OpenSSl EVP库之——非对称算法

  主要是以 p_开头的文件。其中:

•   p_enc.c 封装了公钥加密；
•   p_dec.c 封装了私钥解密；
•   p_lib.c 实现一些辅助函数；
•   p_sign.c 封装了签名函数；
•   p_verify.c 封装了验签函数；
•   p_seal.c 封装了数字信封；
•   p_open.c 封装了解数字信封。

---

1 基本数据结构EVP_PKEY

struct evp_pkey_st 
{
int type;
int save_type;
int references;
const EVP_PKEY_ASN1_METHOD *ameth;
    ENGINE *engine;
union 
    {
char *ptr;
struct rsa_st *rsa;     /* RSA */
struct dsa_st *dsa;     /* DSA */
struct dh_st *dh;       /* DH */
struct ec_key_st *ec;   /* ECC */
    } pkey;
int save_parameters;
    STACK_OF(X509_ATTRIBUTE) *attributes; /* [ 0 ] */
};

  该结构用来存放非对称密钥信息，可以是RSA、DSA、DH 或ECC 密钥。其中，ptr 用来存放密钥结构地址，attributes 堆栈用来存放密钥属性。

2 非对称加密

2.1 加密

int EVP_PKEY_encrypt_old(unsigned char *enc_key,const unsigned char *key, 
int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx);
int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx,unsigned char *out, size_t *outlen,
const unsigned char *in, size_t inlen);

2.2 解密

int EVP_PKEY_decrypt_old(unsigned char *dec_key, const unsigned char *enc_key, 
int enc_key_len,EVP_PKEY *private_key);
int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx);
int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx,unsigned char *out, size_t *outlen,
const unsigned char *in, size_t inlen);

2.3 用法示例

int OpenSSL_EncryptEx(EVP_PKEY *pPubKey,
const unsigned char *data, int data_cb, 
unsigned char* enc, unsigned int *penc_cb)
{
int rv = 0, n = 0;
char szErr[1024];

    rv = EVP_PKEY_encrypt(enc, data, data_cb, pPubKey);
if (rv <= 0) {
        n  = ERR_get_error();
        ERR_error_string( n, szErr );
fprintf( stderr, "OpenSSL_Encrypt: EVP_PKEY_encrypt failed: \nopenssl return %d, %s\n", n, szErr );

        rv = n;
goto enc_ret;
    }

if (*penc_cb) {
        *penc_cb = rv;
    }

    rv = 0;

enc_ret:
return rv;
}

int OpenSSL_DecryptEx(EVP_PKEY *pPriKey,
unsigned char *enc, unsigned int enc_cb,
unsigned char *data, unsigned int *pdata_cb) 
{
int rv = 0, n = 0;
char szErr[1024];

    rv = EVP_PKEY_decrypt(data, enc, enc_cb, pPriKey);
if (rv <= 0) {
        n  = ERR_get_error();
        ERR_error_string( n, szErr );
fprintf( stderr, "OpenSSL_Decrypt: EVP_PKEY_decrypt failed: \nopenssl return %d, %s\n", n, szErr );

        rv = n;
goto enc_ret;
    }

if (*pdata_cb) {
        *pdata_cb = rv;
    }

    rv = 0;

enc_ret:
return rv;
}

3 数字签名

3.1 签名

  EVP_Sign系列函数使用的基础结构跟信息摘要算法使用的基础结构是一样的，而且，其前面的两个操作步骤初始化和数据操作（信息摘要）也跟信息摘要算法是一样的，唯一不一样的是最后一步操作，本系列函数做了签名的工作，而信息摘要系列函数当然就只是简单的处理完摘要信息了事了。其实这是很容易理解的事情，因为签名算法就是在信息摘要之后用私钥进行签名的过程。本系列函数定义的如下(openssl/evp.h)：

     int EVP_SignInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);
int EVP_SignUpdate(EVP_MD_CTX *ctx, const void *d, unsigned int cnt);
int EVP_SignFinal(EVP_MD_CTX *ctx,unsigned char *sig,unsigned int *s, EVP_PKEY *pkey);
void EVP_SignInit(EVP_MD_CTX *ctx, const EVP_MD *type);
int EVP_PKEY_size(EVP_PKEY *pkey);

