EVP_ENCRYPTINIT(3) | Library Functions Manual | EVP_ENCRYPTINIT(3)

# NAME

`EVP_CIPHER_CTX_new`, `EVP_CIPHER_CTX_reset`, `EVP_CIPHER_CTX_free`, `EVP_CIPHER_CTX_copy`, `EVP_EncryptInit_ex`, `EVP_EncryptUpdate`, `EVP_EncryptFinal_ex`, `EVP_DecryptInit_ex`, `EVP_DecryptUpdate`, `EVP_DecryptFinal_ex`, `EVP_CipherInit_ex`, `EVP_CipherUpdate`, `EVP_CipherFinal_ex`, `EVP_EncryptInit`, `EVP_EncryptFinal`, `EVP_DecryptInit`, `EVP_DecryptFinal`, `EVP_CipherInit`, `EVP_CipherFinal`, `EVP_CIPHER_CTX_encrypting`, `EVP_get_cipherbyname`, `EVP_get_cipherbynid`, `EVP_get_cipherbyobj`, `EVP_CIPHER_CTX_cipher`, `EVP_enc_null`, `EVP_idea_cbc`, `EVP_idea_ecb`, `EVP_idea_cfb64`, `EVP_idea_cfb`, `EVP_idea_ofb`, `EVP_bf_cbc`, `EVP_bf_ecb`, `EVP_bf_cfb64`, `EVP_bf_cfb`, `EVP_bf_ofb`, `EVP_cast5_cbc`, `EVP_cast5_ecb`, `EVP_cast5_cfb64`, `EVP_cast5_cfb`, `EVP_cast5_ofb` — EVP cipher routines

# SYNOPSIS

