OpenSSL中的EVP接口

最新推荐文章于 2024-06-27 12:50:37 发布
最新推荐文章于 2024-06-27 12:50:37 发布
阅读量4.8k 收藏 27
点赞数 6
文章标签： openssl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/doushi/article/details/122800215
版权
本文详细介绍了如何使用 OpenSSL 的 EVP_API 进行摘要算法和对称加密操作。通过 EVP_MD 结构获取不同摘要算法，如 MD5、SHA1、AES 等，并展示了 EVP_MD_CTX API 的使用方法。同时，对称加密部分列举了多种加密算法，如 AES、DES，并提供了 EVP_CIPHER_CTX API 的初始化、更新、最终化等步骤。此外，还涉及了密钥管理和加解密的统一API。
摘要由CSDN通过智能技术生成

索引

摘要算法（Digest）

EVP_MD结构保存了摘要算法的实现，相同的API，使用不同的EVP_MD，就可以实现不同的摘要算法。

获取EVP_MD

直接根据算法获取：

        #include <openssl/evp.h>

        const EVP_MD *EVP_md2(void);
        const EVP_MD *EVP_md4(void);
        const EVP_MD *EVP_md5(void);
        const EVP_MD *EVP_md5_sha1(void);
        const EVP_MD *EVP_mdc2(void);
        const EVP_MD *EVP_ripemd160(void);
        const EVP_MD *EVP_sha1(void);
        const EVP_MD *EVP_sha224(void);
        const EVP_MD *EVP_sha256(void);
        const EVP_MD *EVP_sha512_224(void);
        const EVP_MD *EVP_sha512_256(void);
        const EVP_MD *EVP_sha384(void);
        const EVP_MD *EVP_sha512(void);
        const EVP_MD *EVP_sha3_224(void);
        const EVP_MD *EVP_sha3_256(void);
        const EVP_MD *EVP_sha3_384(void);
        const EVP_MD *EVP_sha3_512(void);
        const EVP_MD *EVP_shake128(void);
        const EVP_MD *EVP_shake256(void);
        const EVP_MD *EVP_sm3(void);
        const EVP_MD *EVP_whirlpool(void);

根据名字查找：

        EVP_MD *EVP_MD_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
                             const char *properties);
        int EVP_MD_up_ref(EVP_MD *md);
        void EVP_MD_free(EVP_MD *md);
        
        const EVP_MD *EVP_get_digestbyname(const char *name);
        const EVP_MD *EVP_get_digestbynid(int type);
        const EVP_MD *EVP_get_digestbyobj(const ASN1_OBJECT *o);

OpenSSL3.0之前的版本使用EVP_get_digestbyname，OpenSSL3.0使用EVP_MD_fetch。

获取摘要长度和数据块长度（字节）

int EVP_MD_get_size(const EVP_MD *md);
#define EVP_MD_size EVP_MD_get_size
int EVP_MD_CTX_get_size(const EVP_MD_CTX *ctx);
#define EVP_MD_CTX_size EVP_MD_CTX_get_size

int EVP_MD_get_block_size(const EVP_MD *md);
#define EVP_MD_block_size EVP_MD_get_block_size
int EVP_MD_CTX_get_block_size(const EVP_MD_CTX *ctx);
#define EVP_MD_CTX_block_size EVP_MD_CTX_get_block_size

通常block size对Digest算法没什么意义。

Digest API

        EVP_MD_CTX *EVP_MD_CTX_new(void);
        int EVP_MD_CTX_reset(EVP_MD_CTX *ctx);
        void EVP_MD_CTX_free(EVP_MD_CTX *ctx);

        int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
        int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d, size_t cnt);
        int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s);

例子

        #include <stdio.h>
        #include <string.h>
        #include <openssl/evp.h>

        int main(int argc, char *argv[])
        {
            EVP_MD_CTX *mdctx;
            const EVP_MD *md;
            char mess1[] = "Test Message\n";
            char mess2[] = "Hello World\n";
            unsigned char md_value[EVP_MAX_MD_SIZE];
            unsigned int md_len, i;

            if (argv[1] == NULL) {
                printf("Usage: mdtest digestname\n");
                exit(1);
            }

            md = EVP_get_digestbyname(argv[1]);
            if (md == NULL) {
                printf("Unknown message digest %s\n", argv[1]);
                exit(1);
            }

            mdctx = EVP_MD_CTX_new();
            EVP_DigestInit_ex2(mdctx, md, NULL);
            EVP_DigestUpdate(mdctx, mess1, strlen(mess1));
            EVP_DigestUpdate(mdctx, mess2, strlen(mess2));
            EVP_DigestFinal_ex(mdctx, md_value, &md_len);
            EVP_MD_CTX_free(mdctx);

            printf("Digest is: ");
            for (i = 0; i < md_len; i++)
                printf("%02x", md_value[i]);
            printf("\n");

            exit(0);
        }

对称加密（Cipher）

EVP_CIPHER结构保存了加密算法的实现，相同的API，使用不同的EVP_CIPHER，就可以实现不同的加密算法。

