OpenSSL

密码学和 SSL/TLS 工具包

EVP_EncryptInit_ex

NAME

EVP_CIPHER_fetch、EVP_CIPHER_up_ref、EVP_CIPHER_free、EVP_CIPHER_CTX_new、EVP_CIPHER_CTX_reset、EVP_CIPHER_CTX_free、EVP_EncryptInit_ex、EVP_EncryptInit_ex2、EVP_EncryptUpdate、EVP_EncryptFinal_ex、EVP_DecryptInit_ex、EVP_DecryptInit_ ex2、EVP_DecryptUpdate、EVP_DecryptFinal_ex、EVP_CipherInit_ex、EVP_CipherInit_ex2、EVP_CipherUpdate、EVP_CipherFinal_ex、EVP_CIPHER_CTX_set_key_length、EVP_CIPHER_CTX_ctrl、EVP_EncryptInit、EVP_EncryptFinal、EVP_DecryptInit、EVP_DecryptFinal、 EVP_CipherInit, EVP_CipherFinal、EVP_Cipher、EVP_get_cipherbyname、EVP_get_cipherbynid、EVP_get_cipherbyobj、EVP_CIPHER_is_a、EVP_CIPHER_get0_name、EVP_CIPHER_get0_description、EVP_CIPHER_names_do_all、EVP_CIPHER_get0_provider、EVP_CIPHER_get_nid、 EVP_CIPHER_get_params、EVP_CIPHER_gettable_params、EVP_CIPHER_get_block_size、EVP_CIPHER_get_key_length、EVP_CIPHER_get_iv_length、EVP_CIPHER_get_flags、EVP_CIPHER_get_mode、EVP_CIPHER_get_type、EVP_CIPHER_CTX_cipher、EVP_CIPHER_CTX_get0 _cipher、EVP_CIPHER_CTX_get1_cipher、EVP_CIPHER_CTX_get0_name、EVP_CIPHER_CTX_get_nid、EVP_CIPHER_CTX_get_params、 EVP_CIPHER_gettable_ctx_params、EVP_CIPHER_CTX_gettable_params、EVP_CIPHER_CTX_set_params、EVP_CIPHER_settable_ctx_params、EVP_CIPHER_CTX_settable_params、EVP_CIPHER_CTX_get_block_size、EVP_CIPHER_CTX_get_key_length、EVP_CIPHER_CTX_get _iv_length、EVP_CIPHER_CTX_get_tag_length、EVP_CIPHER_CTX_get_app_data、EVP_CIPHER_CTX_set_app_data、EVP_CIPHER_CTX_flags、EVP_CIPHER_CTX_set_flags、EVP_CIPHER_CTX_clear_flags、EVP_CIPHER_CTX_test_flags、EVP_CIPHER_CTX_get_类型，EVP_CIPHER_CTX_get_mode，EVP_CIPHER_CTX_get_num，EVP_CIPHER_CTX_set_num，EVP_CIPHER_CTX_is_加密，EVP_CIPHER_param_to_asn1，EVP_CIPHER_asn1_to_param，EVP_CIPHER_CTX_set_padding，EVP_enc_null，EVP_CIPHER_do_all_prov已定， EVP_CIPHER_nid、EVP_CIPHER_name、EVP_CIPHER_block_size、EVP_CIPHER_key_length、EVP_CIPHER_iv_length、EVP_CIPHER_flags、EVP_CIPHER_mode、EVP_CIPHER_type、EVP_CIPHER_CTX_加密、EVP_CIPHER_CTX_nid、EVP_CIPHER_CTX_block_size、EVP _CIPHER_CTX_key_length、EVP_CIPHER_CTX_iv_length、EVP_CIPHER_CTX_tag_length、EVP_CIPHER_CTX_num、EVP_CIPHER_CTX_type、EVP_CIPHER_CTX_mode - EVP 密码例程

SYNOPSIS 

 #include <openssl/evp.h>

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

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_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);

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_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);

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_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);

int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                    const unsigned char *key, const unsigned char *iv);
int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);

int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                    const unsigned char *key, const unsigned char *iv);
int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);

int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                   const unsigned char *key, const unsigned char *iv, int enc);
int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);

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

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_ctrl(EVP_CIPHER_CTX *ctx, int cmd, int p1, void *p2);
int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key);
void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags);
void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags);
int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags);

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

int EVP_CIPHER_get_nid(const EVP_CIPHER *e);
int EVP_CIPHER_is_a(const EVP_CIPHER *cipher, const char *name);
int EVP_CIPHER_names_do_all(const EVP_CIPHER *cipher,
                            void (*fn)(const char *name, void *data),
                            void *data);
const char *EVP_CIPHER_get0_name(const EVP_CIPHER *cipher);
const char *EVP_CIPHER_get0_description(const EVP_CIPHER *cipher);
const OSSL_PROVIDER *EVP_CIPHER_get0_provider(const EVP_CIPHER *cipher);
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);
unsigned long EVP_CIPHER_get_flags(const EVP_CIPHER *e);
unsigned long EVP_CIPHER_get_mode(const EVP_CIPHER *e);
int EVP_CIPHER_get_type(const EVP_CIPHER *cipher);

const EVP_CIPHER *EVP_CIPHER_CTX_get0_cipher(const EVP_CIPHER_CTX *ctx);
EVP_CIPHER *EVP_CIPHER_CTX_get1_cipher(const EVP_CIPHER_CTX *ctx);
int EVP_CIPHER_CTX_get_nid(const EVP_CIPHER_CTX *ctx);
const char *EVP_CIPHER_CTX_get0_name(const EVP_CIPHER_CTX *ctx);

int EVP_CIPHER_get_params(EVP_CIPHER *cipher, OSSL_PARAM params[]);
int EVP_CIPHER_CTX_set_params(EVP_CIPHER_CTX *ctx, const OSSL_PARAM params[]);
int EVP_CIPHER_CTX_get_params(EVP_CIPHER_CTX *ctx, OSSL_PARAM params[]);
const OSSL_PARAM *EVP_CIPHER_gettable_params(const EVP_CIPHER *cipher);
const OSSL_PARAM *EVP_CIPHER_settable_ctx_params(const EVP_CIPHER *cipher);
const OSSL_PARAM *EVP_CIPHER_gettable_ctx_params(const EVP_CIPHER *cipher);
const OSSL_PARAM *EVP_CIPHER_CTX_settable_params(EVP_CIPHER_CTX *ctx);
const OSSL_PARAM *EVP_CIPHER_CTX_gettable_params(EVP_CIPHER_CTX *ctx);
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);
void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx);
void EVP_CIPHER_CTX_set_app_data(const EVP_CIPHER_CTX *ctx, void *data);
int EVP_CIPHER_CTX_get_type(const EVP_CIPHER_CTX *ctx);
int EVP_CIPHER_CTX_get_mode(const EVP_CIPHER_CTX *ctx);
int EVP_CIPHER_CTX_get_num(const EVP_CIPHER_CTX *ctx);
int EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX *ctx, int num);
int EVP_CIPHER_CTX_is_encrypting(const EVP_CIPHER_CTX *ctx);

int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type);

void EVP_CIPHER_do_all_provided(OSSL_LIB_CTX *libctx,
                                void (*fn)(EVP_CIPHER *cipher, void *arg),
                                void *arg);

#define EVP_CIPHER_nid EVP_CIPHER_get_nid
#define EVP_CIPHER_name EVP_CIPHER_get0_name
#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_flags EVP_CIPHER_get_flags
#define EVP_CIPHER_mode EVP_CIPHER_get_mode
#define EVP_CIPHER_type EVP_CIPHER_get_type
#define EVP_CIPHER_CTX_encrypting EVP_CIPHER_CTX_is_encrypting
#define EVP_CIPHER_CTX_nid EVP_CIPHER_CTX_get_nid
#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
#define EVP_CIPHER_CTX_num EVP_CIPHER_CTX_get_num
#define EVP_CIPHER_CTX_type EVP_CIPHER_CTX_get_type
#define EVP_CIPHER_CTX_mode EVP_CIPHER_CTX_get_mode

自 OpenSSL 3.0 起，以下函数已被弃用，并且可以通过使用合适的版本值定义OPENSSL_API_COMPAT 来完全隐藏，请参阅openssl_user_macros(7)： 

 const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx);

自 OpenSSL 1.1.0 起，以下函数已被弃用，并且可以通过使用合适的版本值定义OPENSSL_API_COMPAT 来完全隐藏，请参阅openssl_user_macros(7)： 

 int EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx);

DESCRIPTION

EVP 密码例程是某些对称密码的高级接口。