library “libcrypto”
`#include <openssl/evp.h>`

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_CIPHER_CTX_copy`(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in);

int
`EVP_EncryptInit_ex`(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, ENGINE *engine, const unsigned char *key, const unsigned char *iv);

int
`EVP_EncryptUpdate`(EVP_CIPHER_CTX *ctx, unsigned char *out, int *out_len, const unsigned char *in, int in_len);

int
`EVP_EncryptFinal_ex`(EVP_CIPHER_CTX *ctx, unsigned char *out, int *out_len);

int
`EVP_DecryptInit_ex`(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, ENGINE *engine, const unsigned char *key, const unsigned char *iv);

int
`EVP_DecryptUpdate`(EVP_CIPHER_CTX *ctx, unsigned char *out, int *out_len, const unsigned char *in, int in_len);

int
`EVP_DecryptFinal_ex`(EVP_CIPHER_CTX *ctx, unsigned char *out, int *out_len);

int
`EVP_CipherInit_ex`(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, ENGINE *engine, const unsigned char *key, const unsigned char *iv, int enc);

int
`EVP_CipherUpdate`(EVP_CIPHER_CTX *ctx, unsigned char *out, int *out_len, const unsigned char *in, int in_len);

int
`EVP_CipherFinal_ex`(EVP_CIPHER_CTX *ctx, unsigned char *out, int *out_len);

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

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 *out, int *out_len);

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 *out, int *out_len);

int
`EVP_CIPHER_CTX_encrypting`(const EVP_CIPHER_CTX *ctx);

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

const EVP_CIPHER *
`EVP_CIPHER_CTX_cipher`(const EVP_CIPHER_CTX *ctx);

# DESCRIPTION

The EVP cipher routines are a high level interface to certain symmetric ciphers.

`EVP_CIPHER_CTX_new`() creates a new, empty cipher context.

`EVP_CIPHER_CTX_reset`() clears all information from ctx and frees all allocated memory associated with it, except the ctx object itself, such that it can be reused for another series of calls to `EVP_CipherInit`(), `EVP_CipherUpdate`(), and `EVP_CipherFinal`().

`EVP_CIPHER_CTX_free`() clears all information from ctx and frees all allocated memory associated with it, including ctx itself. This function should be called after all operations using a cipher are complete, so sensitive information does not remain in memory. If ctx is a `NULL` pointer, no action occurs.

`EVP_CIPHER_CTX_copy`() calls `EVP_CIPHER_CTX_reset`() on out and copies all the data from in to out, except that the EVP_CIPHER object used by in and any application specific data set with EVP_CIPHER_CTX_set_app_data(3) are not copied and out will point to the same two objects. The algorithm- and implementation-specific cipher data described in EVP_CIPHER_CTX_get_cipher_data(3) is copied with malloc(3) and memcpy(3), i.e. assuming that it does not contain pointers to any sub-objects. If the bit `EVP_CIPH_CUSTOM_COPY` has been set with EVP_CIPHER_meth_set_flags(3), EVP_CIPHER_CTX_ctrl(3) is called at the end with arguments in, `EVP_CTRL_COPY`, 0, and out such that the cipher implementation can perform further algorithm- and implementation-specific initializations after the algorithm- and implementation-specific cipher data has been copied. Among the cipher algorithms built into the library, `EVP_CIPH_CUSTOM_COPY` and `EVP_CTRL_COPY` are used by some of the ciphers documented in the EVP_aes_256_gcm(3) manual page.

`EVP_EncryptInit`() and `EVP_EncryptInit_ex`() set up the cipher context ctx for encryption with cipher type. type is normally supplied by a function such as EVP_aes_256_cbc(3). key is the symmetric key to use and iv is the IV to use (if necessary). The actual number of bytes used for the key and IV depends on the cipher. The ENGINE *engine argument is always ignored and passing `NULL` is recommended. It is possible to set all parameters to `NULL` except type in an initial call and supply the remaining parameters in subsequent calls, all of which have type set to `NULL`. This is done when the default cipher parameters are not appropriate.

`EVP_EncryptUpdate`() encrypts in_len bytes from the buffer in and writes the encrypted version to out. This function can be called multiple times to encrypt successive blocks of data. The amount of data written depends on the block alignment of the encrypted data: as a result the amount of data written may be anything from zero bytes to (in_len + cipher_block_size - 1) so out should contain sufficient room. The actual number of bytes written is placed in *out_len.

If padding is enabled (the default) then `EVP_EncryptFinal`() and `EVP_EncryptFinal_ex`(), which behave identically, encrypt the "final" data, that is any data that remains in a partial block. It uses NOTES (aka PKCS padding). The encrypted final data is written to out which should have sufficient space for one cipher block. The number of bytes written is placed in *out_len. After this function is called, the encryption operation is finished and no further calls to `EVP_EncryptUpdate`() should be made.

If padding is disabled then `EVP_EncryptFinal`() and `EVP_EncryptFinal_ex`() do not encrypt any more data and return an error if any data remains in a partial block: that is if the total data length is not a multiple of the block size.

`EVP_DecryptInit`(), `EVP_DecryptInit_ex`(), `EVP_DecryptUpdate`(), `EVP_DecryptFinal`(), and `EVP_DecryptFinal_ex`() are the corresponding decryption operations. `EVP_DecryptFinal`() and `EVP_DecryptFinal_ex`() return an error code if padding is enabled and the final block is not correctly formatted. The parameters and restrictions are identical to the encryption operations except that if padding is enabled the decrypted data buffer out passed to `EVP_DecryptUpdate`() should have sufficient room for (in_len + cipher_block_size) bytes unless the cipher block size is 1 in which case in_len bytes is sufficient.

`EVP_CipherInit`(), `EVP_CipherInit_ex`(), `EVP_CipherUpdate`(), `EVP_CipherFinal`(), and `EVP_CipherFinal_ex`() are functions that can be used for decryption or encryption. The operation performed depends on the value of the enc parameter. It should be set to 1 for encryption, 0 for decryption and -1 to leave the value unchanged (the actual value of enc being supplied in a previous call).

`EVP_get_cipherbyname`(), `EVP_get_cipherbynid`(), and `EVP_get_cipherbyobj`() return an EVP_CIPHER structure when passed a cipher name, a NID or an ASN1_OBJECT structure.

`EVP_CIPHER_CTX_cipher`() returns the EVP_CIPHER structure when passed an EVP_CIPHER_CTX structure.

Where possible the EVP interface to symmetric ciphers should be used in preference to the low level interfaces. This is because the code then becomes transparent to the cipher used and much more flexible.

PKCS padding works by adding n padding bytes of value n to make the total length of the encrypted data a multiple of the block size. Padding is always added so if the data is already a multiple of the block size n will equal the block size. For example if the block size is 8 and 11 bytes are to be encrypted then 5 padding bytes of value 5 will be added.

When decrypting, the final block is checked to see if it has the correct form.

Although the decryption operation can produce an error if padding is enabled, it is not a strong test that the input data or key is correct. A random block has better than 1 in 256 chance of being of the correct format and problems with the input data earlier on will not produce a final decrypt error.

If padding is disabled then the decryption operation will always succeed if the total amount of data decrypted is a multiple of the block size.

`EVP_get_cipherbynid`() and `EVP_get_cipherbyobj`() are implemented as macros.

# RETURN VALUES

`EVP_CIPHER_CTX_new`() returns a pointer to a newly created EVP_CIPHER_CTX for success or `NULL` for failure.

`EVP_CIPHER_CTX_reset`(), `EVP_CIPHER_CTX_copy`(), `EVP_EncryptInit_ex`(), `EVP_EncryptUpdate`(), `EVP_EncryptFinal_ex`(), `EVP_DecryptInit_ex`(), `EVP_DecryptUpdate`(), `EVP_DecryptFinal_ex`(), `EVP_CipherInit_ex`(), `EVP_CipherUpdate`(), `EVP_CipherFinal_ex`(), `EVP_EncryptInit`(), `EVP_EncryptFinal`(), `EVP_DecryptInit`(), `EVP_DecryptFinal`(), `EVP_CipherInit`(), and `EVP_CipherFinal`() return 1 for success or 0 for failure.

`EVP_CIPHER_CTX_encrypting`() returns 1 if ctx is initialized for encryption or 0 otherwise, in which case it may be uninitialized or initialized for decryption.

`EVP_get_cipherbyname`(), `EVP_get_cipherbynid`(), and `EVP_get_cipherbyobj`() return an EVP_CIPHER structure or `NULL` on error.

`EVP_CIPHER_CTX_cipher`() returns an EVP_CIPHER structure.

# CIPHER LISTING

`EVP_enc_null`()
  Null cipher: does nothing.
`EVP_idea_cbc`(), `EVP_idea_ecb`(), `EVP_idea_cfb64`(), `EVP_idea_ofb`()
  IDEA encryption algorithm in CBC, ECB, CFB and OFB modes respectively. IDEA is a block cipher operating on 64 bit blocks using a 128 bit key. `EVP_idea_cfb`() is an alias for `EVP_idea_cfb64`(), implemented as a macro.
`EVP_bf_cbc`(), `EVP_bf_ecb`(), `EVP_bf_cfb64`(), `EVP_bf_ofb`()
  Blowfish encryption algorithm in CBC, ECB, CFB and OFB modes respectively. Blowfish is a block cipher operating on 64 bit blocks using a variable key length. The default key length is 128 bits. `EVP_bf_cfb`() is an alias for `EVP_bf_cfb64`(), implemented as a macro.
`EVP_cast5_cbc`(), `EVP_cast5_ecb`(), `EVP_cast5_cfb64`(), `EVP_cast5_ofb`()
  CAST-128 encryption algorithm in CBC, ECB, CFB and OFB modes respectively. CAST-128 is a block cipher operating on 64 bit blocks using a variable key length. The default and maximum key length is 128 bits. `EVP_cast5_cfb`() is an alias for `EVP_cast5_cfb64`(), implemented as a macro.

Some algorithms are documented in separate manual pages:

manual page | block size | key size (in bits)
EVP_aes_128_cbc(3) | 128 | 128, 192, 256
EVP_aes_128_ccm(3) | 128 | 128, 192, 256
EVP_aes_128_gcm(3) | 128 | 128, 192, 256
EVP_camellia_128_cbc(3) | 128 | 128, 192, 256
EVP_chacha20(3) | stream | 256
EVP_des_cbc(3) | 64 | 64
EVP_rc2_cbc(3) | 64 | variable, default 128
EVP_rc4(3) | stream | variable, default 128
EVP_sm4_cbc(3) | 128 | 128

# EXAMPLES

Encrypt a string using blowfish:

    int
    do_crypt(char *out_filename)
    {
    	unsigned char out_buf[1024];
    	int out_len, tmp_len;
    	/*
    	 * 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};
    	const char in_text[] = "Some Crypto Text";
    	EVP_CIPHER_CTX *ctx;
    	FILE *out_fileptr;

    	ctx = EVP_CIPHER_CTX_new();
    	EVP_EncryptInit_ex(ctx, EVP_bf_cbc(), NULL, key, iv);

    	if (!EVP_EncryptUpdate(ctx, out_buf, &out_len, in_text,
    	    strlen(in_text))) {
    		/* 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, out_buf + out_len, &tmp_len)) {
    		/* Error */
    		EVP_CIPHER_CTX_free(ctx);
    		return 0;
    	}
    	out_len += tmp_len;
    	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_fileptr = fopen(out_filename, "wb");
    	if (out_fileptr == NULL) {
    		/* Error */
    		return 0;
    	}
    	fwrite(out_buf, 1, out_len, out_fileptr);
    	fclose(out_fileptr);
    	return 1;
    }

The ciphertext from the above example can be decrypted using the openssl(1) utility with the command line:

    openssl bf -in cipher.bin -K 000102030405060708090A0B0C0D0E0F \
               -iv 0102030405060708 -d

General encryption, decryption function example using FILE I/O and AES128 with a 128-bit key:

    int
    do_crypt(FILE *in_fileptr, FILE *out_fileptr, int do_encrypt)
    {
    	/* Allow enough space in output buffer for additional block */
    	unsigned char in_buf[1024], out_buf[1024 + EVP_MAX_BLOCK_LENGTH];
    	int in_len, out_len;
    	EVP_CIPHER_CTX *ctx;

    	/*
    	 * Bogus key and IV: we'd normally set these from
    	 * another source.
    	 */
    	unsigned char key[] = "0123456789abcdeF";
    	unsigned char iv[] = "1234567887654321";

    	ctx = EVP_CIPHER_CTX_new();
    	EVP_CipherInit_ex(ctx, EVP_aes_128_cbc(), NULL, NULL, NULL,
    	    do_encrypt);
    	EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, do_encrypt);

    	for (;;) {
    		in_len = fread(in_buf, 1, 1024, in_fileptr);
    		if (in_len <= 0)
    			break;
    		if (!EVP_CipherUpdate(ctx, out_buf, &out_len, in_buf,
    		    in_len)) {
    			/* Error */
    			EVP_CIPHER_CTX_free(ctx);
    			return 0;
    		}
    		fwrite(out_buf, 1, out_len, out_fileptr);
    	}
    	if (!EVP_CipherFinal_ex(ctx, out_buf, &out_len)) {
    		/* Error */
    		EVP_CIPHER_CTX_free(ctx);
    		return 0;
    	}
    	fwrite(out_buf, 1, out_len, out_fileptr);

    	EVP_CIPHER_CTX_free(ctx);
    	return 1;
    }

# SEE ALSO

BIO_f_cipher(3), evp(3), EVP_AEAD_CTX_init(3), EVP_aes_128_cbc(3), EVP_aes_128_ccm(3), EVP_aes_128_gcm(3), EVP_camellia_128_cbc(3), EVP_chacha20(3), EVP_CIPHER_CTX_ctrl(3), EVP_CIPHER_CTX_get_cipher_data(3), EVP_CIPHER_CTX_init(3), EVP_CIPHER_CTX_set_flags(3), EVP_CIPHER_nid(3), EVP_des_cbc(3), EVP_OpenInit(3), EVP_rc2_cbc(3), EVP_rc4(3), EVP_SealInit(3), EVP_sm4_cbc(3)

# HISTORY

`EVP_EncryptInit`(), `EVP_EncryptUpdate`(), `EVP_EncryptFinal`(), `EVP_DecryptInit`(), `EVP_DecryptUpdate`(), `EVP_DecryptFinal`(), `EVP_CipherInit`(), `EVP_CipherUpdate`(), `EVP_CipherFinal`(), `EVP_get_cipherbyname`(), `EVP_idea_cbc`(), `EVP_idea_ecb`(), `EVP_idea_cfb`(), and `EVP_idea_ofb`() first appeared in SSLeay 0.5.1. `EVP_bf_cbc`(), `EVP_bf_ecb`(), `EVP_bf_cfb`(), and `EVP_bf_ofb`() first appeared in SSLeay 0.6.6. `EVP_get_cipherbyobj`(), `EVP_CIPHER_CTX_cipher`(), and `EVP_enc_null`() first appeared in SSLeay 0.8.0. `EVP_get_cipherbynid`() first appeared in SSLeay 0.8.1. All these functions have been available since OpenBSD 2.4.

`EVP_EncryptInit_ex`(), `EVP_EncryptFinal_ex`(), `EVP_DecryptInit_ex`(), `EVP_DecryptFinal_ex`(), `EVP_CipherInit_ex`(), and `EVP_CipherFinal_ex`() first appeared in OpenSSL 0.9.7 and have been available since OpenBSD 3.2.

`EVP_bf_cfb64`(), `EVP_cast5_cfb64`(), and `EVP_idea_cfb64`() first appeared in OpenSSL 0.9.7e and have been available since OpenBSD 3.8.

`EVP_CIPHER_CTX_new`() and `EVP_CIPHER_CTX_free`() first appeared in OpenSSL 0.9.8b and have been available since OpenBSD 4.5.

`EVP_CIPHER_CTX_copy`() first appeared in OpenSSL 1.0.0 and has been available since OpenBSD 4.9.

`EVP_CIPHER_CTX_reset`() first appeared in OpenSSL 1.1.0 and has been available since OpenBSD 6.3.

`EVP_CIPHER_CTX_encrypting`() first appeared in OpenSSL 1.1.0 and has been available since OpenBSD 6.4.

# BUGS

`EVP_CIPHER_CTX_copy`() may already have cleared the data in out and copied some new data into it even if it fails and returns 0.

June 8, 2025 | Debian