获取EVP_CIPHER

直接根据算法获取：

        #include <openssl/evp.h>

        const EVP_CIPHER *EVP_enc_null(void);
        const EVP_CIPHER *EVP_ciphername(void)

   EVP_ciphername is used a placeholder for any of the described cipher functions, such as EVP_des_cbc.

   EVP_des_cbc, EVP_des_cfb, EVP_des_cfb1, EVP_des_cfb8, EVP_des_cfb64, EVP_des_ecb, EVP_des_ofb, EVP_des_ede, EVP_des_ede_cbc,
   EVP_des_ede_cfb, EVP_des_ede_cfb64, EVP_des_ede_ecb, EVP_des_ede_ofb, EVP_des_ede3, EVP_des_ede3_cbc, EVP_des_ede3_cfb,
   EVP_des_ede3_cfb1, EVP_des_ede3_cfb8, EVP_des_ede3_cfb64, EVP_des_ede3_ecb, EVP_des_ede3_ofb, EVP_des_ede3_wrap - EVP DES cipher
   
   EVP_desx_cbc - EVP DES-X cipher

   EVP_aes_128_cbc, EVP_aes_192_cbc, EVP_aes_256_cbc, EVP_aes_128_cfb, EVP_aes_192_cfb, EVP_aes_256_cfb, EVP_aes_128_cfb1,
   EVP_aes_192_cfb1, EVP_aes_256_cfb1, EVP_aes_128_cfb8, EVP_aes_192_cfb8, EVP_aes_256_cfb8, EVP_aes_128_ctr, EVP_aes_192_ctr,
   EVP_aes_256_ctr, EVP_aes_128_ecb, EVP_aes_192_ecb, EVP_aes_256_ecb, EVP_aes_128_ofb, EVP_aes_192_ofb, EVP_aes_256_ofb,
   EVP_aes_128_cbc_hmac_sha1, EVP_aes_256_cbc_hmac_sha1, EVP_aes_128_cbc_hmac_sha256, EVP_aes_256_cbc_hmac_sha256, EVP_aes_128_ccm,
   EVP_aes_192_ccm, EVP_aes_256_ccm, EVP_aes_128_gcm, EVP_aes_192_gcm, EVP_aes_256_gcm, EVP_aes_128_ocb, EVP_aes_192_ocb,
   EVP_aes_256_ocb, EVP_aes_128_wrap, EVP_aes_192_wrap, EVP_aes_256_wrap, EVP_aes_128_wrap_pad, EVP_aes_192_wrap_pad,
   EVP_aes_256_wrap_pad, EVP_aes_128_xts, EVP_aes_256_xts - EVP AES cipher

   EVP_aria_128_cbc, EVP_aria_192_cbc, EVP_aria_256_cbc, EVP_aria_128_cfb, EVP_aria_192_cfb, EVP_aria_256_cfb, EVP_aria_128_cfb1,
   EVP_aria_192_cfb1, EVP_aria_256_cfb1, EVP_aria_128_cfb8, EVP_aria_192_cfb8, EVP_aria_256_cfb8, EVP_aria_128_ctr, EVP_aria_192_ctr,
   EVP_aria_256_ctr, EVP_aria_128_ecb, EVP_aria_192_ecb, EVP_aria_256_ecb, EVP_aria_128_ofb, EVP_aria_192_ofb, EVP_aria_256_ofb,
   EVP_aria_128_ccm, EVP_aria_192_ccm, EVP_aria_256_ccm, EVP_aria_128_gcm, EVP_aria_192_gcm, EVP_aria_256_gcm

   EVP_bf_cbc, EVP_bf_cfb, EVP_bf_cfb64, EVP_bf_ecb, EVP_bf_ofb - EVP Blowfish cipher

   EVP_blake2b512, EVP_blake2s256 - BLAKE2 For EVP

   EVP_camellia_128_cbc, EVP_camellia_192_cbc, EVP_camellia_256_cbc, EVP_camellia_128_cfb, EVP_camellia_192_cfb, EVP_camellia_256_cfb,
   EVP_camellia_128_cfb1, EVP_camellia_192_cfb1, EVP_camellia_256_cfb1, EVP_camellia_128_cfb8, EVP_camellia_192_cfb8,
   EVP_camellia_256_cfb8, EVP_camellia_128_ctr, EVP_camellia_192_ctr, EVP_camellia_256_ctr, EVP_camellia_128_ecb, EVP_camellia_192_ecb,
   EVP_camellia_256_ecb, EVP_camellia_128_ofb, EVP_camellia_192_ofb, EVP_camellia_256_ofb - EVP Camellia cipher

   EVP_cast5_cbc, EVP_cast5_cfb, EVP_cast5_cfb64, EVP_cast5_ecb, EVP_cast5_ofb - EVP CAST cipher

   EVP_chacha20, EVP_chacha20_poly1305 - EVP ChaCha20 stream cipher

   EVP_idea_cbc, EVP_idea_cfb, EVP_idea_cfb64, EVP_idea_ecb, EVP_idea_ofb - EVP IDEA cipher

   EVP_rc2_cbc, EVP_rc2_cfb, EVP_rc2_cfb64, EVP_rc2_ecb, EVP_rc2_ofb, EVP_rc2_40_cbc, EVP_rc2_64_cbc - EVP RC2 cipher

   EVP_rc4, EVP_rc4_40, EVP_rc4_hmac_md5 - EVP RC4 stream cipher

   EVP_rc5_32_12_16_cbc, EVP_rc5_32_12_16_cfb, EVP_rc5_32_12_16_cfb64, EVP_rc5_32_12_16_ecb, EVP_rc5_32_12_16_ofb - EVP RC5 cipher

   EVP_seed_cbc, EVP_seed_cfb, EVP_seed_cfb128, EVP_seed_ecb, EVP_seed_ofb - EVP SEED cipher

   EVP_sm4_cbc, EVP_sm4_ecb, EVP_sm4_cfb, EVP_sm4_cfb128, EVP_sm4_ofb, EVP_sm4_ctr - EVP SM4 cipher

