c++ - 使用来自 USB 令牌的证书和密钥进行数字签名

Question

我想使用来自 USB 令牌（加密狗）的用户密钥和证书签署文件。

我已经在 stackoverflow 和其他网站上搜索了一段时间，但除了 .NET 框架中的一些好的功能（我没有使用）之外，没有得到任何有用的东西。

似乎由于密钥没有暴露，加密是由硬件本身完成的。这是否意味着每个硬件制造商都提供了自己的 API，并且没有通用的方法来解决这个问题？

另外，我读到，一旦将令牌插入计算机，其证书就会加载到系统存储中。是否可以使用商店的证书？如何在商店中识别和访问此类证书？那么私钥呢？

当可以从 .p12 或 .pfx 文件中提取证书时，我使用 OpenSSL 进行数字签名。

如果我在某个地方错了，请纠正我，我是这个话题的新手。

score 12 · Accepted Answer

我不知道我会将 OpenSSL 引擎的任何方面描述为“相当简单”。命令行版本乱七八糟，我自己在代码中做了之后才能弄清楚命令行在做什么。操作顺序和生命周期没有很好地说明（我仍然不完全知道它们是什么，但我的系统正在运行并且不再泄漏内存，所以是的。）

我已经在 github 上发布了功能版本： https ://github.com/tkil/openssl-pkcs11-samples

以下是相关部分的导览tok-sign.c：

首先，一些帮手：

#define FAIL( msg, dest )                      \
    do {                                       \
        fprintf( stderr, "error: " msg "\n" ); \
        goto dest;                             \
    } while ( 0 )

/* mandatory is "not optional"... */
const int CMD_MANDATORY = 0;

该引擎最奇怪的地方可能dynamic在于它实际上是一个元引擎：您向它提供各种参数，当您向它提供各种参数时LOAD，它会加载动态库并提供一个新引擎。一旦您知道正确的操作顺序，它的代码就很简单了。在这里，我们可以访问动态引擎，对其进行配置，然后要求它引入pkcs11引擎：

ENGINE_load_dynamic();
ENGINE * dyn = ENGINE_by_id( "dynamic" );
if ( ! dyn )
    FAIL( "retrieving 'dynamic' engine", free_out_sig_file );

// this is the bridge between OpenSSL and any generic PCKS11 provider:
char * engine_pkcs11_so = "/opt/crypto/lib/engines/engine_pkcs11.so";

if ( 1 != ENGINE_ctrl_cmd_string( dyn, "SO_PATH", engine_pkcs11_so, CMD_MANDATORY ) )
    FAIL( "dyn: setting so_path <= 'engine_pkcs11.so'", free_dyn );

if ( 1 != ENGINE_ctrl_cmd_string( dyn, "ID", "pkcs11", CMD_MANDATORY ) )
    FAIL( "dyn: setting id <= 'pkcs11'", free_dyn );

if ( 1 != ENGINE_ctrl_cmd( dyn, "LIST_ADD", 1, NULL, NULL, CMD_MANDATORY ) )
    FAIL( "dyn: setting list_add <= 1", free_dyn );

if ( 1 != ENGINE_ctrl_cmd( dyn, "LOAD", 1, NULL, NULL, CMD_MANDATORY ) )
    FAIL( "dyn: setting load <= 1", free_dyn );

此时，如果所有这些调用都成功，您的 OpenSSL 实例现在可以访问一个名为“pkcs11”的新引擎。现在我们需要访问那个新引擎，正确配置它，并让它自己初始化：

ENGINE * pkcs11 = ENGINE_by_id( "pkcs11" );
if ( ! pkcs11 )
    FAIL( "pkcs11: unable to get engine", free_dyn );

// this is the actual pkcs11 provider we're using.  in this case, it's
// from the OpenSC package.
char * opensc_pkcs11_so = "/opt/crypto/lib/opensc-pkcs11.so";

if ( 1 != ENGINE_ctrl_cmd_string( pkcs11, "MODULE_PATH", opensc_pkcs11_so, CMD_MANDATORY ) )
    FAIL( "setting module_path <= 'opensc-pkcs11.so'", free_pkcs11 );

