Die digitale Signatur mittels Zertifikat und-Schlüssel vom USB-token

Weiß ich nicht, ich würde prägen einen Aspekt von OpenSSL-engines als "ziemlich einfach". Die command-line-version ist, ist es chaotisch, und ich konnte nur herausfinden, was der Befehl-Linie war dabei, nachdem ich es im code selbst. Die Reihenfolge der Operationen und die Lebensdauer sind nicht aufgerufen, die sehr gut (und ich noch nicht ganz wissen, was diese sind, aber ich habe mein system laufen-und nicht länger ein Speicherleck, also yay.)

Habe ich bis funktionierende Versionen auf github: https://github.com/tkil/openssl-pkcs11-samples

Hier ist eine Führung durch die relevanten Teile des tok-sign.c:

Zunächst einige Helfer:

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

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

Wohl die merkwürdigste Sache, über die dynamic Motor ist, dass es wirklich ein meta-engine: Sie füttern es verschiedene Parameter, und wenn Sie es füttern LOAD wird, lädt die dynamische Bibliothek und macht einen neuen Motor zur Verfügung. Es ist einfach in den code, sobald Sie wissen, die richtige Reihenfolge der Operationen. Wir bekommen hier Zugang zu den dynamischen Motor, konfigurieren, und dann bitten, es zu bringen in die pkcs11 Motor:

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 );

An diesem Punkt, wenn alle diese Aufrufe gelungen, Ihre OpenSSL-Instanz hat nun Zugriff auf eine neue engine namens "pkcs11". Jetzt müssen wir den Zugriff auf die neue engine, konfigurieren Sie es richtig, und lassen Sie es zu initialisieren selbst:

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 );

Nun, wir haben Zugang zu den token, den wir bekommen können die privaten Schlüssel für die Verwendung im OpenSSL-Operationen:

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

Allerdings konnte ich nicht herausfinden, wie die zum extrahieren der entsprechenden Bescheinigung durch das MOTOR-interface, also ging ich direkt zu 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 );

Endlich, wir beginnen, Daten zu sammeln für die CMS_Sign Anfrage. Wir schauen uns alle die Zertifikate auf dem token, wählen Sie diejenige, die dem privaten Schlüssel und speichern Sie den rest in ein 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 );

Endlich können wir signieren der Daten, dann Ausgabe die Unterschrift in einem DER-formatierte Datei:

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 );

Nach, es ist einfach Aufräumen:

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 );

InformationsquelleAutor AnthonyFoiani