根据名字查找：

        EVP_CIPHER *EVP_CIPHER_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
                                     const char *properties);
        int EVP_CIPHER_up_ref(EVP_CIPHER *cipher);
        void EVP_CIPHER_free(EVP_CIPHER *cipher);
        
        const EVP_CIPHER *EVP_get_cipherbyname(const char *name);
        const EVP_CIPHER *EVP_get_cipherbynid(int nid);
        const EVP_CIPHER *EVP_get_cipherbyobj(const ASN1_OBJECT *a);

OpenSSL3.0之前的版本使用EVP_get_digestbyname，OpenSSL3.0使用EVP_MD_fetch。

Cipher API

上下文管理

        EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void);
        int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *ctx);
        void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx);

Encrypt API

        int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                            const unsigned char *key, const unsigned char *iv);
        int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                               ENGINE *impl, const unsigned char *key, const unsigned char *iv);
        int EVP_EncryptInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                                const unsigned char *key, const unsigned char *iv,
                                const OSSL_PARAM params[]);
                                
        int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
                              int *outl, const unsigned char *in, int inl);
                              
        int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
       int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);

Decrypt API

        int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                            const unsigned char *key, const unsigned char *iv);
        int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                               ENGINE *impl, const unsigned char *key, const unsigned char *iv);
        int EVP_DecryptInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                                const unsigned char *key, const unsigned char *iv,
                                const OSSL_PARAM params[]);

        int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
                              int *outl, const unsigned char *in, int inl);

        int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
        int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);

加解密统一API

        int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                           const unsigned char *key, const unsigned char *iv, int enc);
        int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                              ENGINE *impl, const unsigned char *key, const unsigned char *iv, int enc);
        int EVP_CipherInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                               const unsigned char *key, const unsigned char *iv,
                               int enc, const OSSL_PARAM params[]);

        int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
                             int *outl, const unsigned char *in, int inl);

        int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
        int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);

其他设置

        int EVP_CIPHER_get_block_size(const EVP_CIPHER *e);
        int EVP_CIPHER_get_key_length(const EVP_CIPHER *e);
        int EVP_CIPHER_get_iv_length(const EVP_CIPHER *e);
        int EVP_CIPHER_CTX_get_block_size(const EVP_CIPHER_CTX *ctx);
        int EVP_CIPHER_CTX_get_key_length(const EVP_CIPHER_CTX *ctx);
        int EVP_CIPHER_CTX_get_iv_length(const EVP_CIPHER_CTX *ctx);
         int EVP_CIPHER_CTX_get_tag_length(const EVP_CIPHER_CTX *ctx);

        int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *x, int padding);
        int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen);
        int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key);
        int EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md,
                           const unsigned char *salt,
                           const unsigned char *data, int datal, int count,
                           unsigned char *key, unsigned char *iv);

        
        int EVP_CIPHER_CTX_is_encrypting(const EVP_CIPHER_CTX *ctx);

        #define EVP_CIPHER_block_size EVP_CIPHER_get_block_size
        #define EVP_CIPHER_key_length EVP_CIPHER_get_key_length
        #define EVP_CIPHER_iv_length EVP_CIPHER_get_iv_length
        #define EVP_CIPHER_CTX_encrypting EVP_CIPHER_CTX_is_encrypting
        #define EVP_CIPHER_CTX_block_size EVP_CIPHER_CTX_get_block_size
        #define EVP_CIPHER_CTX_key_length EVP_CIPHER_CTX_get_key_length
        #define EVP_CIPHER_CTX_iv_length EVP_CIPHER_CTX_get_iv_length
        #define EVP_CIPHER_CTX_tag_length EVP_CIPHER_CTX_get_tag_length

例子

非对称加密

密钥管理