EVP_CIPHER类型是用于密码方法实现的结构体。

EVP_CIPHER_fetch()

在属性给定的标准内，从提供给定算法的任何提供者获取给定算法 的密码实现。有关更多信息，请参阅crypto(7) 中的“算法获取”。

返回的值最终必须使用 EVP_CIPHER_free() 释放。

获取的EVP_CIPHER结构进行引用计数。

EVP_CIPHER_up_ref()

增加EVP_CIPHER结构 的引用计数。

EVP_CIPHER_free()

减少获取的EVP_CIPHER结构 的引用计数。如果引用计数降至 0，则该结构将被释放。

EVP_CIPHER_CTX_new()

分配并返回密码上下文。

EVP_CIPHER_CTX_free()

清除密码上下文中的所有信息并释放与其关联的任何分配的内存，包括ctx本身。应在使用密码的所有操作完成后调用此函数，以便敏感信息不会保留在内存中。

EVP_CIPHER_CTX_ctrl()

这是一个遗留方法。EVP_CIPHER_CTX_set_params() 和 EVP_CIPHER_CTX_get_params() 是用于设置和获取提供程序使用的参数的机制。

在上下文ctx 上执行特定于密码的控制操作。控制命令在cmd中指示，任何附加参数在p1和p2中指示。EVP_CIPHER_CTX_ctrl() 必须在 EVP_CipherInit_ex2() 之后调用。其他限制可能适用，具体取决于控制类型和密码实现。

如果此函数恰好与获取的EVP_CIPHER 一起使用，它将把 OpenSSL 已知的控件转换为OSSL_PARAM(3)参数，并使用 OpenSSL 定义的键调用 EVP_CIPHER_CTX_get_params() 或 EVP_CIPHER_CTX_set_params() （适合每个控制命令）。

请参阅下面的“控制”以获取更多信息，包括正在进行的翻译。

EVP_CIPHER_get_params()

从 CIPHER cipher中检索请求的算法参数 列表。请参阅下面的“参数”了解更多信息。

EVP_CIPHER_CTX_get_params()

从 CIPHER 上下文ctx检索请求的参数 列表。请参阅下面的“参数”了解更多信息。

EVP_CIPHER_CTX_set_params()

将参数 列表设置到 CIPHER 上下文ctx中。请参阅下面的“参数”了解更多信息。

EVP_CIPHER_gettable_params()

获取一个常量OSSL_PARAM(3)数组，该数组描述可与 EVP_CIPHER_get_params() 一起使用的可检索参数。

EVP_CIPHER_gettable_ctx_params() and EVP_CIPHER_CTX_gettable_params()

获取一个常量OSSL_PARAM(3)数组，该数组描述可与 EVP_CIPHER_CTX_get_params() 一起使用的可检索参数。EVP_CIPHER_gettable_ctx_params() 返回可以从算法中检索的参数，而 EVP_CIPHER_CTX_gettable_params() 返回可以在上下文的当前状态下检索的参数。

EVP_CIPHER_settable_ctx_params() and EVP_CIPHER_CTX_settable_params()

获取一个常量OSSL_PARAM(3)数组，该数组描述可与 EVP_CIPHER_CTX_set_params() 一起使用的可设置参数。EVP_CIPHER_settable_ctx_params() 返回可以从算法设置的参数，而 EVP_CIPHER_CTX_settable_params() 返回可以在上下文的当前状态下设置的参数。

EVP_EncryptInit_ex2()

设置密码上下文ctx以使用密码类型进行加密。类型通常通过调用 EVP_CIPHER_fetch() 提供。也可以使用旧函数（例如 EVP_aes_256_cbc()）设置类型，但不建议新应用程序这样做。key是要使用的对称密钥，iv是要使用的 IV（如果需要），密钥和 IV 实际使用的字节数取决于密码。参数params将在初始化后在上下文中设置。可以将除初始调用中的类型之外的所有参数设置为 NULL ，并在后续调用中提供其余参数，所有参数的类型都设置为 NULL。当默认密码参数不合适时会执行此操作。对于EVP_CIPH_GCM_MODE，如果未指定，IV 将在内部生成。

EVP_EncryptInit_ex()

当impl为 NULL 时，此旧函数类似于 EVP_EncryptInit_ex2() 。如果存在，将使用 impl引擎中类型的实现。

EVP_EncryptUpdate()

加密缓冲区in中的inl字节并将加密版本写入out。可以多次调用此函数来加密连续的数据块。写入的数据量取决于加密数据的块对齐。对于大多数密码和模式，写入的数据量可以是从零字节到 (inl + cipher_block_size - 1) 字节的任何值。对于换行密码模式，写入的数据量可以是从零字节到 (inl + cipher_block_size) 字节的任意值。对于流密码，写入的数据量可以是从零字节到整数字节的任意值。因此，out应包含足够的空间来执行正在执行的操作。实际写入的字节数放置在outl中。它还检查in和out是否部分重叠，如果是 0，则返回以指示失败。

如果启用填充（默认），则 EVP_EncryptFinal_ex() 会加密“最终”数据，即保留在部分块中的任何数据。它使用标准块填充（又名 PKCS 填充），如下面的“注释”部分所述。加密的最终数据被写入输出，该输出应具有足够的空间容纳一个密码块。写入的字节数放置在outl中。调用此函数后，加密操作完成，不应再调用 EVP_EncryptUpdate()。

如果禁用填充，则 EVP_EncryptFinal_ex() 将不再加密任何数据，并且如果部分块中保留有任何数据，即如果总数据长度不是块大小的倍数，则 EVP_EncryptFinal_ex() 将返回错误。

EVP_DecryptInit_ex2(), EVP_DecryptInit_ex(), EVP_DecryptUpdate() and EVP_DecryptFinal_ex()

这些函数就是对应的解密操作。如果启用填充并且最终块的格式不正确，EVP_DecryptFinal() 将返回错误代码。参数和限制与加密操作相同，除了如果启用填充，则传递给 EVP_DecryptUpdate() 的解密数据缓冲区应该有足够的空间容纳 ( inl + cipher_block_size) 字节，除非密码块大小为 1，在这种情况下inl字节为充足的。

EVP_CipherInit_ex2(), EVP_CipherInit_ex(), EVP_CipherUpdate() and EVP_CipherFinal_ex()

这些函数可用于解密或加密。执行的操作取决于enc参数的值。应将其设置为 1 进行加密，0 进行解密，-1 保持值不变（“enc”的实际值在先前的调用中提供）。

EVP_CIPHER_CTX_reset()

清除密码上下文中的所有信息并释放与其关联的所有已分配内存（ctx本身除外）。只要ctx被另一个 EVP_CipherInit() / EVP_CipherUpdate() / EVP_CipherFinal() 系列调用重用， 就应该调用此函数。

EVP_EncryptInit(), EVP_DecryptInit() and EVP_CipherInit()

其行为方式与 EVP_EncryptInit_ex()、EVP_DecryptInit_ex() 和 EVP_CipherInit_ex() 类似，除非类型不是获取的密码，否则它们使用type的默认实现。

EVP_EncryptFinal(), EVP_DecryptFinal() and EVP_CipherFinal()

与 EVP_EncryptFinal_ex()、EVP_DecryptFinal_ex() 和 EVP_CipherFinal_ex() 相同。在以前的版本中，他们还清理了ctx，但现在不再这样做，并且必须调用 EVP_CIPHER_CTX_cleanup() 来释放任何上下文资源。

EVP_Cipher()

对in 中的 最大inl字节数进行加密或解密，并将结果保留在out中。

对于旧密码 - 如果密码没有设置标志EVP_CIPH_FLAG_CUSTOM_CIPHER，则inl必须是 EVP_CIPHER_get_block_size() 的倍数。如果不是，则结果未定义。如果密码设置了该标志，则inl可以是任意大小。

由于此函数的 API 契约的限制，它不应在应用程序中使用，请考虑使用 EVP_CipherUpdate() 和 EVP_CipherFinal_ex() 代替。

EVP_get_cipherbyname(), EVP_get_cipherbynid() and EVP_get_cipherbyobj()

当分别传递密码名称、密码NID或ASN1_OBJECT结构时， 返回EVP_CIPHER结构。

EVP_get_cipherbyname() 将为“AES-128-SIV”、“AES-128-CBC-CTS”和“CAMELLIA-128-CBC-CTS”等算法返回 NULL，这些算法以前只能通过低级接口访问。

EVP_get_cipherbyname() 函数用于向后兼容版本 3 之前的 OpenSSL，并且与 EVP_CIPHER_fetch() 函数不同，因为它不会尝试“获取”密码的实现。此外，它只知道 OpenSSL 内置的密码并具有关联的 NID。类似地，EVP_get_cipherbynid() 和 EVP_get_cipherbyobj() 也返回没有关联实现的对象。