【EVP_SignInit_ex】
  该函数是一个宏定义函数，其实际定义如下：
   #define EVP_SignInit_ex(a,b,c) EVP_DigestInit_ex(a,b,c)
  可见，该函数跟前面叙述的EVP_DigestInit_ex的功能和使用方法是一样的，都是使用ENGINE参数impl所代表的实现函数功能来设置结构ctx。在调用本函数前，参数ctx一定要经过EVP_MD_CTX_init函数初始化。详细使用方法参看前面的文章介绍。成功返回1，失败返回0。
【EVP_SignUpdate】
  该函数也是一个宏定义函数，其实际定义如下：
  #define EVP_SignUpdate(a,b,c) EVP_DigestUpdate(a,b,c)
  该函数使用方法和功能也跟前面介绍的EVP_DigestUpdate函数一样，将一个cnt字节的数据经过信息摘要运算存储到结构ctx中，该函数可以在一个相同的ctx中调用多次来实现对更多数据的信息摘要工作。成功返回1，失败返回0。
【EVP_SignFinal】
  该函数跟前面两个函数不同，这是签名系列函数跟信息摘要函数开始不同的地方，其实，该函数是将签名操作的信息摘要结构ctx拷贝一份，然后调用EVP_DigestFinal_ex完成信息摘要工作，然后开始对摘要信息用私钥pkey进行签名,并将签名信息保存在参数sig里面。如果参数s不为NULL，那么就会将签名信息数据的长度（单位字节）保存在该参数中，通常写入的数据是EVP_PKEY_size(key)。
  因为操作的时候是拷贝了一份ctx，所以，原来的ctx结构还可以继续使用EVP_SignUpdate和EVP_SignFinal函数来完成更多信息的签名工作。不过，最后一定要使用EVP_MD_CTX_cleanup函数清除和释放ctx结构，否则就会造成内存泄漏。
  此外，当使用DSA私钥签名的时候，一定要对产生的随机数进行种子播种工作（seeded)，否则操作就会失败。RSA算法则不一定需要这样做。至于使用的签名算法跟摘要算法的关系，在EVP_Digest系列中已经有详细说明，这里不再重复。
  本函数操作成功返回1，否则返回0。
【EVP_SignInit】
  本函数也是一个宏定义函数，其定义如下：
  #define EVP_SignInit(a,b) EVP_DigestInit(a,b)
  所以其功能和用法跟前面介绍的EVP_DigestInit函数完全一样，使用缺省实现的算法初始化算法结构ctx。
【EVP_PKEY_size】
  本函数返回一个签名信息的最大长度（单位字节）。实际签名信息的长度则由上述的函数EVP_SignFinal返回，有可能比这小。
  上述所有函数发生错误，可以使用ERR_get_error函数获得错误码。

3.2 认证

  跟EVP_Sign系列函数一样，EVP_Verify系列函数的前两步（初始化和信息摘要处理）跟信息摘要算法是一样的，因为签名验证的过程就是先对信息进行信息摘要，然后再将发来的摘要信息解密后进行比较的过程，其定义如下（openssl/evp.h）：

     int EVP_VerifyInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);
int EVP_VerifyUpdate(EVP_MD_CTX *ctx, const void *d, unsigned int cnt);
int EVP_VerifyFinal(EVP_MD_CTX *ctx,unsigned char *sigbuf, unsigned int siglen,EVP_PKEY *pkey);

int EVP_VerifyInit(EVP_MD_CTX *ctx, const EVP_MD *type);

【EVP_VerifyInit_ex】
  该函数是一个宏定义函数，其实际定义如下：
   #define EVP_VerifyInit_ex(a,b,c) EVP_DigestInit_ex(a,b,c)
  所以，其功能和使用方法跟前面介绍的EVP_DigestInit_ex函数是一样的。该函数使用参数impl所提供的算法库对验证结构ctx进行设置。在调用本函数之前，参数ctx必须经过调用EVP_MD_CTX_init进行初始化。成功返回1，失败返回0。