公钥算法上下文 EVP_PKEY_CTX

        #include <openssl/evp.h>

        EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e);
        EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e);
        EVP_PKEY_CTX *EVP_PKEY_CTX_new_from_name(OSSL_LIB_CTX *libctx,
                                                 const char *name,
                                                 const char *propquery);
        EVP_PKEY_CTX *EVP_PKEY_CTX_new_from_pkey(OSSL_LIB_CTX *libctx,
                                                 EVP_PKEY *pkey,
                                                 const char *propquery);
        EVP_PKEY_CTX *EVP_PKEY_CTX_dup(const EVP_PKEY_CTX *ctx);
        void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_CTX_is_a(EVP_PKEY_CTX *ctx, const char *keytype);

常用的可能是EVP_PKEY_CTX_new_from_name和EVP_PKEY_CTX_new

各种参数设置

        #include <openssl/evp.h>

        int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
                              int cmd, int p1, void *p2);
        int EVP_PKEY_CTX_ctrl_uint64(EVP_PKEY_CTX *ctx, int keytype, int optype,
                                     int cmd, uint64_t value);
        int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
                                  const char *value);

        int EVP_PKEY_CTX_md(EVP_PKEY_CTX *ctx, int optype, int cmd, const char *md);

        int EVP_PKEY_CTX_set_signature_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
        int EVP_PKEY_CTX_get_signature_md(EVP_PKEY_CTX *ctx, const EVP_MD **pmd);

        int EVP_PKEY_CTX_set_mac_key(EVP_PKEY_CTX *ctx, const unsigned char *key,
                                     int len);
        int EVP_PKEY_CTX_set_group_name(EVP_PKEY_CTX *ctx, const char *name);
        int EVP_PKEY_CTX_get_group_name(EVP_PKEY_CTX *ctx, char *name, size_t namelen);

        int EVP_PKEY_CTX_set_kem_op(EVP_PKEY_CTX *ctx, const char *op);

        #include <openssl/rsa.h>

        int EVP_PKEY_CTX_set_rsa_padding(EVP_PKEY_CTX *ctx, int pad);
        int EVP_PKEY_CTX_get_rsa_padding(EVP_PKEY_CTX *ctx, int *pad);
        int EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int saltlen);
        int EVP_PKEY_CTX_get_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int *saltlen);
        int EVP_PKEY_CTX_set_rsa_keygen_bits(EVP_PKEY_CTX *ctx, int mbits);
        int EVP_PKEY_CTX_set1_rsa_keygen_pubexp(EVP_PKEY_CTX *ctx, BIGNUM *pubexp);
        int EVP_PKEY_CTX_set_rsa_keygen_primes(EVP_PKEY_CTX *ctx, int primes);
        int EVP_PKEY_CTX_set_rsa_mgf1_md_name(EVP_PKEY_CTX *ctx, const char *mdname,
                                            const char *mdprops);
        int EVP_PKEY_CTX_set_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
        int EVP_PKEY_CTX_get_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
        int EVP_PKEY_CTX_get_rsa_mgf1_md_name(EVP_PKEY_CTX *ctx, char *name,
                                              size_t namelen);
        int EVP_PKEY_CTX_set_rsa_oaep_md_name(EVP_PKEY_CTX *ctx, const char *mdname,
                                              const char *mdprops);
        int EVP_PKEY_CTX_set_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
        int EVP_PKEY_CTX_get_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
        int EVP_PKEY_CTX_get_rsa_oaep_md_name(EVP_PKEY_CTX *ctx, char *name,
                                              size_t namelen);
        int EVP_PKEY_CTX_set0_rsa_oaep_label(EVP_PKEY_CTX *ctx, void *label,
                                             int len);
        int EVP_PKEY_CTX_get0_rsa_oaep_label(EVP_PKEY_CTX *ctx, unsigned char **label);

        #include <openssl/dsa.h>

        int EVP_PKEY_CTX_set_dsa_paramgen_bits(EVP_PKEY_CTX *ctx, int nbits);
        int EVP_PKEY_CTX_set_dsa_paramgen_q_bits(EVP_PKEY_CTX *ctx, int qbits);
        int EVP_PKEY_CTX_set_dsa_paramgen_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
        int EVP_PKEY_CTX_set_dsa_paramgen_md_props(EVP_PKEY_CTX *ctx,
                                                   const char *md_name,
                                                   const char *md_properties);
        int EVP_PKEY_CTX_set_dsa_paramgen_type(EVP_PKEY_CTX *ctx, const char *name);
        int EVP_PKEY_CTX_set_dsa_paramgen_gindex(EVP_PKEY_CTX *ctx, int gindex);
        int EVP_PKEY_CTX_set_dsa_paramgen_seed(EVP_PKEY_CTX *ctx,
                                               const unsigned char *seed,
                                               size_t seedlen);

        #include <openssl/dh.h>

        int EVP_PKEY_CTX_set_dh_paramgen_prime_len(EVP_PKEY_CTX *ctx, int len);
        int EVP_PKEY_CTX_set_dh_paramgen_subprime_len(EVP_PKEY_CTX *ctx, int len);
        int EVP_PKEY_CTX_set_dh_paramgen_generator(EVP_PKEY_CTX *ctx, int gen);
        int EVP_PKEY_CTX_set_dh_paramgen_type(EVP_PKEY_CTX *ctx, int type);
        int EVP_PKEY_CTX_set_dh_pad(EVP_PKEY_CTX *ctx, int pad);
        int EVP_PKEY_CTX_set_dh_nid(EVP_PKEY_CTX *ctx, int nid);
        int EVP_PKEY_CTX_set_dh_rfc5114(EVP_PKEY_CTX *ctx, int rfc5114);
        int EVP_PKEY_CTX_set_dhx_rfc5114(EVP_PKEY_CTX *ctx, int rfc5114);
        int EVP_PKEY_CTX_set_dh_paramgen_gindex(EVP_PKEY_CTX *ctx, int gindex);
        int EVP_PKEY_CTX_set_dh_paramgen_seed(EVP_PKEY_CTX *ctx,
                                               const unsigned char *seed,
                                               size_t seedlen);
        int EVP_PKEY_CTX_set_dh_kdf_type(EVP_PKEY_CTX *ctx, int kdf);
        int EVP_PKEY_CTX_get_dh_kdf_type(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_CTX_set0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT *oid);
        int EVP_PKEY_CTX_get0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT **oid);
        int EVP_PKEY_CTX_set_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
        int EVP_PKEY_CTX_get_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
        int EVP_PKEY_CTX_set_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int len);
        int EVP_PKEY_CTX_get_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int *len);
        int EVP_PKEY_CTX_set0_dh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char *ukm, int len);

        #include <openssl/ec.h>

        int EVP_PKEY_CTX_set_ec_paramgen_curve_nid(EVP_PKEY_CTX *ctx, int nid);
        int EVP_PKEY_CTX_set_ec_param_enc(EVP_PKEY_CTX *ctx, int param_enc);
        int EVP_PKEY_CTX_set_ecdh_cofactor_mode(EVP_PKEY_CTX *ctx, int cofactor_mode);
        int EVP_PKEY_CTX_get_ecdh_cofactor_mode(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_CTX_set_ecdh_kdf_type(EVP_PKEY_CTX *ctx, int kdf);
        int EVP_PKEY_CTX_get_ecdh_kdf_type(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_CTX_set_ecdh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
        int EVP_PKEY_CTX_get_ecdh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
        int EVP_PKEY_CTX_set_ecdh_kdf_outlen(EVP_PKEY_CTX *ctx, int len);
        int EVP_PKEY_CTX_get_ecdh_kdf_outlen(EVP_PKEY_CTX *ctx, int *len);
        int EVP_PKEY_CTX_set0_ecdh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char *ukm, int len);

生成密钥

        int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_generate(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);

例如：

  • Generate a 2048 bit RSA key:
        #include <openssl/evp.h>
        #include <openssl/rsa.h>

        EVP_PKEY_CTX *ctx;
        EVP_PKEY *pkey = NULL;

        ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
        if (!ctx)
            /* Error occurred */
        if (EVP_PKEY_keygen_init(ctx) <= 0)
            /* Error */
        if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 2048) <= 0)
            /* Error */

        /* Generate key */
        if (EVP_PKEY_keygen(ctx, &pkey) <= 0)
            /* Error */
  • Generate a key from a set of parameters:
        #include <openssl/evp.h>
        #include <openssl/rsa.h>

        EVP_PKEY_CTX *ctx;
        ENGINE *eng;
        EVP_PKEY *pkey = NULL, *param;

        /* Assumed param, eng are set up already */
        ctx = EVP_PKEY_CTX_new(param, eng);
        if (!ctx)
            /* Error occurred */
        if (EVP_PKEY_keygen_init(ctx) <= 0)
            /* Error */

        /* Generate key */
        if (EVP_PKEY_keygen(ctx, &pkey) <= 0)
            /* Error */
  • Example of generation callback for OpenSSL public key implementations:
        /* Application data is a BIO to output status to */

        EVP_PKEY_CTX_set_app_data(ctx, status_bio);

        static int genpkey_cb(EVP_PKEY_CTX *ctx)
        {
            char c = '*';
            BIO *b = EVP_PKEY_CTX_get_app_data(ctx);
            int p = EVP_PKEY_CTX_get_keygen_info(ctx, 0);

            if (p == 0)
                c = '.';
            if (p == 1)
                c = '+';
            if (p == 2)
                c = '*';
            if (p == 3)
                c = '\n';
            BIO_write(b, &c, 1);
            (void)BIO_flush(b);
            return 1;
        }