当使用这些函数返回的密码对象时（例如在调用 EVP_EncryptInit_ex() 中），将从加载的提供程序中隐式获取密码的实现。如果没有合适的实现可用，则此获取可能会失败。使用 EVP_CIPHER_fetch() 来显式从提供者获取算法和关联的实现。

有关获取的更多信息， 请参阅crypto(7) 中的“算法获取” 。

从这些函数返回的密码对象不需要使用 EVP_CIPHER_free() 释放。

EVP_CIPHER_get_nid() and EVP_CIPHER_CTX_get_nid()

传递EVP_CIPHER或EVP_CIPHER_CTX结构 时返回密码的 NID 。实际的 NID 值是一个内部值，可能没有相应的 OBJECT IDENTIFIER。

EVP_CIPHER_CTX_set_flags(), EVP_CIPHER_CTX_clear_flags() and EVP_CIPHER_CTX_test_flags()

设置、清除和测试ctx标志。有关详细信息， 请参阅下面的“标志” 。

对于提供的密码，仅应在将获取的密码分配给ctx 后调用 EVP_CIPHER_CTX_set_flags() 。建议使用“参数”代替。

EVP_CIPHER_CTX_set_padding()

启用或禁用填充。应在使用 EVP_EncryptInit_ex2()、EVP_DecryptInit_ex2() 或 EVP_CipherInit_ex2() 设置加密或解密上下文后调用此函数。默认情况下，加密操作使用标准块填充进行填充，并且在解密时检查并删除填充。如果pad参数为零，则不执行填充，加密或解密的数据总量必须是块大小的倍数，否则会发生错误。

EVP_CIPHER_get_key_length() and EVP_CIPHER_CTX_get_key_length()

传递EVP_CIPHER或EVP_CIPHER_CTX结构 时返回密码的密钥长度。常量EVP_MAX_KEY_LENGTH是所有密码的最大密钥长度。注意：虽然 EVP_CIPHER_get_key_length() 对于给定密码是固定的，但对于可变密钥长度密码，EVP_CIPHER_CTX_get_key_length() 的值可能不同。

EVP_CIPHER_CTX_set_key_length()

设置密码上下文的密钥长度。如果密码是固定长度密码，则尝试将密钥长度设置为固定值以外的任何值都是错误的。

EVP_CIPHER_get_iv_length() and EVP_CIPHER_CTX_get_iv_length()

当传递EVP_CIPHER或EVP_CIPHER_CTX 时返回密码的 IV 长度。如果密码不使用 IV，它将返回零。常量EVP_MAX_IV_LENGTH是所有密码的最大 IV 长度。

EVP_CIPHER_CTX_get_tag_length()

当传递EVP_CIPHER_CTX 时，返回 AEAD 密码的标签长度​​。如果密码不支持标签，它将返回零。如果未设置标签长度，则返回默认值。

EVP_CIPHER_get_block_size() and EVP_CIPHER_CTX_get_block_size()

传递EVP_CIPHER或EVP_CIPHER_CTX结构 时返回密码的块大小。常量EVP_MAX_BLOCK_LENGTH也是所有密码的最大块长度。

EVP_CIPHER_get_type() and EVP_CIPHER_CTX_get_type()

返回传递的密码或上下文的类型。该“类型”是密码对象标识符的实际 NID，因此它忽略密码参数（40 位 RC2 和 128 位 RC2 具有相同的 NID）。如果密码没有对象标识符或没有 ASN1 支持，此函数将返回NID_undef。

EVP_CIPHER_is_a()

如果cipher是可通过name识别的算法的实现，则返回 1 ，否则返回 0。如果cipher是旧密码（它是 EVP_aes128() 等的返回值，而不是 EVP_CIPHER_fetch() 的结果），则仅包含密码名称将考虑 使用默认库上下文注册（请参阅OSSL_LIB_CTX(3) ）。

EVP_CIPHER_get0_name() and EVP_CIPHER_CTX_get0_name()

返回传递的密码或上下文的名称。对于获取的具有多个名称的密码，仅返回其中之一。另请参见 EVP_CIPHER_names_do_all()。

EVP_CIPHER_names_do_all()

遍历密码的所有名称，并使用每个名称和数据调用fn。这仅对获取的EVP_CIPHER有用。

EVP_CIPHER_get0_description()

返回密码的描述，用于显示和人类消费。该描述由密码实现自行决定。

EVP_CIPHER_get0_provider()

返回一个OSSL_PROVIDER指针，指向实现给定EVP_CIPHER的提供者。

EVP_CIPHER_CTX_get0_cipher()

传递EVP_CIPHER_CTX结构时返回EVP_CIPHER结构。EVP_CIPHER_CTX_get1_cipher() 是相同的，只是所有权传递给调用者。

EVP_CIPHER_get_mode() and EVP_CIPHER_CTX_get_mode()

返回分组密码模式：EVP_CIPH_ECB_MODE、EVP_CIPH_CBC_MODE、EVP_CIPH_CFB_MODE、EVP_CIPH_OFB_MODE、EVP_CIPH_CTR_MODE、EVP_CIPH_GCM_MODE、EVP_CIPH_CCM_MODE、EVP_CIPH_XTS_MODE、EVP_CIPH_WRAP_MODE、EVP_CIPH_OCB_MODE 或 EVP_CIPH _SIV_模式。如果密码是流密码，则返回 EVP_CIPH_STREAM_CIPHER。

EVP_CIPHER_get_flags()

返回与密码关联的任何标志。有关当前定义的标志的列表， 请参阅“标志” 。

EVP_CIPHER_CTX_get_num() and EVP_CIPHER_CTX_set_num()

获取或设置关联ctx 的密码特定“num”参数。内置密码通常使用它来跟踪当前底层块有多少已经被“使用”。

EVP_CIPHER_CTX_is_encrypting()

报告ctx是否用于加密或解密。

EVP_CIPHER_CTX_flags()

已弃用的宏调用EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(ctx)). 不使用。

EVP_CIPHER_param_to_asn1()

根据传递的密码设置 AlgorithmIdentifier“参数”。这通常包括任何参数和 IV。进行此调用时必须设置密码 IV（如果有）。应在实际“使用”密码之前进行此调用（例如在任何 EVP_EncryptUpdate()、EVP_DecryptUpdate() 调用之前）。如果密码不支持任何 ASN1，此功能可能会失败。

EVP_CIPHER_asn1_to_param()

根据 ASN1 AlgorithmIdentifier“参数”设置密码参数。确切的效果取决于密码。以RC2为例，它将设置 IV 和有效密钥长度。应在设置基本密码类型之后但在设置密钥之前调用此函数。例如，将调用 EVP_CipherInit()，并将 IV 和密钥设置为 NULL，然后调用 EVP_CIPHER_asn1_to_param()，最后再次调用 EVP_CipherInit()，并将除密钥之外的所有参数设置为 NULL。如果密码不支持任何 ASN1 或无法设置参数（例如不支持 RC2 有效密钥长度），则此功能可能会失败。

EVP_CIPHER_CTX_rand_key()

根据密码上下文生成适当长度的随机密钥。EVP_CIPHER可以提供自己的随机密钥生成例程来支持特定形式的密钥。key必须指向至少与 EVP_CIPHER_CTX_get_key_length() 返回的值一样大的缓冲区。

EVP_CIPHER_do_all_provided()

遍历给定库上下文libctx 中所有激活的提供程序实现的所有密码，并且对于每个实现，使用实现方法和给定arg作为参数 调用给定函数fn 。

PARAMETERS

有关传递参数的信息，请参阅OSSL_PARAM(3)。

可获取的EVP_CIPHER参数

当调用 EVP_CIPHER_fetch() 时，它会在内部调用 EVP_CIPHER_get_params() 并缓存结果。

EVP_CIPHER_get_params() 可与以下OSSL_PARAM(3)键一起使用：

“mode” (OSSL_CIPHER_PARAM_MODE) <unsigned integer>

获取关联的密码算法cipher 的 模式。有关有效模式的列表，请参阅“EVP_CIPHER_get_mode() 和 EVP_CIPHER_CTX_get_mode()” 。使用 EVP_CIPHER_get_mode() 检索缓存的值。

“keylen” (OSSL_CIPHER_PARAM_KEYLEN) <unsigned integer>

获取关联密码算法cipher 的密钥长度。使用 EVP_CIPHER_get_key_length() 检索缓存的值。