【EVP_VerifyUpdate】
  该函数也是一个宏定义函数，其实际定义如下：
  #define EVP_VerifyUpdate(a,b,c) EVP_DigestUpdate(a,b,c)
  所以，其功能和使用方法跟前面介绍的EVP_DigestUpdate函数是相同的。该函数将参数d中的cnt字节数据经过信息摘要计算后保存到ctx中，该函数可以进行多次调用，以处理更多的数据。成功调用返回1，失败返回0。
【EVP_VerifyFinal】
  该函数使用公钥pkey和ctx结构里面的信息验证sigbuf里面的数据的签名。事实上，该函数先调用EVP_MD_CTX_copy_ex函数将原来的ctx拷贝一份，然后调用EVP_DigestFinal_ex函数完成拷贝的ctx的信息摘要计算，最后才使用公钥进行签名的验证工作。
  因为该函数实际上处理的是原来ctx函数的一个拷贝，所以原来的ctx结构还可以调用EVP_VerifyUpdate和EVP_VerifyFinal函数进行更多的数据处理和签名验证工作。
  在使用完之后，ctx必须使用EVP_MD_CTX_cleanup函数释放内存，否则就会导致内存泄漏。
  此外，至于信息摘要算法和签名算法的关联的关系，请参照信息摘要算法部分的说明。
  该函数调用成功返回1，失败则返回0或－1。
【EVP_VerifyInit】
  该函数使用缺省的实现算法对ctx结构进行初始化。也是一个宏定义函数，其定义如下：
  #define EVP_VerifyInit(a,b) EVP_DigestInit(a,b)
  所以跟EVP_DigestInit函数功能和用法是一样的。

3.3 用法示例

static int OpenSSL_Sign(EVP_PKEY *pPriKey, 
unsigned char *data, int data_cb, 
unsigned char* sign, unsigned int *psign_cb )
{
const EVP_MD *md = NULL;
    EVP_MD_CTX md_sign_ctx;
int nRet = 0, n = 0;
char szErr[1024];

//根据密钥类型选择摘要算法
switch (pPriKey->type) {
case EVP_PKEY_EC:
        md = EVP_ecdsa();
break;
default:
        md = EVP_sha1();
break;
    }

//摘要上下文初始化
if( !EVP_SignInit ( &md_sign_ctx, md ) ) {
        n  = ERR_get_error();
        ERR_error_string( n, szErr );
fprintf( stderr, "OpenSSL_Sign: EVP_SignInit failed: \nopenssl return %d, %s\n", n, szErr );

        nRet = -1;
goto sign_ret;
    }

//签名所需的摘要计算，如果有多段数据，可以多次调用EVP_SignUpdate
if( ! EVP_SignUpdate(&md_sign_ctx, data, data_cb) ) {
        n  = ERR_get_error();
        ERR_error_string( n, szErr );

fprintf( stderr,"OpenSSL_Sign: EVP_SignUpdate failed: \nopenssl return %d, %s\n", n, szErr );

        nRet = -2;
goto sign_ret;
    }

//计算签名
if( !EVP_SignFinal (&md_sign_ctx, 
            sign, 
            psign_cb, 
            pPriKey ) ) {
        n  = ERR_get_error();
        ERR_error_string( n, szErr );

fprintf( stderr,"OpenSSL_Sign: EVP_SignFinal failed: \nopenssl return %d, %s\n", n, szErr );

        nRet = -3;
goto sign_ret;
    }

sign_ret:
if( !EVP_MD_CTX_cleanup(&md_sign_ctx) ) {
        n  = ERR_get_error();
        ERR_error_string( n, szErr );
fprintf( stderr,"OpenSSL_Sign: EVP_ctx_cleanup failed: \nopenssl return %d, %s\n", n, szErr );
    }

return nRet;
}