if ( 1 != ENGINE_ctrl_cmd_string( pkcs11, "PIN", key_pin, CMD_MANDATORY ) )
    FAIL( "setting pin", free_pkcs11 );

if ( 1 != ENGINE_init( pkcs11 ) )
    FAIL( "pkcs11: unable to initialize engine", free_pkcs11 );

现在我们可以访问令牌，我们可以获取用于 OpenSSL 操作的私钥：

EVP_PKEY * key = ENGINE_load_private_key( pkcs11, key_id, NULL, NULL );
if ( ! key )
    FAIL( "reading private key", free_pkcs11 );

但是想不通怎么通过ENGINE接口提取对应的证书，所以直接去LibP11：

PKCS11_CTX * p11_ctx = PKCS11_CTX_new();
if ( ! p11_ctx )
    FAIL( "opening pkcs11 context", free_key );

if ( 0 != PKCS11_CTX_load( p11_ctx, opensc_pkcs11_so ) )
    FAIL( "unable to load module", free_p11_ctx );

PKCS11_SLOT * p11_slots;
unsigned int num_p11_slots;
if ( 0 != PKCS11_enumerate_slots( p11_ctx, &p11_slots, &num_p11_slots ) )
    FAIL( "enumerating slots", free_p11_ctx_module );

PKCS11_SLOT * p11_used_slot =
  PKCS11_find_token( p11_ctx, p11_slots, num_p11_slots );
if ( ! p11_used_slot )
    FAIL( "finding token", free_p11_slots );

PKCS11_CERT * p11_certs;
unsigned int num_p11_certs;
if ( 0 != PKCS11_enumerate_certs( p11_used_slot->token, &p11_certs, &num_p11_certs ) )
    FAIL( "enumerating certs", free_p11_slots );

最后，我们开始为 CMS_Sign 请求收集数据。我们查看令牌上的所有证书，挑选出与私钥对应的证书，然后将其余证书存储在 OpenSSL 中STACK_OF(X509)：

STACK_OF(X509) * extra_certs = sk_X509_new_null();
if ( ! extra_certs )
    FAIL( "allocating extra certs", free_p11_slots );

X509 * key_cert = NULL;
for ( unsigned int i = 0; i < num_p11_certs; ++i )
{
    PKCS11_CERT * p11_cert = p11_certs + i;

    if ( ! p11_cert->label )
        continue;

    // fprintf( stderr, "p11: got cert label='%s', x509=%p\n",
    //         p11_cert->label, p11_cert->x509 );

    if ( ! p11_cert->x509 )
    {
        fprintf( stderr, "p11: ... no x509, ignoring\n" );
        continue;
    }

    const char * label = p11_cert->label;
    const unsigned int label_len = strlen( label );

    if ( strcmp( label, key_label ) == 0 )
    {
        // fprintf( stderr, "p11: ... saving as signing cert\n" );
        key_cert = p11_cert->x509;
    }
    else if ( strncmp( label, "encrypt", 7 ) == 0 &&
              label_len == 8 &&
              '0' <= label[7] && label[7] <= '3' )
    {
        // fprintf( stderr, "p11: ... ignoring as encrypting cert\n" );
    }
    else
    {
        // fprintf( stderr, "p11: ... saving as extra cert\n" );
        if ( ! sk_X509_push( extra_certs, p11_cert->x509 ) )
            FAIL( "pushing extra cert", free_extra_certs );
    }
}

if ( ! key_cert )
    FAIL( "finding signing cert", free_extra_certs );

最后，我们可以对数据进行签名，然后将签名输出到 DER 格式的文件中：

CMS_ContentInfo * ci = CMS_sign( key_cert, key, extra_certs, in_data_file,
                                 CMS_DETACHED | CMS_BINARY );
if ( ! ci )
    FAIL( "could not create signing structure", free_extra_certs );

if ( 1 != i2d_CMS_bio( out_sig_file, ci ) )
       FAIL( "could not write signature in DER", free_ci );

之后，它只是清理：

free_ci:
    CMS_ContentInfo_free( ci );

free_extra_certs:
    /* these certs are actually "owned" by the libp11 code, and are
     * presumably freed with the slot or context. */
    sk_X509_free( extra_certs );

free_p11_slots:
    PKCS11_release_all_slots( p11_ctx, p11_slots, num_p11_slots );