“ivlen” (OSSL_CIPHER_PARAM_IVLEN) <unsigned integer>

获取关联密码算法cipher 的 IV 长度。使用 EVP_CIPHER_get_iv_length() 检索缓存的值。

“blocksize” (OSSL_CIPHER_PARAM_BLOCK_SIZE) <unsigned integer>

获取关联密码算法cipher 的块大小。对于流密码，块大小应为 1。请注意，密码的块大小可能与底层加密/解密原语的块大小不同。例如，CTR 模式下的 AES 的块大小为 1（因为它的运行方式类似于流密码），即使 AES 的块大小为 16。使用 EVP_CIPHER_get_block_size() 检索缓存的值。

“aead” (OSSL_CIPHER_PARAM_AEAD) <integer>

如果这是 AEAD 密码算法，则获取 1，否则获取 0。使用 (EVP_CIPHER_get_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) 检索缓存的值。

“custom-iv” (OSSL_CIPHER_PARAM_CUSTOM_IV) <integer>

如果密码算法密码具有自定义 IV，则获取 1，否则获取 0。如果使用自定义 IV，则存储和初始化 IV 完全留给实现。使用 (EVP_CIPHER_get_flags(cipher) & EVP_CIPH_CUSTOM_IV) 检索缓存的值。

“cts” (OSSL_CIPHER_PARAM_CTS) <integer>

如果密码算法密码使用密文窃取，则获取 1，否则获取 0。当前用于指示该密码是一次性的，仅允许对 EVP_CipherUpdate() 进行一次调用。使用 (EVP_CIPHER_get_flags(cipher) & EVP_CIPH_FLAG_CTS) 检索缓存的值。

“tls-multi” (OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK) <integer>

如果密码算法密码支持加密块的交错，则获取 1，否则获取 0。交错是仅适用于某些 TLS 密码的优化。使用 (EVP_CIPHER_get_flags(cipher) & EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK) 检索缓存的值。

“has-randkey” (OSSL_CIPHER_PARAM_HAS_RANDKEY) <integer>

如果密码算法密码支持可获取的 EVP_CIPHER_CTX 参数OSSL_CIPHER_PARAM_RANDOM_KEY ，则获取 1 。只有 DES 和 3DES 将此设置为 1，所有其他 OpenSSL 密码返回 0。

可获取和可设置的 EVP_CIPHER_CTX 参数

以下OSSL_PARAM(3)键可与 EVP_CIPHER_CTX_get_params() 和 EVP_CIPHER_CTX_set_params() 一起使用。

“padding” (OSSL_CIPHER_PARAM_PADDING) <unsigned integer>

获取或设置密码上下文ctx的填充模式。如果值为 1，则启用填充；如果值为 0，则禁用填充。另请参见 EVP_CIPHER_CTX_set_padding()。

“num” (OSSL_CIPHER_PARAM_NUM) <unsigned integer>

获取或设置密码上下文ctx的密码特定“num”参数。内置密码通常使用它来跟踪当前底层块有多少已经被“使用”。另请参见 EVP_CIPHER_CTX_get_num() 和 EVP_CIPHER_CTX_set_num()。

“keylen” (OSSL_CIPHER_PARAM_KEYLEN) <unsigned integer>

获取或设置密码上下文ctx 的密钥长度。“keylen”参数的长度不应超过size_t的长度。另请参见 EVP_CIPHER_CTX_get_key_length() 和 EVP_CIPHER_CTX_set_key_length()。

“tag” (OSSL_CIPHER_PARAM_AEAD_TAG) <octet string>

获取或设置关联密码上下文ctx 的 AEAD 标记。请参阅EVP_EncryptInit(3) 中的“AEAD 接口”。

“keybits” (OSSL_CIPHER_PARAM_RC2_KEYBITS) <unsigned integer>

获取或设置用于 RC2 密码的有效密钥位。“keybits”参数的长度不应超过size_t的长度。

“rounds” (OSSL_CIPHER_PARAM_ROUNDS) <unsigned integer>

获取或设置用于密码的轮数。这是由 RC5 密码使用的。

“alg_id_param” (OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS) <octet string>

用于将 DER 编码的 AlgorithmIdentifier 参数传入或传出密码实现。EVP_CIPHER_param_to_asn1(3)和EVP_CIPHER_asn1_to_param(3)等函数将此参数用于任何设置了标志EVP_CIPH_FLAG_CUSTOM_ASN1的实现。

“cts_mode” (OSSL_CIPHER_PARAM_CTS_MODE) <UTF8 string>

获取或设置密文窃取模式。对于所有模式，输出大小与输入大小相同。输入长度必须大于或等于块大小。（AES 和 CAMELLIA 的块大小为 16 字节）。

该模式的有效值为：

“CS1”

NIST 密文窃取变体。对于块大小倍数的输入长度，相当于使用“AES-XXX-CBC”或“CAMELLIA-XXX-CBC”密码，否则倒数第二个密码文本块是部分块。

“CS2”

对于块大小倍数的输入长度，相当于使用“AES-XXX-CBC”或“CAMELLIA-XXX-CBC”密码，否则与“CS3”模式相同。

“CS3”

密文窃取的 Kerberos5 变体始终将最后一个密文块与前一个块交换（可能是部分块或完整块，具体取决于输入长度）。如果输入长度恰好是一个完整块，则这相当于使用“AES-XXX-CBC”或“CAMELLIA-XXX-CBC”密码。

默认为“CS1”。仅支持“AES-128-CBC-CTS”、“AES-192-CBC-CTS”、“AES-256-CBC-CTS”、“CAMELLIA-128-CBC-CTS”、“CAMELLIA-192- CBC-CTS”和“CAMELLIA-256-CBC-CTS”。

“tls1multi_interleave” (OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE) <unsigned integer>

设置或获取 tls1 多块密码操作一次性发送的记录数（4 或 8 条记录）。

可获取的EVP_CIPHER_CTX参数

以下OSSL_PARAM(3)键可与 EVP_CIPHER_CTX_get_params() 一起使用：

“ivlen” (OSSL_CIPHER_PARAM_IVLEN and <OSSL_CIPHER_PARAM_AEAD_IVLEN) <unsigned integer>

获取密码上下文ctx 的 IV 长度。“ivlen”参数的长度不应超过size_t的长度。另请参见 EVP_CIPHER_CTX_get_iv_length()。

“iv” (OSSL_CIPHER_PARAM_IV) <octet string OR octet ptr>

获取用于初始化关联的密码上下文ctx的 IV 。另请参见 EVP_CIPHER_CTX_get_original_iv()。

“updated-iv” (OSSL_CIPHER_PARAM_UPDATED_IV) <octet string OR octet ptr>

获取关联密码上下文的更新伪 IV 状态，例如 CBC 模式的先前密文块或 OFB 模式的迭代加密 IV 值。请注意，八位字节指针访问已被弃用，提供它只是为了向后兼容历史 libcrypto API。另请参见 EVP_CIPHER_CTX_get_updated_iv()。

“randkey” (OSSL_CIPHER_PARAM_RANDOM_KEY) <octet string>

获取关联密码上下文ctx 的特定于实现的随机生成密钥。目前仅 DES 和 3DES 支持此功能（将密钥设置为奇校验）。

“taglen” (OSSL_CIPHER_PARAM_AEAD_TAGLEN) <unsigned integer>

获取用于关联密码上下文ctx的 AEAD 密码的标签长度​​。如果尚未设置，它将获得默认值。“taglen”参数的长度不应超过size_t的长度。另请参见 EVP_CIPHER_CTX_get_tag_length()。

“tlsaadpad” (OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD) <unsigned integer>

获取将添加到关联密码上下文ctx 的 AEAD 标签的 TLS 记录中的标签长度​​。“tlsaadpad”参数的长度不应超过size_t的长度。

“tlsivgen” (OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN) <octet string>

获取为加密生成的调用字段。只能在设置“tlsivfixed”后调用。这仅用于 GCM 模式。

“tls1multi_enclen” (OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN) <unsigned integer>

获取“tls1multi_enc”操作返回的记录的总长度。

“tls1multi_maxbufsz” (OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE) <unsigned integer>

获取 TLS1 多块密码操作的最大记录长度。“tls1multi_maxbufsz”参数的长度不应超过size_t的长度。

“tls1multi_aadpacklen” (OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN) <unsigned integer>

获取运行“tls1multi_aad”操作的结果。

“tls-mac” (OSSL_CIPHER_PARAM_TLS_MAC) <octet ptr>

用于传递 TLS MAC 数据。

可设置的 EVP_CIPHER_CTX 参数

以下OSSL_PARAM(3)键可与 EVP_CIPHER_CTX_set_params() 一起使用：

