HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/pkcs11-util.c

86,914 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 88cdffa4b6128d0680badc0bb5f078f07a8ed062

Lines 2001–2140 of 2,140

        if (r < 0 && r != -EAGAIN)
                return r;
 
        if (table_isempty(t)) {
                log_info("No suitable PKCS#11 tokens found.");
                return 0;
        }
 
        return table_print_or_warn(t);
#else
        return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                               "PKCS#11 tokens not supported on this build.");
#endif
}
 
#if HAVE_P11KIT
static int auto_callback(
                CK_FUNCTION_LIST *m,
                CK_SESSION_HANDLE session,
                CK_SLOT_ID slot_id,
                const CK_SLOT_INFO *slot_info,
                const CK_TOKEN_INFO *token_info,
                P11KitUri *uri,
                void *userdata) {
 
        _cleanup_(p11_kit_uri_freep) P11KitUri *token_uri = NULL;
        char **t = userdata;
        int uri_result, r;
 
        assert(slot_info);
        assert(token_info);
 
        r = dlopen_p11kit(LOG_DEBUG);
        if (r < 0)
                return r;
 
        if (!FLAGS_SET(token_info->flags, CKF_HW_SLOT|CKF_TOKEN_PRESENT))
                return -EAGAIN;
 
        if (*t)
                return log_error_errno(SYNTHETIC_ERRNO(ENOTUNIQ),
                                       "More than one suitable PKCS#11 token found.");
 
        token_uri = uri_from_token_info(token_info);
        if (!token_uri)
                return log_oom();
 
        uri_result = sym_p11_kit_uri_format(token_uri, P11_KIT_URI_FOR_ANY, t);
        if (uri_result != P11_KIT_URI_OK)
                return log_warning_errno(SYNTHETIC_ERRNO(EAGAIN), "Failed to format slot URI: %s", sym_p11_kit_uri_message(uri_result));
 
        return 0;
}
#endif
 
int pkcs11_find_token_auto(char **ret) {
#if HAVE_P11KIT
        int r;
 
        r = pkcs11_find_token(NULL, auto_callback, ret);
        if (r == -EAGAIN)
                return log_error_errno(SYNTHETIC_ERRNO(ENODEV), "No suitable PKCS#11 tokens found.");
        if (r < 0)
                return r;
 
        return 0;
#else
        return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                               "PKCS#11 tokens not supported on this build.");
#endif
}
 
#if HAVE_P11KIT
void pkcs11_crypt_device_callback_data_release(pkcs11_crypt_device_callback_data *data) {
        erase_and_free(data->decrypted_key);
 
        if (data->free_encrypted_key)
                free(data->encrypted_key);
}
 
int pkcs11_crypt_device_callback(
                CK_FUNCTION_LIST *m,
                CK_SESSION_HANDLE session,
                CK_SLOT_ID slot_id,
                const CK_SLOT_INFO *slot_info,
                const CK_TOKEN_INFO *token_info,
                P11KitUri *uri,
                void *userdata) {
 
        pkcs11_crypt_device_callback_data *data = ASSERT_PTR(userdata);
        CK_OBJECT_HANDLE object;
        int r;
 
        assert(m);
        assert(slot_info);
        assert(token_info);
        assert(uri);
 
        /* Called for every token matching our URI */
 
        r = pkcs11_token_login(
                        m,
                        session,
                        slot_id,
                        token_info,
                        data->friendly_name,
                        "drive-harddisk",
                        "pkcs11-pin",
                        data->askpw_credential,
                        data->until,
                        data->askpw_flags,
                        NULL);
        if (r < 0)
                return r;
 
        /* We are likely called during early boot, where entropy is scarce. Mix some data from the PKCS#11
         * token, if it supports that. It should be cheap, given that we already are talking to it anyway and
         * shouldn't hurt. */
        (void) pkcs11_token_acquire_rng(m, session);
 
        r = pkcs11_token_find_private_key(m, session, uri, &object);
        if (r < 0)
                return r;
 
        r = pkcs11_token_decrypt_data(
                        m,
                        session,
                        object,
                        data->encrypted_key,
                        data->encrypted_key_size,
                        data->rsa_padding,
                        &data->decrypted_key,
                        &data->decrypted_key_size);
        if (r < 0)
                return r;
 
        return 0;
}
#endif