密钥参数打印

        #include <openssl/evp.h>

        int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey,
                                  int indent, ASN1_PCTX *pctx);
        int EVP_PKEY_print_public_fp(FILE *fp, const EVP_PKEY *pkey,
                                     int indent, ASN1_PCTX *pctx);
        int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey,
                                   int indent, ASN1_PCTX *pctx);
        int EVP_PKEY_print_private_fp(FILE *fp, const EVP_PKEY *pkey,
                                      int indent, ASN1_PCTX *pctx);
        int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey,
                                  int indent, ASN1_PCTX *pctx);
        int EVP_PKEY_print_params_fp(FILE *fp, const EVP_PKEY *pkey,
                                     int indent, ASN1_PCTX *pctx);

密钥的提取和指定

        int EVP_PKEY_get_raw_private_key(const EVP_PKEY *pkey, unsigned char *priv,
                                         size_t *len);
        int EVP_PKEY_get_raw_public_key(const EVP_PKEY *pkey, unsigned char *pub,
                                        size_t *len);

        EVP_PKEY *EVP_PKEY_new_raw_private_key_ex(OSSL_LIB_CTX *libctx,
                                                  const char *keytype,
                                                  const char *propq,
                                                  const unsigned char *key,
                                                  const unsigned char *key,
                                                  size_t keylen);
        EVP_PKEY *EVP_PKEY_new_raw_private_key(int type, ENGINE *e,
                                               const unsigned char *key, size_t keylen);
        EVP_PKEY *EVP_PKEY_new_raw_public_key_ex(OSSL_LIB_CTX *libctx,
                                                 const char *keytype,
                                                 const char *propq,
                                                 const unsigned char *key,
                                                 size_t keylen);
        EVP_PKEY *EVP_PKEY_new_raw_public_key(int type, ENGINE *e,
                                              const unsigned char *key, size_t keylen);