“mackey” (OSSL_CIPHER_PARAM_AEAD_MAC_KEY) <octet string>

设置复合 AEAD 密码（例如 AES-CBC-HMAC-SHA256）使用的 MAC 密钥。

“speed” (OSSL_CIPHER_PARAM_SPEED) <unsigned integer>

设置关联密码上下文的速度选项。仅 AES SIV 密码支持此功能，默认情况下不允许多个操作。将“速度”设置为 1 允许执行另一次加密或解密操作。这用于性能测试。

“use-bits” (OSSL_CIPHER_PARAM_USE_BITS) <unsigned integer>

确定传递给 EVP_EncryptUpdate()、EVP_DecryptUpdate() 和 EVP_CipherUpdate() 的输入长度inl是位数还是字节数。将“use-bits”设置为 1 使用位。默认值以字节为单位。这仅用于CFB1密码。

可以使用 EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS) 进行设置。

“tls-version” (OSSL_CIPHER_PARAM_TLS_VERSION) <integer>

设置 TLS 版本。

“tls-mac-size” (OSSL_CIPHER_PARAM_TLS_MAC_SIZE) <unsigned integer>

设置 TLS MAC 大小。

“tlsaad” (OSSL_CIPHER_PARAM_AEAD_TLS1_AAD) <octet string>

为关联的密码上下文ctx设置 TLSv1.2 AAD 信息。TLSv1.2 AAD 信息的长度始终为 13 个字节，并且如 RFC5246 第 6.2.3.3 节中所述的“additional_data”字段的定义。

“tlsivfixed” (OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED) <octet string>

为关联密码上下文的 TLS 记录加密/解密中使用的 AEAD 密码设置 IV 的固定部分。TLS 记录加密/解密始终“就地”发生，因此输入和输出缓冲区始终位于相同的内存位置。TLSv1.2 中的 AEAD IV 由隐式​​“固定”部分和随每个记录而变化的显式部分组成。设置 TLS 固定 IV 会更改加密/解密 TLS 记录的密码。TLS 记录使用每个记录的单个 OSSL_FUNC_cipher_cipher 调用进行加密/解密。对于记录解密，输入缓冲区的第一个字节将是 IV 的显式部分，输入缓冲区的最后一个字节将是 AEAD 标记。IV 显式部分的长度和标签长度将取决于所使用的密码，并将在相关密码套件的 RFC 中定义。为了允许“就地”解密，明文输出应写入输出缓冲区中读取密文有效负载的同一位置，即紧接在显式 IV 之后。

加密记录时，输入缓冲区的前字节应为空，以便为显式 IV 留出空间，写入标签的最后字节也是如此。输入缓冲区的长度将包括显式 IV 的长度、有效负载和标记字节。密码实现应该生成显式 IV 并将其写入输出缓冲区的开头，对有效负载进行“就地”加密并将其写入输出缓冲区，最后将标签添加到输出缓冲区的末尾。

无论是加密还是解密 OSSL_FUNC_cipher_cipher 调用中写入*outl 的值都应该是有效负载的长度，不包括显式 IV 长度和标记长度。

“tlsivinv” (OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV) <octet string>

设置用于解密的调用字段。只能在设置“tlsivfixed”后调用。这仅用于 GCM 模式。

“tls1multi_enc” (OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC) <octet string>

为支持一次性发送 4 或 8 条记录的 TLS1 感知密码触发多块 TLS1 加密操作。密码执行 MAC 和加密阶段并自行构造记录标头。“tls1multi_enc”为加密操作提供输出缓冲区，还必须设置“tls1multi_encin”和“tls1multi_interleave”以便为加密操作提供值。

“tls1multi_encin” (OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN) <octet string>

提供要加密的数据以进行 TLS1 多块密码操作。

“tls1multi_maxsndfrag” (OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT) <unsigned integer>

设置 TLS1 多块密码操作的最大发送片段大小。必须在使用“tls1multi_maxbufsz”之前设置。“tls1multi_maxsndfrag”参数的长度不应超过size_t的长度。

“tls1multi_aad” (OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD) <octet string>

设置 TLS1 多块密码操作使用的经过身份验证的附加数据。提供的数据由 13 个字节的记录数据组成，其中包含： 字节 0-7：第一个记录的序列号 字节 8：记录类型 字节 9-10：协议版本 字节 11-12：输入长度（始终为 0）

为此操作还必须设置“tls1multi_interleave”。

CONTROLS

以下部分列出了从 EVP_CIPHER_CTX_ctrl() 标识符到 PARAMETERS 的映射。有关更多详细信息， 请参阅“参数”部分。

EVP_CIPHER_CTX_ctrl() 可用于发送以下标准控件：

EVP_CTRL_AEAD_SET_IVLEN and EVP_CTRL_GET_IVLEN

当与获取的EVP_CIPHER一起使用时，EVP_CIPHER_CTX_set_params() 和 EVP_CIPHER_CTX_get_params() 会通过带有键“ivlen”( OSSL_CIPHER_PARAM_IVLEN ) 的OSSL_PARAM(3)项进行调用。

EVP_CTRL_AEAD_SET_IV_FIXED

当与获取的EVP_CIPHER一起使用时，EVP_CIPHER_CTX_set_params() 会通过带有键“tlsivfixed”（OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED） 的OSSL_PARAM(3)项调用。

EVP_CTRL_AEAD_SET_MAC_KEY

当与获取的EVP_CIPHER一起使用时，EVP_CIPHER_CTX_set_params() 会通过带有键“mackey”的OSSL_PARAM(3)项调用( OSSL_CIPHER_PARAM_AEAD_MAC_KEY )。

EVP_CTRL_AEAD_SET_TAG and EVP_CTRL_AEAD_GET_TAG

当与获取的EVP_CIPHER一起使用时，EVP_CIPHER_CTX_set_params() 和 EVP_CIPHER_CTX_get_params() 会通过带有键“tag”( OSSL_CIPHER_PARAM_AEAD_TAG ) 的OSSL_PARAM(3)项进行调用。

EVP_CTRL_CCM_SET_L

当与获取的EVP_CIPHER 一起使用时，EVP_CIPHER_CTX_set_params() 会通过OSSL_PARAM(3)项调用，其中键为“ivlen”( OSSL_CIPHER_PARAM_IVLEN )，值为 (15 - L)

EVP_CTRL_COPY

没有为此的 OSSL_PARAM 映射。请改用 EVP_CIPHER_CTX_copy()。

EVP_CTRL_GCM_SET_IV_INV

当与获取的EVP_CIPHER一起使用时，EVP_CIPHER_CTX_set_params() 会通过带有键“tlsivinv”（OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV ）的OSSL_PARAM(3)项调用。

EVP_CTRL_RAND_KEY

当与获取的EVP_CIPHER一起使用时，EVP_CIPHER_CTX_set_params() 会通过带有键“randkey”（OSSL_CIPHER_PARAM_RANDOM_KEY） 的OSSL_PARAM(3)项进行调用。

EVP_CTRL_SET_KEY_LENGTH

当与获取的EVP_CIPHER一起使用时，EVP_CIPHER_CTX_set_params() 会通过带有键“keylen”( OSSL_CIPHER_PARAM_KEYLEN ) 的OSSL_PARAM(3)项进行调用。

EVP_CTRL_SET_RC2_KEY_BITS and EVP_CTRL_GET_RC2_KEY_BITS

当与获取的EVP_CIPHER一起使用时，EVP_CIPHER_CTX_set_params() 和 EVP_CIPHER_CTX_get_params() 会通过带有键“keybits”( OSSL_CIPHER_PARAM_RC2_KEYBITS ) 的OSSL_PARAM(3)项进行调用。

EVP_CTRL_SET_RC5_ROUNDS and EVP_CTRL_GET_RC5_ROUNDS

当与获取的EVP_CIPHER一起使用时，EVP_CIPHER_CTX_set_params() 和 EVP_CIPHER_CTX_get_params() 会通过带有键“rounds”( OSSL_CIPHER_PARAM_ROUNDS ) 的OSSL_PARAM(3)项进行调用。

EVP_CTRL_SET_SPEED

当与获取的EVP_CIPHER一起使用时，EVP_CIPHER_CTX_set_params() 会通过带有键“speed”( OSSL_CIPHER_PARAM_SPEED ) 的OSSL_PARAM(3)项进行调用。

EVP_CTRL_GCM_IV_GEN

当与获取的EVP_CIPHER一起使用时，EVP_CIPHER_CTX_get_params() 会通过带有键“tlsivgen”（OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN） 的OSSL_PARAM(3)项调用。