static int OpenSSL_Verify(EVP_PKEY *pPubKey, 
unsigned char *data, int data_cb, 
unsigned char* sign, unsigned int sign_cb )
{
const EVP_MD *md = NULL;
    EVP_MD_CTX md_sign_ctx, md_verify_ctx;
int nRet = 0, n = 0;
char szErr[1024];

//根据密钥类型选择摘要算法
switch (pPubKey->type) {
case EVP_PKEY_EC:
        md = EVP_ecdsa();
break;
default:
        md = EVP_sha1();
break;
    }

//摘要上下文初始化
if( !EVP_VerifyInit( &md_verify_ctx, md ) ) {
        n  = ERR_get_error();
        ERR_error_string( n, szErr );

fprintf( stderr, "OpenSSL_Verify: EVP_VerifyInit failed: \nopenssl return %d, %s\n", n, szErr );

        nRet = -4;
goto verify_ret;
    }

//验签所需的摘要计算，如果有多段数据，可以多次调用EVP_VerifyUpdate
if( !EVP_VerifyUpdate(&md_verify_ctx, data, data_cb) ) {
        n  = ERR_get_error();
        ERR_error_string( n, szErr );

fprintf( stderr, "OpenSSL_Verify: EVP_VerifyUpdate failed: \nopenssl return %d, %s\n", n, szErr );

        nRet = -5;
goto verify_ret;
    }

//验证签名
if( !EVP_VerifyFinal(&md_verify_ctx, sign, sign_cb, pPubKey) ) {
        n  = ERR_get_error();
        ERR_error_string( n, szErr );

fprintf( stderr, "OpenSSL_Verify: EVP_VerifyFinal failed: \nopenssl return %d, %s\n", n, szErr );

        nRet = -6;
goto verify_ret;
    }

verify_ret:
if( !EVP_MD_CTX_cleanup(&md_verify_ctx) ) {
        n  = ERR_get_error();
        ERR_error_string( n, szErr );
fprintf( stderr, "OpenSSL_Verify: EVP_ctx_cleanup failed: \nopenssl return %d, %s\n", n, szErr );
    }

return nRet;
}

4 数字信封

4.1 写信

  seal系列函数是相当于完成一个电子信封的功能，它产生一个随机密钥，然后使用一个公钥对改密钥进行封装，数据可以使用随机密钥进行加密。
  信封加密在进行大量数据传输的时候是必须经常要用到的，因为公开密钥算法的加解密速度很慢，但对称算法就快多了。所以一般用公开密钥算法进行加密密钥的传输，而真正进行数据加密则使用对称加密算法。
  其定义的函数如下（openssl/evp.h）：

     int EVP_SealInit(EVP_CIPHER_CTX *ctx, EVP_CIPHER *type, unsigned char **ek,
int *ekl, unsigned char *iv,EVP_PKEY **pubk, int npubk);
int EVP_SealUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
int *outl, unsigned char *in, int inl);
int EVP_SealFinal(EVP_CIPHER_CTX *ctx, unsigned char *out,int *outl);

【EVP_SealInit】
  该函数初始化一个加密算法结构EVP_CIPHER_CTX，采用了指定的加密算法，使用一个随机密钥和初始化向量IV。事实上，该函数调用EVP_EncryptInit_ex函数两次完成了ctx结构的初始化工作。参数type是算法类型，跟签名介绍过的是一样的，为EVP_des_cbc类型的函数。随机私钥被一个或多个公钥加密，这就允许秘钥被公钥相应的私钥解密。参数ek是一个缓存序列，可以存放多个被公钥加密后的密钥的信息，所以每个缓存空间都应该足够大，比如ek[i]的缓存空间就必须为EVP_PKEY_size(pubk[i])那么大。每个被加密密钥的长度保存在数字ekl中。参数pubk是一个公钥陈列，可以包含多个公钥。函数成功执行返回npubk，失败返回0。
  因为该函数的密钥是随机产生的，随意在调用该函数之前，必须对随机数播种（seeded）。
   使用的公钥必须是RSA，因为在openssl里面这是唯一支持密钥传输的公钥算法。
  跟EVP_EncryptInit函数一样，本函数也可以分为两次调用，第一次调用的时候要将参数npubk设为0，第二调用的时候就应该将参数type设为NULL。
【EVP_SealUpdate】
  该函数是一个宏定义函数，其实际定义如下：
  #define EVP_SealUpdate(a,b,c,d,e) EVP_EncryptUpdate(a,b,c,d,e)
  由此可见，其完成的功能和使用方法跟EVP_EncryptUpdate函数是一样的。细节参看前面介绍的文章。成功执行返回1，否则返回0。
【EVP_SealFinal】
  该函数简单调用了EVP_EncryptFinal_ex完成其功能，所以其完成的功能和使用参数也跟EVP_EncryptFinal_ex函数一样，细节请参考相关文章。唯一不一样的是，该函数还调用EVP_EncryptInit_ex(ctx,NULL,NULL,NULL,NULL)函数对ctx结构再次进行了初始化。成功返回1，否则返回0。