密钥的保存和读取

使用OSSL_ENCODER和OSSL_DECODER

构建OSSL_ENCODER_CTX

        #include <openssl/encoder.h>

        OSSL_ENCODER_CTX *
        OSSL_ENCODER_CTX_new_for_pkey(const EVP_PKEY *pkey, int selection,
        OSSL_ENCODER_CTX_new_for_pkey(const EVP_PKEY *pkey, int selection,
                                      const char *output_type,
                                      const char *output_structure,
                                      const char *propquery);

        int OSSL_ENCODER_CTX_set_cipher(OSSL_ENCODER_CTX *ctx,
                                        const char *cipher_name,
                                        const char *propquery);
        int OSSL_ENCODER_CTX_set_passphrase(OSSL_ENCODER_CTX *ctx,
                                            const unsigned char *kstr,
                                            size_t klen);
        int OSSL_ENCODER_CTX_set_pem_password_cb(OSSL_ENCODER_CTX *ctx,
                                                 pem_password_cb *cb, void *cbarg);
        int OSSL_ENCODER_CTX_set_passphrase_ui(OSSL_ENCODER_CTX *ctx,
                                               const UI_METHOD *ui_method,
                                               void *ui_data);
        int OSSL_ENCODER_CTX_set_passphrase_cb(OSSL_ENCODER_CTX *ctx,
                                               OSSL_PASSPHRASE_CALLBACK *cb,
                                               void *cbarg);

编码输出

        #include <openssl/encoder.h>

        int OSSL_ENCODER_to_data(OSSL_ENCODER_CTX *ctx, unsigned char **pdata,
                                 size_t *pdata_len);
        int OSSL_ENCODER_to_bio(OSSL_ENCODER_CTX *ctx, BIO *out);
        int OSSL_ENCODER_to_fp(OSSL_ENCODER_CTX *ctx, FILE *fp);

构建OSSL_DECODER_CTX

        #include <openssl/decoder.h>

        typedef struct ossl_decoder_ctx_st OSSL_DECODER_CTX;

        OSSL_DECODER_CTX *OSSL_DECODER_CTX_new(void);
        const OSSL_PARAM *OSSL_DECODER_settable_ctx_params(OSSL_DECODER *decoder);
        int OSSL_DECODER_CTX_set_params(OSSL_DECODER_CTX *ctx,
                                        const OSSL_PARAM params[]);
        void OSSL_DECODER_CTX_free(OSSL_DECODER_CTX *ctx);

        int OSSL_DECODER_CTX_set_selection(OSSL_DECODER_CTX *ctx, int selection);
        int OSSL_DECODER_CTX_set_input_type(OSSL_DECODER_CTX *ctx,
                                            const char *input_type);
        int OSSL_DECODER_CTX_set_input_structure(OSSL_DECODER_CTX *ctx,
                                                 const char *input_structure);
        int OSSL_DECODER_CTX_add_decoder(OSSL_DECODER_CTX *ctx, OSSL_DECODER *decoder);
        int OSSL_DECODER_CTX_add_extra(OSSL_DECODER_CTX *ctx,
                                       OSSL_LIB_CTX *libctx,
                                       const char *propq);
        int OSSL_DECODER_CTX_get_num_decoders(OSSL_DECODER_CTX *ctx);

        typedef struct ossl_decoder_instance_st OSSL_DECODER_INSTANCE;
        OSSL_DECODER *
        OSSL_DECODER_INSTANCE_get_decoder(OSSL_DECODER_INSTANCE *decoder_inst);
        void *
        OSSL_DECODER_INSTANCE_get_decoder_ctx(OSSL_DECODER_INSTANCE *decoder_inst);
        const char *
        OSSL_DECODER_INSTANCE_get_input_type(OSSL_DECODER_INSTANCE *decoder_inst);
        OSSL_DECODER_INSTANCE_get_input_structure(OSSL_DECODER_INSTANCE *decoder_inst,
                                                  int *was_set);

        typedef int OSSL_DECODER_CONSTRUCT(OSSL_DECODER_INSTANCE *decoder_inst,
                                           const OSSL_PARAM *object,
                                           void *construct_data);
        typedef void OSSL_DECODER_CLEANUP(void *construct_data);

        int OSSL_DECODER_CTX_set_construct(OSSL_DECODER_CTX *ctx,
                                           OSSL_DECODER_CONSTRUCT *construct);
        int OSSL_DECODER_CTX_set_construct_data(OSSL_DECODER_CTX *ctx,
                                                void *construct_data);
        int OSSL_DECODER_CTX_set_cleanup(OSSL_DECODER_CTX *ctx,
                                         OSSL_DECODER_CLEANUP *cleanup);
        OSSL_DECODER_CONSTRUCT *OSSL_DECODER_CTX_get_construct(OSSL_DECODER_CTX *ctx);
        void *OSSL_DECODER_CTX_get_construct_data(OSSL_DECODER_CTX *ctx);
        OSSL_DECODER_CLEANUP *OSSL_DECODER_CTX_get_cleanup(OSSL_DECODER_CTX *ctx);

        int OSSL_DECODER_export(OSSL_DECODER_INSTANCE *decoder_inst,
                                void *reference, size_t reference_sz,
                                OSSL_CALLBACK *export_cb, void *export_cbarg);

解码

        #include <openssl/decoder.h>

        int OSSL_DECODER_from_bio(OSSL_DECODER_CTX *ctx, BIO *in);
        int OSSL_DECODER_from_fp(OSSL_DECODER_CTX *ctx, FILE *fp);
        int OSSL_DECODER_from_data(OSSL_DECODER_CTX *ctx, const unsigned char **pdata,
                                   size_t *pdata_len);
使用EVP_PKEY_todata和EVP_PKEY_fromdata
        #include <openssl/evp.h>

        int EVP_PKEY_todata(const EVP_PKEY *pkey, int selection, OSSL_PARAM **params);
        int EVP_PKEY_export(const EVP_PKEY *pkey, int selection,
                            OSSL_CALLBACK *export_cb, void *export_cbarg);

        int EVP_PKEY_fromdata_init(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_fromdata(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey, int selection,
                              OSSL_PARAM params[]);
        const OSSL_PARAM *EVP_PKEY_fromdata_settable(EVP_PKEY_CTX *ctx, int selection);

检测私钥是否正确

        #include <openssl/evp.h>

        int EVP_PKEY_check(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_param_check(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_param_check_quick(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_public_check(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_public_check_quick(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_private_check(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_pairwise_check(EVP_PKEY_CTX *ctx);

加解密

        #include <openssl/evp.h>

        int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_encrypt_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
        int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx,
                             unsigned char *out, size_t *outlen,
                             const unsigned char *in, size_t inlen);

        int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_decrypt_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
        int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx,
                             unsigned char *out, size_t *outlen,
                             const unsigned char *in, size_t inlen);

签名和验签

签名

        #include <openssl/evp.h>

        int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_sign_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
        int EVP_PKEY_sign(EVP_PKEY_CTX *ctx,
                          unsigned char *sig, size_t *siglen,
                          const unsigned char *tbs, size_t tbslen);

验签

        #include <openssl/evp.h>

        int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_verify_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
        int EVP_PKEY_verify(EVP_PKEY_CTX *ctx,
                            const unsigned char *sig, size_t siglen,
                            const unsigned char *tbs, size_t tbslen);
飞花丝雨
关注
  • 6
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
openSSL中EVP接口
新时代农民工
08-03 767
OpenSSL在日常开发者通常是以so的形式引入程序中，下面我们来跟踪一下EVP是如何把这些算法接口抽象统一实现的。ossl_init_add_all_ciphers作为静态方式加载，只加载一次把所有的cipher通过openssl_add_all_ciphers_int添加到改进程中。
OpenSSL中文手册之EVP库详解
热门推荐
liao20081228的博客
07-29 5万+
说明：这一系列文章参考自http://blog.csdn.net/xiaoting451292510/article/category/5609403/3 ，个人做了整理 。OpenSSL之EVP——加密算法  EVP加密算法包括了对称加密算法和非对称加密算法. 函数名称：EVP_Encrypt*…,EVP_Cipher…* 功能描述：该系列函数封装提供了对称加密算法的功能。 相关文件：e
Linux C语言调用OpenSSL：EVP 接口概述
Penseur2018的博客
06-19 820
本文介绍了openssl中的EVP高级API的应用场景和优缺点等，并对比了它和低级接口之间的性能差异
openssl evp 对称加密(AES_ecb,ccb)
weixin_34302561的博客
12-01 469
openssl evp 对称加密(AES_ecb,ccb) evp.h 封装了openssl常用密码学工具，以下主要说对称加密的接口 1. 如下使用 aes_256_ecb 模式的加密解密测试代码 unsigned char key[32] = {1}; unsigned char iv[16] = {0}; unsigned char *inStr = "this is...
openssl框架闲谈--EVP加密/解密接口(附：加密)
Netfilter
02-09 9131
openssl 框架中的另一个重头戏就是EVP接口，它提供了所有的加密和解密实现，不但封装了已有的著名算法，而且其简单易用的接口可以让你自己轻松实现一个算法，这 就增强了它的可扩展性，基本上，openssl只是提供了机制框架，策略由用户实现。EVP接口的重要数据结构如下： typedef struct evp_cipher_st {     int nid;        //对象
openssl+EVP详解
N阶二进制的博客
11-29 3783
EVP 提供了通用的加密和解密函数，可以用于对称加密和非对称加密。选择加密算法，创建相应的EVP_CIPHER结构。初始化上下文。使用或初始化加密或解密操作。使用或处理数据。使用或完成加密或解密操作。由digest.c实现，实现过程中调用了对应摘要算法的回调函数。各个摘要算法提供了自己的EVP_MD静态结构，对应源码为m_xxx.c。
evp.rar_EVP加密_evp_openssl evp
09-21
EVP接口抽象了底层的实现细节，使得代码更加简洁且易于维护。 **EVP加密概述** EVP加密是OpenSSL中的核心组件之一，它提供了一种统一的方式来处理多种加密和摘要算法。EVP API允许开发者选择不同的加密算法，如AES...
openssl之EVP系列
01-06
此外，OpenSSL会定期更新支持的算法，EVP接口能确保开发者能够快速利用新算法，提高系统的安全性。 在实际项目中，EVP系列的使用不仅简化了代码，提高了代码的可读性和可维护性，还能确保在满足安全标准的同时，...
Openssl 库函数接口说明
11-09
在`openssl开发手册.chm`中，详细介绍了OpenSSL库的接口及其用法。以下是一些关键知识点： 1. **RSA 加密算法**： RSA 是一种非对称加密算法，基于大整数因子分解的困难性。它使用一对公钥和私钥，公钥用于加密，...
openssl evp aes 加解密算法调试例程
07-11
2、利用openssl EVP接口 在openssl/evp.h中定义。在这个接口中提供的AES是默认是pkcs5padding方式填充方案。 3、注意openssl新老版本的区别 看如下这段 One of the primary differences between master (OpenSSL ...
openssl之EVP
drrlalala的专栏
06-26 3562
本文参考百度百科和http://blog.csdn.net/gdwzh/article/details/19231 一，什么是openssl?         SSL 是一个缩写，代表的是 Secure Sockets Layer。它是支持在 Internet 上进行安全通信的标准，并且将数据密码术集成到了协议之中。数据在离开您的计算机之前就已经被加密，然后只有到达它预定的目标后才被解
OpenSSL/GMSSL EVP接口说明——2.7 杂凑示例代码
云与山的彼端
04-05 2万+
OpenSSL/GMSSL EVP接口说明——2.7 杂凑示例代码
openssl之EVP系列之10---EVP_Sign系列函数介绍
diandingyin9417的博客
06-22 223
openssl之EVP系列之10---EVP_Sign系列函数介绍 ---依据openssl doc/crypto/EVP_SignInit.pod翻译 （作者：DragonKing, Mail: wzhah@263.net ,公布于：http://openssl.126.com之openssl专业论坛,版本号：openssl-0.9.7） EVP...
使用openssl应用层接口(EVP_***)实现对称(aes,idea等)加密
guolisong的专栏
11-17 1080
通过调用openssl的库函数，来实现对称加密
OpenSSL EVP详解
最新发布
宁静致远的博客
06-27 964
EVP 提供了通用的加密和解密函数，可以用于对称加密和非对称加密。选择加密算法，创建相应的 EVP_CIPHER 结构。初始化 EVP_CIPHER_CTX 上下文。使用 EVP_EncryptInit_ex 或 EVP_DecryptInit_ex 初始化加密或解密操作。使用 EVP_EncryptUpdate 或 EVP_DecryptUpdate 处理数据。使用 EVP_EncryptFinal_ex 或 EVP_DecryptFinal_ex 完成加密或解密操作。
21.openssl编程——EVP
艾小小雨的博客
01-23 2520
21.1 EVP简介Openssl EVP (high-level cryptographic functions)提供丰富的密码学中的各种函数。EVP主要封装如下功能函数：a.实现了base64编解码BIOb.实现了加解密BIOc.实现了摘要BIOd.实现了reliableBIO;e.封装了摘要算法f.封装了对称加解密算法g.封装了非对称密钥的加密（公钥）、解密（私钥）、签名与验证以及...
#include <openssl/evp.h> 是什么文件
05-14
`#include <openssl/evp.h>` 是 OpenSSL 库中的头文件，其中包含了加密算法和哈希算法等的实现。EVP 是 OpenSSL 中的一个抽象实现，它提供了对称加密、非对称加密、哈希、消息认证码等多种加密算法的实现。通过使用 EVP 接口，我们可以方便地调用 OpenSSL 库中的各种加密算法实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

飞花丝雨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值