EVP_CTRL_AEAD_TLS1_AAD

当与获取的EVP_CIPHER 一起使用时，EVP_CIPHER_CTX_set_params() 会使用键为“tlsaad”( OSSL_CIPHER_PARAM_AEAD_TLS1_AAD )的 OSSL_PARAM(3)项调用，然后使用键为“tlsaadpad”( OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PA )的 EVP_CIPHER_CTX_get_params() 进行调用D）。

EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE

当与获取的EVP_CIPHER 一起使用时，EVP_CIPHER_CTX_set_params() 会被OSSL_PARAM(3)项调用，其中键为 OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT，后跟 EVP_CIPHER_CTX_get_params() ，键为“tls1multi_maxbufsz” ( OSSL_CIPHER_PARAM_TLS1_MU LTIBLOCK_MAX_BUFSIZE）。

EVP_CTRL_TLS1_1_MULTIBLOCK_AAD

当与获取的EVP_CIPHER 一起使用时，EVP_CIPHER_CTX_set_params() 会被OSSL_PARAM(3)项调用，其中键为“tls1multi_aad”（OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD）和“tls1multi_interleave” （ OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE），后跟 EVP_CIPHER_C TX_get_params() 的键为“tls1multi_aadpacklen”（OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN）和“ tls1multi_interleave”（OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE）。

EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT

当与获取的EVP_CIPHER 一起使用时，EVP_CIPHER_CTX_set_params() 会被OSSL_PARAM(3)项调用，其中包含键“tls1multi_enc”（OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC）、“tls1multi_encin”（OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN）和“tls1multi_interleave” ( OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE )，后跟带有密钥的 EVP_CIPHER_CTX_get_params() “tls1multi_enclen”（OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN）。

FLAGS

EVP_CIPHER_CTX_set_flags()、EVP_CIPHER_CTX_clear_flags() 和 EVP_CIPHER_CTX_test_flags()。可用于操作和测试这些EVP_CIPHER_CTX标志：

EVP_CIPH_NO_PADDING

由 EVP_CIPHER_CTX_set_padding() 使用。

另请参见“可获取和可设置的 EVP_CIPHER_CTX 参数” “填充”

EVP_CIPH_FLAG_LENGTH_BITS

请参阅“可设置的 EVP_CIPHER_CTX 参数” “使用位”。

EVP_CIPHER_CTX_FLAG_WRAP_ALLOW

仅用于旧版目的。需要设置此标志来指示密码处理的包装。

EVP_CIPHER_flags() 使用以下标记，这些标记映射到“可获取的 EVP_CIPHER 参数”：

EVP_CIPH_FLAG_AEAD_CIPHER

请参阅“可获取的 EVP_CIPHER 参数” “aead”。

EVP_CIPH_CUSTOM_IV

请参阅“可获取的 EVP_CIPHER 参数” “custom-iv”。

EVP_CIPH_FLAG_CTS

请参阅“可获取的 EVP_CIPHER 参数” “cts”。

EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK;

请参阅“可获取的 EVP_CIPHER 参数” “tls-multi”。

EVP_CIPH_RAND_KEY

请参阅“可获取的 EVP_CIPHER 参数” “has-randkey”。

EVP_CIPHER_flags() 使用以下标志仅用于遗留目的：

EVP_CIPH_VARIABLE_LENGTH
EVP_CIPH_FLAG_CUSTOM_CIPHER
EVP_CIPH_ALWAYS_CALL_INIT
EVP_CIPH_CTRL_INIT
EVP_CIPH_CUSTOM_KEY_LENGTH
EVP_CIPH_CUSTOM_COPY
EVP_CIPH_FLAG_DEFAULT_ASN1

有关上述标志的更多信息， 请参阅EVP_CIPHER_meth_set_flags(3) 。

RETURN VALUES

EVP_CIPHER_fetch()成功时返回指向EVP_CIPHER 的 指针，失败时返回NULL。

EVP_CIPHER_up_ref() 成功返回 1，否则返回 0。

如果成功， EVP_CIPHER_CTX_new() 返回指向新创建的EVP_CIPHER_CTX 的 指针；如果失败，则返回NULL。

EVP_EncryptInit_ex2()、EVP_EncryptUpdate() 和 EVP_EncryptFinal_ex() 返回 1 表示成功，0 表示失败。

EVP_DecryptInit_ex2() 和 EVP_DecryptUpdate() 返回 1 表示成功，0 表示失败。如果解密失败，EVP_DecryptFinal_ex() 返回 0；如果成功，则返回 1。

EVP_CipherInit_ex2() 和 EVP_CipherUpdate() 返回 1 表示成功，0 表示失败。EVP_CipherFinal_ex() 解密失败时返回 0，成功时返回 1。

如果未为密码设置标志EVP_CIPH_FLAG_CUSTOM_CIPHER ，则 EVP_Cipher() 在成功时返回 1，在失败时返回 0 。如果为密码设置了标志EVP_CIPH_FLAG_CUSTOM_CIPHER，则 EVP_Cipher() 返回写入out以进行加密/解密的字节数，或者在为 AEAD 密码指定 AAD 的调用中验证的字节数。

EVP_CIPHER_CTX_reset() 返回 1 表示成功，0 表示失败。

EVP_get_cipherbyname()、EVP_get_cipherbynid() 和 EVP_get_cipherbyobj() 返回EVP_CIPHER结构或出错时返回 NULL。

EVP_CIPHER_get_nid() 和 EVP_CIPHER_CTX_get_nid() 返回 NID。

EVP_CIPHER_get_block_size() 和 EVP_CIPHER_CTX_get_block_size() 返回块大小。

EVP_CIPHER_get_key_length() 和 EVP_CIPHER_CTX_get_key_length() 返回密钥长度。

EVP_CIPHER_CTX_set_padding() 始终返回 1。

EVP_CIPHER_get_iv_length() 和 EVP_CIPHER_CTX_get_iv_length() 返回 IV 长度，如果密码不使用 IV，则返回零。

EVP_CIPHER_CTX_get_tag_length() 返回标签长度，如果密码不使用标签，则返回零。

EVP_CIPHER_get_type() 和 EVP_CIPHER_CTX_get_type() 返回密码的 OBJECT IDENTIFIER 的 NID，如果没有定义的 OBJECT IDENTIFIER，则返回 NID_undef。

EVP_CIPHER_CTX_cipher() 返回EVP_CIPHER结构。

如果实现不支持调用或出现任何其他错误， EVP_CIPHER_CTX_get_num() 将返回非负数值或EVP_CTRL_RET_UNSUPPORTED 。

EVP_CIPHER_CTX_set_num() 成功时返回 1，如果实现不支持调用或出现任何其他错误，则返回 0。

如果ctx设置为加密， 则 EVP_CIPHER_CTX_is_encrypting() 返回 1，否则返回 0。

EVP_CIPHER_param_to_asn1() 和 EVP_CIPHER_asn1_to_param() 成功时返回大于零的值，失败时返回零或负数。

EVP_CIPHER_CTX_rand_key() 返回 1 表示成功，返回 0 或负数表示失败。

如果为所有名称调用回调，则 EVP_CIPHER_names_do_all() 返回 1。返回值 0 表示未针对任何名称调用回调。

CIPHER LISTING

除非另有说明，所有算法都有固定的密钥长度。

请参阅“另请参见”，了解可通过 EVP 接口使用的密码的完整列表。

EVP_enc_null()

空密码：不执行任何操作。

AEAD INTERFACE

带有关联数据的身份验证加密 (AEAD) 模式的 EVP 接口经过细微更改，并且根据指定的模式支持 多个附加的ctrl操作。

要指定其他经过身份验证的数据 (AAD)，应调用 EVP_CipherUpdate()、EVP_EncryptUpdate() 或 EVP_DecryptUpdate()，并将输出参数out设置为NULL。在这种情况下，成功后，参数outl将设置为已验证的字节数。

解密时，EVP_DecryptFinal()或EVP_CipherFinal()的返回值指示操作是否成功。如果它没有指示成功，则身份验证操作失败，并且任何输出数据都不得使用，因为它已损坏。

GCM 和 OCB 模式

GCM 和 OCB 模式支持 以下ctrl 。

EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, ivlen, NULL)

设置 IV 长度。此调用只能在指定 IV 之前进行。如果未调用，则使用默认 IV 长度。

对于 GCM AES 和 OCB AES，默认值为 12（即 96 位）。对于 OCB 模式，最大值为 15。

EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, taglen, tag)

将taglen标签值的字节写入由 指示的缓冲区tag。仅当加密数据且处理完所有数据 后（例如，在调用 EVP_EncryptFinal() 后）才能进行此调用。