free_p11_ctx_module:
    PKCS11_CTX_unload( p11_ctx );

free_p11_ctx:
    PKCS11_CTX_free( p11_ctx );

free_key:
    EVP_PKEY_free( key );

free_pkcs11:
    ENGINE_free( pkcs11 );

free_dyn:
    ENGINE_free( dyn );

score 8 · Accepted Answer

您可以通过使用 OpenSSL 的引擎并为其提供 PKCS#11 引擎来做到这一点。

这可以从命令行（-engine 标志）或通过设置引擎来完成。openssl 发行版的 /apps/ 中的 apps.c 有很好的例子。

命令行的典型调用形式如下

usr/bin/openssl << EOM
engine dynamic -pre SO_PATH:/Library/OpenSC/lib/engines/engine_pkcs11.so  -pre ID:pkcs11 -pre LIST_ADD:1 -pre LOAD -pre MODULE_PATH:opensc-pkcs11.so
req -engine pkcs11 -batch -subj "/CN=moi" -new -key slot_$SLOT-id_$KID -keyform engine -x509 -out cert.pem -text
EOM

它在设备上创建并签署一个请求。

签署某事：

${OPENSSL} << EOM || exit 1
engine -vvvv dynamic \
    -pre SO_PATH:/Library/OpenSC/lib/engines/engine_pkcs11.so  \
    -pre ID:pkcs11 \
    -pre LIST_ADD:1 \
    -pre LOAD \
    -pre MODULE_PATH:$PKCS \
    -pre PIN:$PIN  \
    -pre VERBOSE 

x509 -engine pkcs11 -req -in req.csr -out signed.pem \
    -CAfile $CA \
    -keyform engine -key $SLOT:$CAKID \
    -cert $CAKID.pem

请注意，尽管对于后者，未修补的 openssl 不允许引用卡上的证书（仅密钥）。因此，需要先将其提取并存储为文件。

并使用卡上的密钥将客户端身份验证连接到服务器：

${OPENSSL} << EOM || exit 1
engine -vvvv dynamic \
    -pre SO_PATH:/Library/OpenSC/lib/engines/engine_pkcs11.so  \
    -pre ID:pkcs11 \
    -pre LIST_ADD:1 \
    -pre LOAD \
    -pre MODULE_PATH:$PKCS \
    -pre PIN:$PIN  \
    -pre VERBOSE 

s_client -engine pkcs11 -connect localhost:1443 \
    -CAfile $CA \
    -keyform engine -key $SLOT:$KID \
    -cert $KID.pem

EOM

这很容易翻译成本机代码——只需在 openssl apps.c 文件中的 apps.c 中搜索引擎——看看它是如何完成的。在大多数情况下，它是一些

pkey = ENGINE_load_private_key(e, file,

与旧的相反

BIO_read_filename(key,file)
pkey=d2i_PrivateKey_bio(key, NULL);

score 5 · Accepted Answer

存在2个选项：

PKCS#11。几乎每个 USB 加密令牌和智能卡供应商都为您可以调用的 PKCS#11 提供驱动程序 DLL。我需要注意 PKCS#11 接口规范非常松散，这会导致不同供应商之间的怪癖和不兼容。即，您可能需要在一台设备中使用一组证书属性，而在另一台设备中使用不同的一组属性。
加密API。大多数供应商提供一个 CryptoAPI 模块 (CSP)，它将证书“映射”到 Windows 证书存储中，并且您使用它进行签名的方式与在 Windows 证书存储中使用任何证书的方式相同。这意味着在 Windows API 中使用各种 Crypt* 、 Cert* 和类似函数。

我认为 OpenSSL 不能用于您的任务 - 您需要使用 CryptoAPI 或 PKCS#11。

我们的SecureBlackbox产品提供统一的高级接口，用于根据各种加密标准并使用 PKCS#11 和/或 CryptoAPI 对数据进行签名。仍然在 PKCS#11 的情况下，您（或完成签名的系统的操作员）需要知道 PKCS#11 驱动程序 DLL 的路径。SecureBlackbox 可以使用其库版本从 C++ 中使用。

c++ - 使用来自 USB 令牌的证书和密钥进行数字签名

3 回答 3

Related

Reference