4.2 读信

  本系列函数相对于EVP_Seal系列函数，是进行信封加密的。它将公钥加密了的密钥加密出来，然后进行数据的解密。其定义的函数如下（openssl/evp.h）：

     int EVP_OpenInit(EVP_CIPHER_CTX *ctx,EVP_CIPHER *type,unsigned char *ek,
int ekl,unsigned char *iv,EVP_PKEY *priv);
int EVP_OpenUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
int *outl, unsigned char *in, int inl);
int EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out,int *outl);

【EVP_OpenInit】
  该函数初始化一个用来加密数据的ctx结构。它使用参数priv的私钥解密参数ek里面长度为ekl字节的加密密钥。参数iv是初始化向量。如果参数type设定的加密算法长度是可变的，那么密钥长度就会被设置为解密得到的密钥的长度；如果加密算法长度是固定的，那么得到的解密密钥的长度就必须跟固定算法长度相同才行。成功执行返回密钥的长度，否则返回0。
  跟函数EVP_DecryptInit一样，该函数也可以分成多次调用，首次调用应该将参数priv设置为NULL，再次调用的时候应该将type设置为NULL。
【EVP_OpenUpdate】
  该函数是一个宏定义函数，其实际定义如下：
  #define EVP_OpenUpdate(a,b,c,d,e) EVP_DecryptUpdate(a,b,c,d,e)
  所以，其功能和使用方法跟前面介绍过的EVP_DecryptUpdate相同，请参考相应的文章。成功执行返回1，否则返回0。
【EVP_OpenFinal】
  事实上，该函数调用EVP_DecryptFinal_ex完成了其功能，所以其使用方法跟功能跟函数EVP_DecryptFinal_ex是一样的，参考该函数说明就可以。唯一不同的是，本函数还调用EVP_DecryptInit_ex(ctx,NULL,NULL,NULL,NULL)再次进行了初始化工作。成功执行返回1，否则返回0。

4.3 用法示例

void TestPKCS7Enc(EVP_PKEY *pPriKey, X509 *x)
{
int rv = 0;
char szErr[1024] = {0};

    STACK_OF(X509) *certs = sk_X509_new_null();
unsigned char data[32] = {0};
unsigned int data_cb = sizeof(data);
unsigned char enc[8192] = {0};
unsigned int enc_len = sizeof(enc);

unsigned int dec_len = sizeof(enc);
unsigned char *p = NULL;

    PKCS7 *p7 = NULL;
    BIO *in = BIO_new_mem_buf(data, data_cb);
    BIO *out = BIO_new(BIO_s_mem());

    RAND_pseudo_bytes(data, data_cb);
    BIO_dump_fp(stdout, data, data_cb);

    sk_X509_push(certs, x);
    p7 = PKCS7_encrypt(certs, in, EVP_des_cbc(), PKCS7_BINARY);
if (NULL == p7) {
        rv  = ERR_get_error();
        ERR_error_string(rv, szErr);
fprintf( stderr, "TestPKCS7Enc: PKCS7_encrypt failed: \nopenssl return %d, %s\n", rv, szErr );

        rv = -1;
goto err;
    }

    p = enc;
    enc_len = i2d_PKCS7(p7, &p);

    BIO_dump_fp(stdout, enc, enc_len);

if (!PKCS7_decrypt(p7, pPriKey, x, out, PKCS7_BINARY)) {
        rv  = ERR_get_error();
        ERR_error_string(rv, szErr);
fprintf( stderr, "TestPKCS7Enc: PKCS7_decrypt failed: \nopenssl return %d, %s\n", rv, szErr );

        rv = -1;
goto err;
    }

    p = NULL;
    dec_len = BIO_get_mem_data(out, &p);
    BIO_dump_fp(stdout, p, dec_len);

err:
if (p7) {
        PKCS7_free(p7);
        p7 = NULL;
    }

if (in) {
        BIO_free(in);
        in = NULL;
    }

if (out) {
        BIO_free(out);
        in = NULL;
    }

if (certs) {
        sk_X509_free(certs);
        certs = NULL;
    }
}