对于 OCB，必须为 16 或之前通过EVP_CTRL_AEAD_SET_TAGtaglen设置的值。

EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, taglen, tag)

解密时，此调用将预期标记设置为taglen来自 的字节tag。taglen必须介于 1 到 16 之间（含 1 和 16）。必须在调用 EVP_DecryptFinal() 或 EVP_DecryptFinal_ex() 之前设置该标记。

对于 GCM，此调用仅在解密数据时有效。

对于 OCB，当解密数据以设置预期标签以及加密以设置所需标签长度时，此调用有效。

在 OCB 模式下，使用tagset 加密时调用该函数可以NULL设置标签长度。标签长度只能在指定 IV 之前设置。如果在加密期间设置 IV 之前未调用此函数，则使用默认标签长度。

对于 OCB AES，默认标记长度为 16（即 128 位）。这也是 OCB 的最大标签长度。

CCM模式

CCM 模式的 EVP 界面与 GCM 模式的界面类似，但有一些额外的要求和不同的ctrl值。

对于 CCM 模式，必须将 明文或密文的总长度传递给 EVP_CipherUpdate()、EVP_EncryptUpdate() 或 EVP_DecryptUpdate()，并将输出和输入参数（in和out）设置为NULL，并且长度在inl参数中传递。

CCM 模式支持 以下ctrl 。

EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, taglen, tag)

进行此调用是为了在解密时设置预期的CCM标记值或在加密时设置标记的长度（参数tag设置为 NULL）。标签长度通常称为M。如果未设置，则使用默认值（AES 为 12）。解密时，需要在传入要解密的数据之前设置标签，但与 GCM 和 OCB 模式一样，可以在传递额外的验证数据之后设置标签（参见“AEAD INTERFACE”）。

EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_L, ivlen, NULL)

设置 CCM L值。如果未设置，则使用默认值（AES 为 8）。

EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, ivlen, NULL)

设置 CCM 随机数 (IV) 长度。此调用只能在指定随机数值之前进行。随机数长度由15 - L给出，因此 AES 默认为 7。

SIV模式

对于 SIV 模式密码，EVP 接口的行为发生了微妙的变化，并且支持一些附加的 ctrl 操作。

要指定任何其他经过身份验证的数据 (AAD) 和/或 Nonce，应调用 EVP_CipherUpdate()、EVP_EncryptUpdate() 或 EVP_DecryptUpdate() 并将输出参数 out设置为NULL。

RFC5297 指出，Nonce 是实际加密/解密发生之前 AAD 的最后一块。API 不区分 Nonce 和其他 AAD。

解密时，EVP_DecryptFinal() 或 EVP_CipherFinal() 的返回值指示操作是否成功。如果它没有指示成功，则身份验证操作失败，并且任何输出数据都不得使用，因为它已损坏。

API 不存储密文中的 SIV（合成初始化向量）。相反，它作为标签存储在 EVP_CIPHER_CTX 中。SIV 必须在加密后从上下文中检索，并在解密前设置到上下文中。

这与 RFC5297 的不同之处在于，加密的密码输出和解密的密码输入不包含 SIV。这也意味着明文和密文的长度是相同的。

SIV 模式支持以下 ctrl，用于获取和设置综合初始化向量：

EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, taglen, tag);

将标记值（合成初始化向量）的taglen字节写入tag指示的缓冲区。仅当加密数据且处理完所有数据后（例如，在调用 EVP_EncryptFinal() 后）才能进行此调用。对于 SIV 模式，taglen 必须为 16。

EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, taglen, tag);

将预期标记（综合初始化向量）设置为tag中的taglen字节。此调用仅在解密数据时才合法，并且必须在处理任何数据之前进行（例如，在任何 EVP_DecryptUpdate() 调用之前）。对于 SIV 模式，taglen 必须为 16。

SIV 模式对输入数据进行两次传递，因此，只应调用一次 EVP_CipherUpdate()、EVP_EncryptUpdate() 或 EVP_DecryptUpdate()，而不将其设置为非NULL值。不需要调用 EVP_DecryptFinal() 或 EVP_CipherFinal()，但会指示更新操作是否成功。

ChaCha20-Poly1305

ChaCha20-Poly1305 AEAD 算法支持 以下ctrl 。

EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, ivlen, NULL)

设置随机数长度。该调用现在是多余的，因为唯一有效的值是默认长度 12（即 96 位）。在 OpenSSL 3.0 之前，可以使用小于 12 字节的随机数自动用前导 0 字节填充 iv，使其长度为 12 字节。

EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, taglen, tag)

将taglen标签值的字节写入由 指示的缓冲区tag。仅当加密数据且处理完所有数据 后（例如，在调用 EVP_EncryptFinal() 后）才能进行此调用。

taglen此处指定的值必须为 16（POLY1305_BLOCK_SIZE，即 128 位）或更少。

EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, taglen, tag)

将预期标记设置为taglen来自 的字节tag。标签长度只能在指定 IV 之前设置。taglen必须介于 1 到 16 ( POLY1305_BLOCK_SIZE ) 之间（含边界值）。该调用仅在解密数据时有效。

NOTES

在可能的情况下，应优先使用对称密码的EVP接口而不是低级接口。这是因为代码对于所使用的密码变得透明并且更加灵活。此外，EVP接口将确保使用特定于平台的加密加速，例如 AES-NI（低级接口不提供保证）。

PKCS 填充的工作原理是添加n 个填充字节（值为n），使加密数据的总长度成为块大小的倍数。总是添加填充，因此如果数据已经是块大小的倍数，则n将等于块大小。例如，如果块大小为 8 并且要加密 11 字节，则将添加值为 5 的 5 个填充字节。

解密时检查最终块以查看它是否具有正确的形式。

虽然如果启用填充，解密操作可能会产生错误，但这并不是输入数据或密钥正确性的有力测试。随机块具有正确格式的机会高于 256 分之一，并且早期输入数据的问题不会产生最终的解密错误。

如果禁用填充，则当解密的数据总量是块大小的倍数时，解密操作将始终成功。

函数 EVP_EncryptInit()、EVP_EncryptInit_ex()、EVP_EncryptFinal()、EVP_DecryptInit()、EVP_DecryptInit_ex()、EVP_CipherInit()、EVP_CipherInit_ex() 和 EVP_CipherFinal() 已过时，但为了与现有代码兼容而保留。新代码应使用 EVP_EncryptInit_ex2()、EVP_EncryptFinal_ex()、EVP_DecryptInit_ex2()、EVP_DecryptFinal_ex()、EVP_CipherInit_ex2() 和 EVP_CipherFinal_ex()，因为它们可以重用现有上下文，而无需在每次调用时分配和释放它。

函数 EVP_CipherInit() 和 EVP_CipherInit_ex() 之间存在一些差异，在某些情况下很重要。EVP_CipherInit() 用零填充传递的上下文对象。因此，当密钥和iv在单独的调用中传递时，EVP_CipherInit() 不允许逐步初始化 ctx 。这也意味着为 CTX 设置的标志被删除，对于在 EVP_CipherInit_ex() 中专门处理的EVP_CIPHER_CTX_FLAG_WRAP_ALLOW标志尤其重要。

在调用更新或完成上下文的函数时，忽略EVP_CIPHER_CTX初始化函数 的失败返回可能会导致后续未定义的行为。初始化失败时， EVP_CIPHER_CTX上唯一有效的调用是尝试再次初始化上下文或释放上下文的调用。

EVP_get_cipherbynid() 和 EVP_get_cipherbyobj() 作为宏实现。

BUGS

EVP_MAX_KEY_LENGTH和EVP_MAX_IV_LENGTH仅指具有默认密钥长度的内部密码。如果自定义密码超过这些值，结果将不可预测。这是因为将通用密钥定义为包含EVP_MAX_KEY_LENGTH字节的固定无符号字符数组已成为标准做法。

ASN1 代码不完整（有时不准确），仅在 CBC 模式下针对某些常见 S/MIME 密码（RC2、DES、三重 DES）进行了测试。

EXAMPLES

使用 IDEA 加密字符串： 

 int do_crypt(char *outfile)
{
    unsigned char outbuf[1024];
    int outlen, tmplen;
    /*
     * Bogus key and IV: we'd normally set these from
     * another source.
     */
    unsigned char key[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
    unsigned char iv[] = {1,2,3,4,5,6,7,8};
    char intext[] = "Some Crypto Text";
    EVP_CIPHER_CTX *ctx;
    FILE *out;

    ctx = EVP_CIPHER_CTX_new();
    if (!EVP_EncryptInit_ex2(ctx, EVP_idea_cbc(), key, iv, NULL)) {
        /* Error */
        EVP_CIPHER_CTX_free(ctx);
        return 0;
    }

    if (!EVP_EncryptUpdate(ctx, outbuf, &outlen, intext, strlen(intext))) {
        /* Error */
        EVP_CIPHER_CTX_free(ctx);
        return 0;
    }
    /*
     * Buffer passed to EVP_EncryptFinal() must be after data just
     * encrypted to avoid overwriting it.
     */
    if (!EVP_EncryptFinal_ex(ctx, outbuf + outlen, &tmplen)) {
        /* Error */
        EVP_CIPHER_CTX_free(ctx);
        return 0;
    }
    outlen += tmplen;
    EVP_CIPHER_CTX_free(ctx);
    /*
     * Need binary mode for fopen because encrypted data is
     * binary data. Also cannot use strlen() on it because
     * it won't be NUL terminated and may contain embedded
     * NULs.
     */
    out = fopen(outfile, "wb");
    if (out == NULL) {
        /* Error */
        return 0;
    }
    fwrite(outbuf, 1, outlen, out);
    fclose(out);
    return 1;
}

可以使用openssl实用程序和命令行来 解密上述示例中的密文（为了清楚起见，显示为两行）：

 openssl idea -d \
    -K 000102030405060708090A0B0C0D0E0F -iv 0102030405060708 <filename

使用 FILE I/O 和 AES128 以及 128 位密钥的一般加密和解密函数示例： 

 int do_crypt(FILE *in, FILE *out, int do_encrypt)
{
    /* Allow enough space in output buffer for additional block */
    unsigned char inbuf[1024], outbuf[1024 + EVP_MAX_BLOCK_LENGTH];
    int inlen, outlen;
    EVP_CIPHER_CTX *ctx;
    /*
     * Bogus key and IV: we'd normally set these from
     * another source.
     */
    unsigned char key[] = "0123456789abcdeF";
    unsigned char iv[] = "1234567887654321";

    /* Don't set key or IV right away; we want to check lengths */
    ctx = EVP_CIPHER_CTX_new();
    if (!EVP_CipherInit_ex2(ctx, EVP_aes_128_cbc(), NULL, NULL,
                            do_encrypt, NULL)) {
        /* Error */
        EVP_CIPHER_CTX_free(ctx);
        return 0;
    }
    OPENSSL_assert(EVP_CIPHER_CTX_get_key_length(ctx) == 16);
    OPENSSL_assert(EVP_CIPHER_CTX_get_iv_length(ctx) == 16);

    /* Now we can set key and IV */
    if (!EVP_CipherInit_ex2(ctx, NULL, key, iv, do_encrypt, NULL)) {
        /* Error */
        EVP_CIPHER_CTX_free(ctx);
        return 0;
    }

    for (;;) {
        inlen = fread(inbuf, 1, 1024, in);
        if (inlen <= 0)
            break;
        if (!EVP_CipherUpdate(ctx, outbuf, &outlen, inbuf, inlen)) {
            /* Error */
            EVP_CIPHER_CTX_free(ctx);
            return 0;
        }
        fwrite(outbuf, 1, outlen, out);
    }
    if (!EVP_CipherFinal_ex(ctx, outbuf, &outlen)) {
        /* Error */
        EVP_CIPHER_CTX_free(ctx);
        return 0;
    }
    fwrite(outbuf, 1, outlen, out);

    EVP_CIPHER_CTX_free(ctx);
    return 1;
}

使用 AES-CBC 和 256 位密钥进行加密，并进行“CS1”密文窃取。 

 int encrypt(const unsigned char *key, const unsigned char *iv,
            const unsigned char *msg, size_t msg_len, unsigned char *out)
{
   /*
    * This assumes that key size is 32 bytes and the iv is 16 bytes.
    * For ciphertext stealing mode the length of the ciphertext "out" will be
    * the same size as the plaintext size "msg_len".
    * The "msg_len" can be any size >= 16.
    */
    int ret = 0, encrypt = 1, outlen, len;
    EVP_CIPHER_CTX *ctx = NULL;
    EVP_CIPHER *cipher = NULL;
    OSSL_PARAM params[2];

    ctx = EVP_CIPHER_CTX_new();
    cipher = EVP_CIPHER_fetch(NULL, "AES-256-CBC-CTS", NULL);
    if (ctx == NULL || cipher == NULL)
        goto err;

    /*
     * The default is "CS1" so this is not really needed,
     * but would be needed to set either "CS2" or "CS3".
     */
    params[0] = OSSL_PARAM_construct_utf8_string(OSSL_CIPHER_PARAM_CTS_MODE,
                                                 "CS1", 0);
    params[1] = OSSL_PARAM_construct_end();

    if (!EVP_CipherInit_ex2(ctx, cipher, key, iv, encrypt, params))
        goto err;

    /* NOTE: CTS mode does not support multiple calls to EVP_CipherUpdate() */
    if (!EVP_CipherUpdate(ctx, out, &outlen, msg, msg_len))
        goto err;
     if (!EVP_CipherFinal_ex(ctx, out + outlen, &len))
        goto err;
    ret = 1;
err:
    EVP_CIPHER_free(cipher);
    EVP_CIPHER_CTX_free(ctx);
    return ret;
}

SEE ALSO

evp(7)、property(7)、crypto(7) 中的“算法获取”、provider-cipher(7)、life_cycle-cipher(7)

支持的密码列于：

EVP_aes_128_gcm(3)、EVP_aria_128_gcm (3)、EVP_bf_cbc(3)、EVP_camellia_128_ecb (3) 、EVP_cast5_cbc(3)、EVP_chacha20 (3 )、 EVP_des_cbc(3) 、EVP_desx_cbc(3) 、 EVP_idea_cbc (3)、EVP_rc2_cbc(3)、EVP_rc4(3)、EVP_rc5_32_12_16_cbc(3)、EVP_seed_cbc(3)、EVP_sm4_cbc(3)、

HISTORY

OpenSSL 1.1.0 中添加了对 OCB 模式的支持。

EVP_CIPHER_CTX在 OpenSSL 1.1.0 中变得不透明。结果出现了EVP_CIPHER_CTX_reset()，而EVP_CIPHER_CTX_cleanup()消失了。EVP_CIPHER_CTX_init() 保留为 EVP_CIPHER_CTX_reset() 的别名。

EVP_CIPHER_CTX_cipher() 函数在 OpenSSL 3.0 中已弃用；请改用 EVP_CIPHER_CTX_get0_cipher() 。

EVP_EncryptInit_ex2()、EVP_DecryptInit_ex2()、EVP_CipherInit_ex2()、EVP_CIPHER_fetch()、EVP_CIPHER_free()、EVP_CIPHER_up_ref()、EVP_CIPHER_CTX_get0_cipher()、EVP_CIPHER_CTX_get1_cipher()、EVP_CIPHER_get_param s()、EVP_CIPHER_CTX_set_params()、EVP_CIPHER_CTX_get_params()、EVP_CIPHER_gettable_params()、EVP_CIPHER_settable_ctx_params ()、EVP_CIPHER_gettable_ctx_params()、EVP_CIPHER_CTX_settable_params() 和 EVP_CIPHER_CTX_gettable_params() 函数在 3.0 中添加。

EVP_CIPHER_nid()、EVP_CIPHER_name()、EVP_CIPHER_block_size()、EVP_CIPHER_key_length()、EVP_CIPHER_iv_length()、EVP_CIPHER_flags()、EVP_CIPHER_mode()、EVP_CIPHER_type()、EVP_CIPHER_CTX_nid()、EVP_CIPHER_CTX_ block_size()、EVP_CIPHER_CTX_key_length()、EVP_CIPHER_CTX_iv_length()、EVP_CIPHER_CTX_tag_length ()、EVP_CIPHER_CTX_num()、EVP_CIPHER_CTX_type() 和 EVP_CIPHER_CTX_mode() 函数分别重命名为在 OpenSSL 3.0 中的名称中包含get或。get0旧名称保留为未弃用的别名宏。

在 OpenSSL 3.0 中，EVP_CIPHER_CTX_encrypting() 函数已重命名为 EVP_CIPHER_CTX_is_encrypting()。旧名称保留为未弃用的别名宏。

EVP_CIPHER_CTX_flags() 宏在 OpenSSL 1.1.0 中已弃用。

版权所有 2000-2023 OpenSSL 项目作者。版权所有。

根据 Apache License 2.0（“许可证”）获得许可。除非遵守许可证，否则您不得使用此文件。您可以在源代码分发版或/source/license.html的 LICENSE 文件中获取副本。