cipher.h
mbedtls/config.h
stddef.h
mbedtls/platform_util.h
ccm.h
cmac.h
crypto_builtin_primitives.h
gcm.h
nist_kw.h
oid.h
pkcs12.h
ssl_ciphersuites.h
ssl_ticket.h
mbedtls/check_config.h
cipher.h
mbedtls/config.h
mbedtls/platform_time.h
mbedtls/platform_util.h
limits.h
stddef.h
time.h
ccm.h
cipher.h
cmac.h
debug.h
gcm.h
net.h
net_sockets.h
nist_kw.h
oid.h
pkcs12.h
ssl.h
ssl_cache.h
ssl_ciphersuites.h
ssl_cookie.h
ssl_ticket.h
crypto.h
crypto_builtin_composites.h
crypto_builtin_primitives.h
crypto_driver_contexts_composites.h
crypto_driver_contexts_primitives.h
crypto_struct.h
mbedtls_cipher_info_t
mbedtls_cipher_context_t
MBEDTLS_CIPHER_MODE_AEAD
MBEDTLS_CIPHER_MODE_WITH_PADDING
MBEDTLS_CIPHER_MODE_STREAM
MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE
-0x6080

The selected feature is not available.

MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA
-0x6100

Bad input parameters.

MBEDTLS_ERR_CIPHER_ALLOC_FAILED
-0x6180

Failed to allocate memory.

MBEDTLS_ERR_CIPHER_INVALID_PADDING
-0x6200

Input data contains invalid padding and is rejected.

MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED
-0x6280

Decryption of block requires a full block.

MBEDTLS_ERR_CIPHER_AUTH_FAILED
-0x6300

Authentication failed (for AEAD modes).

MBEDTLS_ERR_CIPHER_INVALID_CONTEXT
-0x6380

The context is invalid. For example, because it was freed.

MBEDTLS_ERR_CIPHER_HW_ACCEL_FAILED
-0x6400

Cipher hardware accelerator failed.

MBEDTLS_CIPHER_VARIABLE_IV_LEN
0x01

Cipher accepts IVs of variable length.

MBEDTLS_CIPHER_VARIABLE_KEY_LEN
0x02

Cipher accepts keys of variable length.

MBEDTLS_MAX_IV_LENGTH
16

Maximum length of any IV, in Bytes.

MBEDTLS_MAX_BLOCK_LENGTH
16

Maximum block size of any cipher, in Bytes.

MBEDTLS_MAX_KEY_LENGTH
64

Maximum key length, in Bytes.

MBEDTLS_DEPRECATED
__attribute__((deprecated))
mbedtls_cipher_id_t
MBEDTLS_CIPHER_ID_NONE
= 0

Placeholder to mark the end of cipher ID lists.

MBEDTLS_CIPHER_ID_NULL

The identity cipher, treated as a stream cipher.

MBEDTLS_CIPHER_ID_AES

The AES cipher.

MBEDTLS_CIPHER_ID_DES

The DES cipher.

DES is considered weak.

MBEDTLS_CIPHER_ID_3DES

The Triple DES cipher.

3DES is considered weak.

MBEDTLS_CIPHER_ID_CAMELLIA

The Camellia cipher.

MBEDTLS_CIPHER_ID_BLOWFISH

The Blowfish cipher.

MBEDTLS_CIPHER_ID_ARC4

The RC4 cipher.

MBEDTLS_CIPHER_ID_ARIA

The Aria cipher.

MBEDTLS_CIPHER_ID_CHACHA20

The ChaCha20 cipher.

Supported cipher types.

RC4 and DES/3DES are considered weak ciphers and their use constitutes a security risk. We recommend considering stronger ciphers instead.

mbedtls_cipher_type_t
MBEDTLS_CIPHER_NONE
= 0

Placeholder to mark the end of cipher-pair lists.

MBEDTLS_CIPHER_NULL

The identity stream cipher.

MBEDTLS_CIPHER_AES_128_ECB

AES cipher with 128-bit ECB mode.

MBEDTLS_CIPHER_AES_192_ECB

AES cipher with 192-bit ECB mode.

MBEDTLS_CIPHER_AES_256_ECB

AES cipher with 256-bit ECB mode.

MBEDTLS_CIPHER_AES_128_CBC

AES cipher with 128-bit CBC mode.

MBEDTLS_CIPHER_AES_192_CBC

AES cipher with 192-bit CBC mode.

MBEDTLS_CIPHER_AES_256_CBC

AES cipher with 256-bit CBC mode.

MBEDTLS_CIPHER_AES_128_CFB128

AES cipher with 128-bit CFB128 mode.

MBEDTLS_CIPHER_AES_192_CFB128

AES cipher with 192-bit CFB128 mode.

MBEDTLS_CIPHER_AES_256_CFB128

AES cipher with 256-bit CFB128 mode.

MBEDTLS_CIPHER_AES_128_CTR

AES cipher with 128-bit CTR mode.

MBEDTLS_CIPHER_AES_192_CTR

AES cipher with 192-bit CTR mode.

MBEDTLS_CIPHER_AES_256_CTR

AES cipher with 256-bit CTR mode.

MBEDTLS_CIPHER_AES_128_GCM

AES cipher with 128-bit GCM mode.

MBEDTLS_CIPHER_AES_192_GCM

AES cipher with 192-bit GCM mode.

MBEDTLS_CIPHER_AES_256_GCM

AES cipher with 256-bit GCM mode.

MBEDTLS_CIPHER_CAMELLIA_128_ECB

Camellia cipher with 128-bit ECB mode.

MBEDTLS_CIPHER_CAMELLIA_192_ECB

Camellia cipher with 192-bit ECB mode.

MBEDTLS_CIPHER_CAMELLIA_256_ECB

Camellia cipher with 256-bit ECB mode.

MBEDTLS_CIPHER_CAMELLIA_128_CBC

Camellia cipher with 128-bit CBC mode.

MBEDTLS_CIPHER_CAMELLIA_192_CBC

Camellia cipher with 192-bit CBC mode.

MBEDTLS_CIPHER_CAMELLIA_256_CBC

Camellia cipher with 256-bit CBC mode.

MBEDTLS_CIPHER_CAMELLIA_128_CFB128

Camellia cipher with 128-bit CFB128 mode.

MBEDTLS_CIPHER_CAMELLIA_192_CFB128

Camellia cipher with 192-bit CFB128 mode.

MBEDTLS_CIPHER_CAMELLIA_256_CFB128

Camellia cipher with 256-bit CFB128 mode.

MBEDTLS_CIPHER_CAMELLIA_128_CTR

Camellia cipher with 128-bit CTR mode.

MBEDTLS_CIPHER_CAMELLIA_192_CTR

Camellia cipher with 192-bit CTR mode.

MBEDTLS_CIPHER_CAMELLIA_256_CTR

Camellia cipher with 256-bit CTR mode.

MBEDTLS_CIPHER_CAMELLIA_128_GCM

Camellia cipher with 128-bit GCM mode.

MBEDTLS_CIPHER_CAMELLIA_192_GCM

Camellia cipher with 192-bit GCM mode.

MBEDTLS_CIPHER_CAMELLIA_256_GCM

Camellia cipher with 256-bit GCM mode.

MBEDTLS_CIPHER_DES_ECB

DES cipher with ECB mode.

DES is considered weak.

MBEDTLS_CIPHER_DES_CBC

DES cipher with CBC mode.

DES is considered weak.

MBEDTLS_CIPHER_DES_EDE_ECB

DES cipher with EDE ECB mode.

3DES is considered weak.

MBEDTLS_CIPHER_DES_EDE_CBC

DES cipher with EDE CBC mode.

3DES is considered weak.

MBEDTLS_CIPHER_DES_EDE3_ECB

DES cipher with EDE3 ECB mode.

3DES is considered weak.

MBEDTLS_CIPHER_DES_EDE3_CBC

DES cipher with EDE3 CBC mode.

3DES is considered weak.

MBEDTLS_CIPHER_BLOWFISH_ECB

Blowfish cipher with ECB mode.

MBEDTLS_CIPHER_BLOWFISH_CBC

Blowfish cipher with CBC mode.

MBEDTLS_CIPHER_BLOWFISH_CFB64

Blowfish cipher with CFB64 mode.

MBEDTLS_CIPHER_BLOWFISH_CTR

Blowfish cipher with CTR mode.

MBEDTLS_CIPHER_ARC4_128

RC4 cipher with 128-bit mode.

MBEDTLS_CIPHER_AES_128_CCM

AES cipher with 128-bit CCM mode.

MBEDTLS_CIPHER_AES_192_CCM

AES cipher with 192-bit CCM mode.

MBEDTLS_CIPHER_AES_256_CCM

AES cipher with 256-bit CCM mode.

MBEDTLS_CIPHER_CAMELLIA_128_CCM

Camellia cipher with 128-bit CCM mode.

MBEDTLS_CIPHER_CAMELLIA_192_CCM

Camellia cipher with 192-bit CCM mode.

MBEDTLS_CIPHER_CAMELLIA_256_CCM

Camellia cipher with 256-bit CCM mode.

MBEDTLS_CIPHER_ARIA_128_ECB

Aria cipher with 128-bit key and ECB mode.

MBEDTLS_CIPHER_ARIA_192_ECB

Aria cipher with 192-bit key and ECB mode.

MBEDTLS_CIPHER_ARIA_256_ECB

Aria cipher with 256-bit key and ECB mode.

MBEDTLS_CIPHER_ARIA_128_CBC

Aria cipher with 128-bit key and CBC mode.

MBEDTLS_CIPHER_ARIA_192_CBC

Aria cipher with 192-bit key and CBC mode.

MBEDTLS_CIPHER_ARIA_256_CBC

Aria cipher with 256-bit key and CBC mode.

MBEDTLS_CIPHER_ARIA_128_CFB128

Aria cipher with 128-bit key and CFB-128 mode.

MBEDTLS_CIPHER_ARIA_192_CFB128

Aria cipher with 192-bit key and CFB-128 mode.

MBEDTLS_CIPHER_ARIA_256_CFB128

Aria cipher with 256-bit key and CFB-128 mode.

MBEDTLS_CIPHER_ARIA_128_CTR

Aria cipher with 128-bit key and CTR mode.

MBEDTLS_CIPHER_ARIA_192_CTR

Aria cipher with 192-bit key and CTR mode.

MBEDTLS_CIPHER_ARIA_256_CTR

Aria cipher with 256-bit key and CTR mode.

MBEDTLS_CIPHER_ARIA_128_GCM

Aria cipher with 128-bit key and GCM mode.

MBEDTLS_CIPHER_ARIA_192_GCM

Aria cipher with 192-bit key and GCM mode.

MBEDTLS_CIPHER_ARIA_256_GCM

Aria cipher with 256-bit key and GCM mode.

MBEDTLS_CIPHER_ARIA_128_CCM

Aria cipher with 128-bit key and CCM mode.

MBEDTLS_CIPHER_ARIA_192_CCM

Aria cipher with 192-bit key and CCM mode.

MBEDTLS_CIPHER_ARIA_256_CCM

Aria cipher with 256-bit key and CCM mode.

MBEDTLS_CIPHER_AES_128_OFB

AES 128-bit cipher in OFB mode.

MBEDTLS_CIPHER_AES_192_OFB

AES 192-bit cipher in OFB mode.

MBEDTLS_CIPHER_AES_256_OFB

AES 256-bit cipher in OFB mode.

MBEDTLS_CIPHER_AES_128_XTS

AES 128-bit cipher in XTS block mode.

MBEDTLS_CIPHER_AES_256_XTS

AES 256-bit cipher in XTS block mode.

MBEDTLS_CIPHER_CHACHA20

ChaCha20 stream cipher.

MBEDTLS_CIPHER_CHACHA20_POLY1305

ChaCha20-Poly1305 AEAD cipher.

MBEDTLS_CIPHER_AES_128_KW

AES cipher with 128-bit NIST KW mode.

MBEDTLS_CIPHER_AES_192_KW

AES cipher with 192-bit NIST KW mode.

MBEDTLS_CIPHER_AES_256_KW

AES cipher with 256-bit NIST KW mode.

MBEDTLS_CIPHER_AES_128_KWP

AES cipher with 128-bit NIST KWP mode.

MBEDTLS_CIPHER_AES_192_KWP

AES cipher with 192-bit NIST KWP mode.

MBEDTLS_CIPHER_AES_256_KWP

AES cipher with 256-bit NIST KWP mode.

Supported {cipher type, cipher mode} pairs.

RC4 and DES/3DES are considered weak ciphers and their use constitutes a security risk. We recommend considering stronger ciphers instead.

mbedtls_cipher_mode_t
MBEDTLS_MODE_NONE
= 0

None.

MBEDTLS_MODE_ECB

The ECB cipher mode.

MBEDTLS_MODE_CBC

The CBC cipher mode.

MBEDTLS_MODE_CFB

The CFB cipher mode.

MBEDTLS_MODE_OFB

The OFB cipher mode.

MBEDTLS_MODE_CTR

The CTR cipher mode.

MBEDTLS_MODE_GCM

The GCM cipher mode.

MBEDTLS_MODE_STREAM

The stream cipher mode.

MBEDTLS_MODE_CCM

The CCM cipher mode.

MBEDTLS_MODE_XTS

The XTS cipher mode.

MBEDTLS_MODE_CHACHAPOLY

The ChaCha-Poly cipher mode.

MBEDTLS_MODE_KW

The SP800-38F KW mode

MBEDTLS_MODE_KWP

The SP800-38F KWP mode

Supported cipher modes.

mbedtls_cipher_padding_t
MBEDTLS_PADDING_PKCS7
= 0

PKCS7 padding (default).

MBEDTLS_PADDING_ONE_AND_ZEROS

ISO/IEC 7816-4 padding.

MBEDTLS_PADDING_ZEROS_AND_LEN

ANSI X.923 padding.

MBEDTLS_PADDING_ZEROS

Zero padding (not reversible).

MBEDTLS_PADDING_NONE

Never pad (full blocks only).

Supported cipher padding types.

mbedtls_operation_t
MBEDTLS_OPERATION_NONE
= -1
MBEDTLS_DECRYPT
= 0
MBEDTLS_ENCRYPT

Type of operation.

MBEDTLS_KEY_LENGTH_NONE
= 0

Undefined key length.

MBEDTLS_KEY_LENGTH_DES
= 64

Key length, in bits (including parity), for DES keys.

DES is considered weak.

MBEDTLS_KEY_LENGTH_DES_EDE
= 128

Key length in bits, including parity, for DES in two-key EDE.

3DES is considered weak.

MBEDTLS_KEY_LENGTH_DES_EDE3
= 192

Key length in bits, including parity, for DES in three-key EDE.

3DES is considered weak.

struct mbedtls_cipher_base_t typedef struct mbedtls_cipher_base_t mbedtls_cipher_base_t mbedtls_cipher_base_t

Base cipher information (opaque struct).

struct mbedtls_cmac_context_t typedef struct mbedtls_cmac_context_t mbedtls_cmac_context_t mbedtls_cmac_context_t

CMAC context (opaque struct).

struct mbedtls_cipher_info_t typedef struct mbedtls_cipher_info_t mbedtls_cipher_info_t mbedtls_cipher_info_t

Cipher information. Allows calling cipher functions in a generic way.

struct mbedtls_cipher_context_t typedef struct mbedtls_cipher_context_t mbedtls_cipher_context_t mbedtls_cipher_context_t

Generic cipher context.

const int * const int * mbedtls_cipher_list (void) mbedtls_cipher_list void

This function retrieves the list of ciphers supported by the generic cipher module.

For any cipher identifier in the returned list, you can obtain the corresponding generic cipher information structure via mbedtls_cipher_info_from_type(), which can then be used to prepare a cipher context via mbedtls_cipher_setup().

A statically-allocated array of cipher identifiers of type cipher_type_t. The last entry is zero.

const mbedtls_cipher_info_t * const mbedtls_cipher_info_t * mbedtls_cipher_info_from_string (const char *cipher_name) mbedtls_cipher_info_from_string const char * cipher_name

This function retrieves the cipher-information structure associated with the given cipher name.

cipher_name

Name of the cipher to search for. This must not be `NULL`.

The cipher information structure associated with the given `cipher_name`.

`NULL` if the associated cipher information is not found.

const mbedtls_cipher_info_t * const mbedtls_cipher_info_t * mbedtls_cipher_info_from_type (const mbedtls_cipher_type_t cipher_type) mbedtls_cipher_info_from_type const mbedtls_cipher_type_t cipher_type

This function retrieves the cipher-information structure associated with the given cipher type.

cipher_type

Type of the cipher to search for.

The cipher information structure associated with the given `cipher_type`.

`NULL` if the associated cipher information is not found.

const mbedtls_cipher_info_t * const mbedtls_cipher_info_t * mbedtls_cipher_info_from_values (const mbedtls_cipher_id_t cipher_id, int key_bitlen, const mbedtls_cipher_mode_t mode) mbedtls_cipher_info_from_values const mbedtls_cipher_id_t cipher_id int key_bitlen const mbedtls_cipher_mode_t mode

This function retrieves the cipher-information structure associated with the given cipher ID, key size and mode.

cipher_id

The ID of the cipher to search for. For example, MBEDTLS_CIPHER_ID_AES.

key_bitlen

The length of the key in bits.

mode

The cipher mode. For example, MBEDTLS_MODE_CBC.

The cipher information structure associated with the given `cipher_id`.

`NULL` if the associated cipher information is not found.

void void mbedtls_cipher_init (mbedtls_cipher_context_t *ctx) mbedtls_cipher_init mbedtls_cipher_context_t * ctx

This function initializes a `ctx` as NONE.

ctx

The context to be initialized. This must not be `NULL`.

void void mbedtls_cipher_free (mbedtls_cipher_context_t *ctx) mbedtls_cipher_free mbedtls_cipher_context_t * ctx

This function frees and clears the cipher-specific context of `ctx`. Freeing `ctx` itself remains the responsibility of the caller.

ctx

The context to be freed. If this is `NULL`, the function has no effect, otherwise this must point to an initialized context.

int int mbedtls_cipher_setup (mbedtls_cipher_context_t *ctx, const mbedtls_cipher_info_t *cipher_info) mbedtls_cipher_setup mbedtls_cipher_context_t * ctx const mbedtls_cipher_info_t * cipher_info

This function prepares a cipher context for use with the given cipher primitive.

In CBC mode, if mbedtls_cipher_set_padding_mode() is not called:

- If MBEDTLS_CIPHER_PADDING_PKCS7 is enabled, the context will use PKCS7 padding.

- Otherwise the context uses no padding and the input must be a whole number of blocks.

After calling this function, you should call mbedtls_cipher_setkey() and, if the mode uses padding, mbedtls_cipher_set_padding_mode(), then for each message to encrypt or decrypt with this key, either:

- mbedtls_cipher_crypt() for one-shot processing with non-AEAD modes;

- mbedtls_cipher_auth_encrypt_ext() or mbedtls_cipher_auth_decrypt_ext() for one-shot processing with AEAD modes or NIST_KW;

- for multi-part processing, see the documentation of mbedtls_cipher_reset().

ctx

The context to prepare. This must be initialized by a call to mbedtls_cipher_init() first.

cipher_info

The cipher to use.

`0` on success.

MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on parameter-verification failure.

MBEDTLS_ERR_CIPHER_ALLOC_FAILED if allocation of the cipher-specific context fails.

unsigned int static unsigned int mbedtls_cipher_get_block_size (const mbedtls_cipher_context_t *ctx) mbedtls_cipher_get_block_size const mbedtls_cipher_context_t * ctx

This function returns the block size of the given cipher.

ctx

The context of the cipher. This must be initialized.

The block size of the underlying cipher.

`0` if `ctx` has not been initialized.

mbedtls_cipher_info_t::block_size
mbedtls_cipher_context_t::cipher_info
MBEDTLS_INTERNAL_VALIDATE_RET
mbedtls_cipher_mode_t static mbedtls_cipher_mode_t mbedtls_cipher_get_cipher_mode (const mbedtls_cipher_context_t *ctx) mbedtls_cipher_get_cipher_mode const mbedtls_cipher_context_t * ctx

This function returns the mode of operation for the cipher. For example, MBEDTLS_MODE_CBC.

ctx

The context of the cipher. This must be initialized.

The mode of operation.

MBEDTLS_MODE_NONE if `ctx` has not been initialized.

mbedtls_cipher_context_t::cipher_info
MBEDTLS_INTERNAL_VALIDATE_RET
MBEDTLS_MODE_NONE
mbedtls_cipher_info_t::mode
int static int mbedtls_cipher_get_iv_size (const mbedtls_cipher_context_t *ctx) mbedtls_cipher_get_iv_size const mbedtls_cipher_context_t * ctx

This function returns the size of the IV or nonce of the cipher, in Bytes.

ctx

The context of the cipher. This must be initialized.

The recommended IV size if no IV has been set.

`0` for ciphers not using an IV or a nonce.

The actual size if an IV has been set.

mbedtls_cipher_context_t::cipher_info
mbedtls_cipher_info_t::iv_size
mbedtls_cipher_context_t::iv_size
MBEDTLS_INTERNAL_VALIDATE_RET
mbedtls_cipher_type_t static mbedtls_cipher_type_t mbedtls_cipher_get_type (const mbedtls_cipher_context_t *ctx) mbedtls_cipher_get_type const mbedtls_cipher_context_t * ctx

This function returns the type of the given cipher.

ctx

The context of the cipher. This must be initialized.

The type of the cipher.

MBEDTLS_CIPHER_NONE if `ctx` has not been initialized.

mbedtls_cipher_context_t::cipher_info
MBEDTLS_CIPHER_NONE
MBEDTLS_INTERNAL_VALIDATE_RET
mbedtls_cipher_info_t::type
const char * static const char * mbedtls_cipher_get_name (const mbedtls_cipher_context_t *ctx) mbedtls_cipher_get_name const mbedtls_cipher_context_t * ctx

This function returns the name of the given cipher as a string.

ctx

The context of the cipher. This must be initialized.

The name of the cipher.

NULL if `ctx` has not been not initialized.

mbedtls_cipher_context_t::cipher_info
MBEDTLS_INTERNAL_VALIDATE_RET
mbedtls_cipher_info_t::name
int static int mbedtls_cipher_get_key_bitlen (const mbedtls_cipher_context_t *ctx) mbedtls_cipher_get_key_bitlen const mbedtls_cipher_context_t * ctx

This function returns the key length of the cipher.

ctx

The context of the cipher. This must be initialized.

The key length of the cipher in bits.

MBEDTLS_KEY_LENGTH_NONE if `ctx` has not been initialized.

mbedtls_cipher_context_t::cipher_info
mbedtls_cipher_info_t::key_bitlen
MBEDTLS_INTERNAL_VALIDATE_RET
MBEDTLS_KEY_LENGTH_NONE
mbedtls_operation_t static mbedtls_operation_t mbedtls_cipher_get_operation (const mbedtls_cipher_context_t *ctx) mbedtls_cipher_get_operation const mbedtls_cipher_context_t * ctx

This function returns the operation of the given cipher.

ctx

The context of the cipher. This must be initialized.

The type of operation: MBEDTLS_ENCRYPT or MBEDTLS_DECRYPT.

MBEDTLS_OPERATION_NONE if `ctx` has not been initialized.

mbedtls_cipher_context_t::cipher_info
MBEDTLS_INTERNAL_VALIDATE_RET
MBEDTLS_OPERATION_NONE
mbedtls_cipher_context_t::operation
int int mbedtls_cipher_setkey (mbedtls_cipher_context_t *ctx, const unsigned char *key, int key_bitlen, const mbedtls_operation_t operation) mbedtls_cipher_setkey mbedtls_cipher_context_t * ctx const unsigned char * key int key_bitlen const mbedtls_operation_t operation

This function sets the key to use with the given context.

ctx

The generic cipher context. This must be initialized and bound to a cipher information structure.

key

The key to use. This must be a readable buffer of at least `key_bitlen` Bits.

key_bitlen

The key length to use, in Bits.

operation

The operation that the key will be used for: MBEDTLS_ENCRYPT or MBEDTLS_DECRYPT.

`0` on success.

MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on parameter-verification failure.

A cipher-specific error code on failure.

int int mbedtls_cipher_set_padding_mode (mbedtls_cipher_context_t *ctx, mbedtls_cipher_padding_t mode) mbedtls_cipher_set_padding_mode mbedtls_cipher_context_t * ctx mbedtls_cipher_padding_t mode

This function sets the padding mode, for cipher modes that use padding.

ctx

The generic cipher context. This must be initialized and bound to a cipher information structure.

mode

The padding mode.

`0` on success.

MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE if the selected padding mode is not supported.

MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA if the cipher mode does not support padding.

int int mbedtls_cipher_set_iv (mbedtls_cipher_context_t *ctx, const unsigned char *iv, size_t iv_len) mbedtls_cipher_set_iv mbedtls_cipher_context_t * ctx const unsigned char * iv size_t iv_len

This function sets the initialization vector (IV) or nonce.

Some ciphers do not use IVs nor nonce. For these ciphers, this function has no effect.

ctx

The generic cipher context. This must be initialized and bound to a cipher information structure.

iv

The IV to use, or NONCE_COUNTER for CTR-mode ciphers. This must be a readable buffer of at least `iv_len` Bytes.

iv_len

The IV length for ciphers with variable-size IV. This parameter is discarded by ciphers with fixed-size IV.

`0` on success.

MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on parameter-verification failure.

int int mbedtls_cipher_reset (mbedtls_cipher_context_t *ctx) mbedtls_cipher_reset mbedtls_cipher_context_t * ctx

This function resets the cipher state.

With non-AEAD ciphers, the order of calls for each message is as follows:

1. mbedtls_cipher_set_iv() if the mode uses an IV/nonce.

2. mbedtls_cipher_reset()

3. mbedtls_cipher_update() one or more times

4. mbedtls_cipher_finish()

This sequence can be repeated to encrypt or decrypt multiple messages with the same key.

With AEAD ciphers, the order of calls for each message is as follows:

1. mbedtls_cipher_set_iv() if the mode uses an IV/nonce.

2. mbedtls_cipher_reset()

3. mbedtls_cipher_update_ad()

4. mbedtls_cipher_update() one or more times

5. mbedtls_cipher_check_tag() (for decryption) or mbedtls_cipher_write_tag() (for encryption).

This sequence can be repeated to encrypt or decrypt multiple messages with the same key.
ctx

The generic cipher context. This must be bound to a key.

`0` on success.

MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on parameter-verification failure.

int int mbedtls_cipher_update_ad (mbedtls_cipher_context_t *ctx, const unsigned char *ad, size_t ad_len) mbedtls_cipher_update_ad mbedtls_cipher_context_t * ctx const unsigned char * ad size_t ad_len

This function adds additional data for AEAD ciphers. Currently supported with GCM and ChaCha20+Poly1305. This must be called exactly once, after mbedtls_cipher_reset().

ctx

The generic cipher context. This must be initialized.

ad

The additional data to use. This must be a readable buffer of at least `ad_len` Bytes.

ad_len

The length of `ad` in Bytes.

`0` on success.

A specific error code on failure.

int int mbedtls_cipher_update (mbedtls_cipher_context_t *ctx, const unsigned char *input, size_t ilen, unsigned char *output, size_t *olen) mbedtls_cipher_update mbedtls_cipher_context_t * ctx const unsigned char * input size_t ilen unsigned char * output size_t * olen

The generic cipher update function. It encrypts or decrypts using the given cipher context. Writes as many block-sized blocks of data as possible to output. Any data that cannot be written immediately is either added to the next block, or flushed when mbedtls_cipher_finish() is called. Exception: For MBEDTLS_MODE_ECB, expects a single block in size. For example, 16 Bytes for AES.

If the underlying cipher is used in GCM mode, all calls to this function, except for the last one before mbedtls_cipher_finish(), must have `ilen` as a multiple of the block size of the cipher.

ctx

The generic cipher context. This must be initialized and bound to a key.

input

The buffer holding the input data. This must be a readable buffer of at least `ilen` Bytes.

ilen

The length of the input data.

output

The buffer for the output data. This must be able to hold at least `ilen + block_size`. This must not be the same buffer as `input`.

olen

The length of the output data, to be updated with the actual number of Bytes written. This must not be `NULL`.

`0` on success.

MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on parameter-verification failure.

MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE on an unsupported mode for a cipher.

A cipher-specific error code on failure.

int int mbedtls_cipher_finish (mbedtls_cipher_context_t *ctx, unsigned char *output, size_t *olen) mbedtls_cipher_finish mbedtls_cipher_context_t * ctx unsigned char * output size_t * olen

The generic cipher finalization function. If data still needs to be flushed from an incomplete block, the data contained in it is padded to the size of the last block, and written to the `output` buffer.

ctx

The generic cipher context. This must be initialized and bound to a key.

output

The buffer to write data to. This needs to be a writable buffer of at least block_size Bytes.

olen

The length of the data written to the `output` buffer. This may not be `NULL`.

`0` on success.

MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on parameter-verification failure.

MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED on decryption expecting a full block but not receiving one.

MBEDTLS_ERR_CIPHER_INVALID_PADDING on invalid padding while decrypting.

A cipher-specific error code on failure.

int int mbedtls_cipher_write_tag (mbedtls_cipher_context_t *ctx, unsigned char *tag, size_t tag_len) mbedtls_cipher_write_tag mbedtls_cipher_context_t * ctx unsigned char * tag size_t tag_len

This function writes a tag for AEAD ciphers. Currently supported with GCM and ChaCha20+Poly1305. This must be called after mbedtls_cipher_finish().

ctx

The generic cipher context. This must be initialized, bound to a key, and have just completed a cipher operation through mbedtls_cipher_finish() the tag for which should be written.

tag

The buffer to write the tag to. This must be a writable buffer of at least `tag_len` Bytes.

tag_len

The length of the tag to write.

`0` on success.

A specific error code on failure.

int int mbedtls_cipher_check_tag (mbedtls_cipher_context_t *ctx, const unsigned char *tag, size_t tag_len) mbedtls_cipher_check_tag mbedtls_cipher_context_t * ctx const unsigned char * tag size_t tag_len

This function checks the tag for AEAD ciphers. Currently supported with GCM and ChaCha20+Poly1305. This must be called after mbedtls_cipher_finish().

ctx

The generic cipher context. This must be initialized.

tag

The buffer holding the tag. This must be a readable buffer of at least `tag_len` Bytes.

tag_len

The length of the tag to check.

`0` on success.

A specific error code on failure.

int int mbedtls_cipher_crypt (mbedtls_cipher_context_t *ctx, const unsigned char *iv, size_t iv_len, const unsigned char *input, size_t ilen, unsigned char *output, size_t *olen) mbedtls_cipher_crypt mbedtls_cipher_context_t * ctx const unsigned char * iv size_t iv_len const unsigned char * input size_t ilen unsigned char * output size_t * olen

The generic all-in-one encryption/decryption function, for all ciphers except AEAD constructs.

ctx

The generic cipher context. This must be initialized.

iv

The IV to use, or NONCE_COUNTER for CTR-mode ciphers. This must be a readable buffer of at least `iv_len` Bytes.

iv_len

The IV length for ciphers with variable-size IV. This parameter is discarded by ciphers with fixed-size IV.

input

The buffer holding the input data. This must be a readable buffer of at least `ilen` Bytes.

ilen

The length of the input data in Bytes.

output

The buffer for the output data. This must be able to hold at least `ilen + block_size`. This must not be the same buffer as `input`.

olen

The length of the output data, to be updated with the actual number of Bytes written. This must not be `NULL`.

Some ciphers do not use IVs nor nonce. For these ciphers, use `iv` = NULL and `iv_len` = 0.

`0` on success.

MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on parameter-verification failure.

MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED on decryption expecting a full block but not receiving one.

MBEDTLS_ERR_CIPHER_INVALID_PADDING on invalid padding while decrypting.

A cipher-specific error code on failure.

int MBEDTLS_DEPRECATED int MBEDTLS_DEPRECATED mbedtls_cipher_auth_encrypt (mbedtls_cipher_context_t *ctx, const unsigned char *iv, size_t iv_len, const unsigned char *ad, size_t ad_len, const unsigned char *input, size_t ilen, unsigned char *output, size_t *olen, unsigned char *tag, size_t tag_len) mbedtls_cipher_auth_encrypt mbedtls_cipher_context_t * ctx const unsigned char * iv size_t iv_len const unsigned char * ad size_t ad_len const unsigned char * input size_t ilen unsigned char * output size_t * olen unsigned char * tag size_t tag_len

The generic authenticated encryption (AEAD) function.

Deprecated

Superseded by mbedtls_cipher_auth_encrypt_ext().

This function only supports AEAD algorithms, not key wrapping algorithms such as NIST_KW; for this, see mbedtls_cipher_auth_encrypt_ext().

ctx

The generic cipher context. This must be initialized and bound to a key associated with an AEAD algorithm.

iv

The nonce to use. This must be a readable buffer of at least `iv_len` Bytes and must not be `NULL`.

iv_len

The length of the nonce. This must satisfy the constraints imposed by the AEAD cipher used.

ad

The additional data to authenticate. This must be a readable buffer of at least `ad_len` Bytes, and may be `NULL` is `ad_len` is `0`.

ad_len

The length of `ad`.

input

The buffer holding the input data. This must be a readable buffer of at least `ilen` Bytes, and may be `NULL` if `ilen` is `0`.

ilen

The length of the input data.

output

The buffer for the output data. This must be a writable buffer of at least `ilen` Bytes, and must not be `NULL`.

olen

This will be filled with the actual number of Bytes written to the `output` buffer. This must point to a writable object of type `size_t`.

tag

The buffer for the authentication tag. This must be a writable buffer of at least `tag_len` Bytes. See note below regarding restrictions with PSA-based contexts.

tag_len

The desired length of the authentication tag. This must match the constraints imposed by the AEAD cipher used, and in particular must not be `0`.

If the context is based on PSA (that is, it was set up with mbedtls_cipher_setup_psa()), then it is required that `tag` == output + ilen. That is, the tag must be appended to the ciphertext as recommended by RFC 5116.

`0` on success.

MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on parameter-verification failure.

A cipher-specific error code on failure.

int MBEDTLS_DEPRECATED int MBEDTLS_DEPRECATED mbedtls_cipher_auth_decrypt (mbedtls_cipher_context_t *ctx, const unsigned char *iv, size_t iv_len, const unsigned char *ad, size_t ad_len, const unsigned char *input, size_t ilen, unsigned char *output, size_t *olen, const unsigned char *tag, size_t tag_len) mbedtls_cipher_auth_decrypt mbedtls_cipher_context_t * ctx const unsigned char * iv size_t iv_len const unsigned char * ad size_t ad_len const unsigned char * input size_t ilen unsigned char * output size_t * olen const unsigned char * tag size_t tag_len

The generic authenticated decryption (AEAD) function.

Deprecated

Superseded by mbedtls_cipher_auth_decrypt_ext().

This function only supports AEAD algorithms, not key wrapping algorithms such as NIST_KW; for this, see mbedtls_cipher_auth_decrypt_ext().

If the data is not authentic, then the output buffer is zeroed out to prevent the unauthentic plaintext being used, making this interface safer.

ctx

The generic cipher context. This must be initialized and bound to a key associated with an AEAD algorithm.

iv

The nonce to use. This must be a readable buffer of at least `iv_len` Bytes and must not be `NULL`.

iv_len

The length of the nonce. This must satisfy the constraints imposed by the AEAD cipher used.

ad

The additional data to authenticate. This must be a readable buffer of at least `ad_len` Bytes, and may be `NULL` is `ad_len` is `0`.

ad_len

The length of `ad`.

input

The buffer holding the input data. This must be a readable buffer of at least `ilen` Bytes, and may be `NULL` if `ilen` is `0`.

ilen

The length of the input data.

output

The buffer for the output data. This must be a writable buffer of at least `ilen` Bytes, and must not be `NULL`.

olen

This will be filled with the actual number of Bytes written to the `output` buffer. This must point to a writable object of type `size_t`.

tag

The buffer for the authentication tag. This must be a readable buffer of at least `tag_len` Bytes. See note below regarding restrictions with PSA-based contexts.

tag_len

The length of the authentication tag. This must match the constraints imposed by the AEAD cipher used, and in particular must not be `0`.

If the context is based on PSA (that is, it was set up with mbedtls_cipher_setup_psa()), then it is required that `tag` == input + len. That is, the tag must be appended to the ciphertext as recommended by RFC 5116.

`0` on success.

MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on parameter-verification failure.

MBEDTLS_ERR_CIPHER_AUTH_FAILED if data is not authentic.

A cipher-specific error code on failure.

int int mbedtls_cipher_auth_encrypt_ext (mbedtls_cipher_context_t *ctx, const unsigned char *iv, size_t iv_len, const unsigned char *ad, size_t ad_len, const unsigned char *input, size_t ilen, unsigned char *output, size_t output_len, size_t *olen, size_t tag_len) mbedtls_cipher_auth_encrypt_ext mbedtls_cipher_context_t * ctx const unsigned char * iv size_t iv_len const unsigned char * ad size_t ad_len const unsigned char * input size_t ilen unsigned char * output size_t output_len size_t * olen size_t tag_len

The authenticated encryption (AEAD/NIST_KW) function.

For AEAD modes, the tag will be appended to the ciphertext, as recommended by RFC 5116. (NIST_KW doesn't have a separate tag.)

ctx

The generic cipher context. This must be initialized and bound to a key, with an AEAD algorithm or NIST_KW.

iv

The nonce to use. This must be a readable buffer of at least `iv_len` Bytes and may be `NULL` if `iv_len` is `0`.

iv_len

The length of the nonce. For AEAD ciphers, this must satisfy the constraints imposed by the cipher used. For NIST_KW, this must be `0`.

ad

The additional data to authenticate. This must be a readable buffer of at least `ad_len` Bytes, and may be `NULL` is `ad_len` is `0`.

ad_len

The length of `ad`. For NIST_KW, this must be `0`.

input

The buffer holding the input data. This must be a readable buffer of at least `ilen` Bytes, and may be `NULL` if `ilen` is `0`.

ilen

The length of the input data.

output

The buffer for the output data. This must be a writable buffer of at least `output_len` Bytes, and must not be `NULL`.

output_len

The length of the `output` buffer in Bytes. For AEAD ciphers, this must be at least `ilen` + `tag_len`. For NIST_KW, this must be at least `ilen` + 8 (rounded up to a multiple of 8 if KWP is used); `ilen` + 15 is always a safe value.

olen

This will be filled with the actual number of Bytes written to the `output` buffer. This must point to a writable object of type `size_t`.

tag_len

The desired length of the authentication tag. For AEAD ciphers, this must match the constraints imposed by the cipher used, and in particular must not be `0`. For NIST_KW, this must be `0`.

`0` on success.

MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on parameter-verification failure.

A cipher-specific error code on failure.

int int mbedtls_cipher_auth_decrypt_ext (mbedtls_cipher_context_t *ctx, const unsigned char *iv, size_t iv_len, const unsigned char *ad, size_t ad_len, const unsigned char *input, size_t ilen, unsigned char *output, size_t output_len, size_t *olen, size_t tag_len) mbedtls_cipher_auth_decrypt_ext mbedtls_cipher_context_t * ctx const unsigned char * iv size_t iv_len const unsigned char * ad size_t ad_len const unsigned char * input size_t ilen unsigned char * output size_t output_len size_t * olen size_t tag_len

The authenticated encryption (AEAD/NIST_KW) function.

If the data is not authentic, then the output buffer is zeroed out to prevent the unauthentic plaintext being used, making this interface safer.

For AEAD modes, the tag must be appended to the ciphertext, as recommended by RFC 5116. (NIST_KW doesn't have a separate tag.)

ctx

The generic cipher context. This must be initialized and bound to a key, with an AEAD algorithm or NIST_KW.

iv

The nonce to use. This must be a readable buffer of at least `iv_len` Bytes and may be `NULL` if `iv_len` is `0`.

iv_len

The length of the nonce. For AEAD ciphers, this must satisfy the constraints imposed by the cipher used. For NIST_KW, this must be `0`.

ad

The additional data to authenticate. This must be a readable buffer of at least `ad_len` Bytes, and may be `NULL` is `ad_len` is `0`.

ad_len

The length of `ad`. For NIST_KW, this must be `0`.

input

The buffer holding the input data. This must be a readable buffer of at least `ilen` Bytes, and may be `NULL` if `ilen` is `0`.

ilen

The length of the input data. For AEAD ciphers this must be at least `tag_len`. For NIST_KW this must be at least `8`.

output

The buffer for the output data. This must be a writable buffer of at least `output_len` Bytes, and may be `NULL` if `output_len` is `0`.

output_len

The length of the `output` buffer in Bytes. For AEAD ciphers, this must be at least `ilen` - `tag_len`. For NIST_KW, this must be at least `ilen` - 8.

olen

This will be filled with the actual number of Bytes written to the `output` buffer. This must point to a writable object of type `size_t`.

tag_len

The actual length of the authentication tag. For AEAD ciphers, this must match the constraints imposed by the cipher used, and in particular must not be `0`. For NIST_KW, this must be `0`.

`0` on success.

MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on parameter-verification failure.

MBEDTLS_ERR_CIPHER_AUTH_FAILED if data is not authentic.

A cipher-specific error code on failure.

This file contains an abstraction interface for use with the cipher primitives provided by the library. It provides a common interface to all of the available cipher operations.

Adriaan de Jong dejong@fox-it.com

    /*
    *CopyrightTheMbedTLSContributors
    *SPDX-License-Identifier:Apache-2.0ORGPL-2.0-or-later
    */

    #ifndefMBEDTLS_CIPHER_H
    #defineMBEDTLS_CIPHER_H

    #if!defined(MBEDTLS_CONFIG_FILE)
    #include"mbedtls/config.h"
    #else
    #includeMBEDTLS_CONFIG_FILE
    #endif

    #include<stddef.h>
    #include"mbedtls/platform_util.h"

    #ifdefined(MBEDTLS_GCM_C)||defined(MBEDTLS_CCM_C)||defined(MBEDTLS_CHACHAPOLY_C)
    #defineMBEDTLS_CIPHER_MODE_AEAD
    #endif

    #ifdefined(MBEDTLS_CIPHER_MODE_CBC)
    #defineMBEDTLS_CIPHER_MODE_WITH_PADDING
    #endif

    #ifdefined(MBEDTLS_ARC4_C)||defined(MBEDTLS_CIPHER_NULL_CIPHER)||\
    defined(MBEDTLS_CHACHA20_C)
    #defineMBEDTLS_CIPHER_MODE_STREAM
    #endif

    #if(defined(__ARMCC_VERSION)||defined(_MSC_VER))&&\
    !defined(inline)&&!defined(__cplusplus)
    #defineinline__inline
    #endif

    #defineMBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE-0x6080
    #defineMBEDTLS_ERR_CIPHER_BAD_INPUT_DATA-0x6100
    #defineMBEDTLS_ERR_CIPHER_ALLOC_FAILED-0x6180
    #defineMBEDTLS_ERR_CIPHER_INVALID_PADDING-0x6200
    #defineMBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED-0x6280
    #defineMBEDTLS_ERR_CIPHER_AUTH_FAILED-0x6300
    #defineMBEDTLS_ERR_CIPHER_INVALID_CONTEXT-0x6380

    /*MBEDTLS_ERR_CIPHER_HW_ACCEL_FAILEDisdeprecatedandshouldnotbeused.*/
    #defineMBEDTLS_ERR_CIPHER_HW_ACCEL_FAILED-0x6400

    #defineMBEDTLS_CIPHER_VARIABLE_IV_LEN0x01
    #defineMBEDTLS_CIPHER_VARIABLE_KEY_LEN0x02
    #ifdef__cplusplus
    extern"C"{
    #endif

    typedefenum{
    MBEDTLS_CIPHER_ID_NONE=0,
    MBEDTLS_CIPHER_ID_NULL,
    MBEDTLS_CIPHER_ID_AES,
    MBEDTLS_CIPHER_ID_DES,
    MBEDTLS_CIPHER_ID_3DES,
    MBEDTLS_CIPHER_ID_CAMELLIA,
    MBEDTLS_CIPHER_ID_BLOWFISH,
    MBEDTLS_CIPHER_ID_ARC4,
    MBEDTLS_CIPHER_ID_ARIA,
    MBEDTLS_CIPHER_ID_CHACHA20,
    }mbedtls_cipher_id_t;

    typedefenum{
    MBEDTLS_CIPHER_NONE=0,
    MBEDTLS_CIPHER_NULL,
    MBEDTLS_CIPHER_AES_128_ECB,
    MBEDTLS_CIPHER_AES_192_ECB,
    MBEDTLS_CIPHER_AES_256_ECB,
    MBEDTLS_CIPHER_AES_128_CBC,
    MBEDTLS_CIPHER_AES_192_CBC,
    MBEDTLS_CIPHER_AES_256_CBC,
    MBEDTLS_CIPHER_AES_128_CFB128,
    MBEDTLS_CIPHER_AES_192_CFB128,
    MBEDTLS_CIPHER_AES_256_CFB128,
    MBEDTLS_CIPHER_AES_128_CTR,
    MBEDTLS_CIPHER_AES_192_CTR,
    MBEDTLS_CIPHER_AES_256_CTR,
    MBEDTLS_CIPHER_AES_128_GCM,
    MBEDTLS_CIPHER_AES_192_GCM,
    MBEDTLS_CIPHER_AES_256_GCM,
    MBEDTLS_CIPHER_CAMELLIA_128_ECB,
    MBEDTLS_CIPHER_CAMELLIA_192_ECB,
    MBEDTLS_CIPHER_CAMELLIA_256_ECB,
    MBEDTLS_CIPHER_CAMELLIA_128_CBC,
    MBEDTLS_CIPHER_CAMELLIA_192_CBC,
    MBEDTLS_CIPHER_CAMELLIA_256_CBC,
    MBEDTLS_CIPHER_CAMELLIA_128_CFB128,
    MBEDTLS_CIPHER_CAMELLIA_192_CFB128,
    MBEDTLS_CIPHER_CAMELLIA_256_CFB128,
    MBEDTLS_CIPHER_CAMELLIA_128_CTR,
    MBEDTLS_CIPHER_CAMELLIA_192_CTR,
    MBEDTLS_CIPHER_CAMELLIA_256_CTR,
    MBEDTLS_CIPHER_CAMELLIA_128_GCM,
    MBEDTLS_CIPHER_CAMELLIA_192_GCM,
    MBEDTLS_CIPHER_CAMELLIA_256_GCM,
    MBEDTLS_CIPHER_DES_ECB,
    MBEDTLS_CIPHER_DES_CBC,
    MBEDTLS_CIPHER_DES_EDE_ECB,
    MBEDTLS_CIPHER_DES_EDE_CBC,
    MBEDTLS_CIPHER_DES_EDE3_ECB,
    MBEDTLS_CIPHER_DES_EDE3_CBC,
    MBEDTLS_CIPHER_BLOWFISH_ECB,
    MBEDTLS_CIPHER_BLOWFISH_CBC,
    MBEDTLS_CIPHER_BLOWFISH_CFB64,
    MBEDTLS_CIPHER_BLOWFISH_CTR,
    MBEDTLS_CIPHER_ARC4_128,
    MBEDTLS_CIPHER_AES_128_CCM,
    MBEDTLS_CIPHER_AES_192_CCM,
    MBEDTLS_CIPHER_AES_256_CCM,
    MBEDTLS_CIPHER_CAMELLIA_128_CCM,
    MBEDTLS_CIPHER_CAMELLIA_192_CCM,
    MBEDTLS_CIPHER_CAMELLIA_256_CCM,
    MBEDTLS_CIPHER_ARIA_128_ECB,
    MBEDTLS_CIPHER_ARIA_192_ECB,
    MBEDTLS_CIPHER_ARIA_256_ECB,
    MBEDTLS_CIPHER_ARIA_128_CBC,
    MBEDTLS_CIPHER_ARIA_192_CBC,
    MBEDTLS_CIPHER_ARIA_256_CBC,
    MBEDTLS_CIPHER_ARIA_128_CFB128,
    MBEDTLS_CIPHER_ARIA_192_CFB128,
    MBEDTLS_CIPHER_ARIA_256_CFB128,
    MBEDTLS_CIPHER_ARIA_128_CTR,
    MBEDTLS_CIPHER_ARIA_192_CTR,
    MBEDTLS_CIPHER_ARIA_256_CTR,
    MBEDTLS_CIPHER_ARIA_128_GCM,
    MBEDTLS_CIPHER_ARIA_192_GCM,
    MBEDTLS_CIPHER_ARIA_256_GCM,
    MBEDTLS_CIPHER_ARIA_128_CCM,
    MBEDTLS_CIPHER_ARIA_192_CCM,
    MBEDTLS_CIPHER_ARIA_256_CCM,
    MBEDTLS_CIPHER_AES_128_OFB,
    MBEDTLS_CIPHER_AES_192_OFB,
    MBEDTLS_CIPHER_AES_256_OFB,
    MBEDTLS_CIPHER_AES_128_XTS,
    MBEDTLS_CIPHER_AES_256_XTS,
    MBEDTLS_CIPHER_CHACHA20,
    MBEDTLS_CIPHER_CHACHA20_POLY1305,
    MBEDTLS_CIPHER_AES_128_KW,
    MBEDTLS_CIPHER_AES_192_KW,
    MBEDTLS_CIPHER_AES_256_KW,
    MBEDTLS_CIPHER_AES_128_KWP,
    MBEDTLS_CIPHER_AES_192_KWP,
    MBEDTLS_CIPHER_AES_256_KWP,
    }mbedtls_cipher_type_t;

    typedefenum{
    MBEDTLS_MODE_NONE=0,
    MBEDTLS_MODE_ECB,
    MBEDTLS_MODE_CBC,
    MBEDTLS_MODE_CFB,
    MBEDTLS_MODE_OFB,
    MBEDTLS_MODE_CTR,
    MBEDTLS_MODE_GCM,
    MBEDTLS_MODE_STREAM,
    MBEDTLS_MODE_CCM,
    MBEDTLS_MODE_XTS,
    MBEDTLS_MODE_CHACHAPOLY,
    MBEDTLS_MODE_KW,
    MBEDTLS_MODE_KWP,
    }mbedtls_cipher_mode_t;

    typedefenum{
    MBEDTLS_PADDING_PKCS7=0,
    MBEDTLS_PADDING_ONE_AND_ZEROS,
    MBEDTLS_PADDING_ZEROS_AND_LEN,
    MBEDTLS_PADDING_ZEROS,
    MBEDTLS_PADDING_NONE,
    }mbedtls_cipher_padding_t;

    typedefenum{
    MBEDTLS_OPERATION_NONE=-1,
    MBEDTLS_DECRYPT=0,
    MBEDTLS_ENCRYPT,
    }mbedtls_operation_t;

    enum{
    MBEDTLS_KEY_LENGTH_NONE=0,
    MBEDTLS_KEY_LENGTH_DES=64,
    MBEDTLS_KEY_LENGTH_DES_EDE=128,
    MBEDTLS_KEY_LENGTH_DES_EDE3=192,
    };

    /*Thisshouldideallybederivedautomaticallyfromlistofciphers.
    *ThisshouldbekeptinsyncwithMBEDTLS_SSL_MAX_IV_LENGTHdefined
    *inssl_internal.h.*/
    #defineMBEDTLS_MAX_IV_LENGTH16

    /*Thisshouldideallybederivedautomaticallyfromlistofciphers.
    *ThisshouldbekeptinsyncwithMBEDTLS_SSL_MAX_BLOCK_LENGTHdefined
    *inssl_internal.h.*/
    #defineMBEDTLS_MAX_BLOCK_LENGTH16

    /*Thisshouldideallybederivedautomaticallyfromlistofciphers.
    *Fornow,onlycheckwhetherXTSisenabledwhichuses64Bytekeys,
    *anduse32Bytesasanupperboundforthemaximumkeylengthotherwise.
    *ThisshouldbekeptinsyncwithMBEDTLS_SSL_MAX_BLOCK_LENGTHdefined
    *inssl_internal.h,whichhoweverdeliberatelyignoresthecaseofXTS
    *sincethelatterisn'tusedinSSL/TLS.*/
    #ifdefined(MBEDTLS_CIPHER_MODE_XTS)
    #defineMBEDTLS_MAX_KEY_LENGTH64
    #else
    #defineMBEDTLS_MAX_KEY_LENGTH32
    #endif/*MBEDTLS_CIPHER_MODE_XTS*/

    typedefstructmbedtls_cipher_base_tmbedtls_cipher_base_t;

    typedefstructmbedtls_cmac_context_tmbedtls_cmac_context_t;

    typedefstructmbedtls_cipher_info_t{
    mbedtls_cipher_type_ttype;

    mbedtls_cipher_mode_tmode;

    unsignedintkey_bitlen;

    constchar*name;

    unsignedintiv_size;

    intflags;

    unsignedintblock_size;

    constmbedtls_cipher_base_t*base;

    }mbedtls_cipher_info_t;

    typedefstructmbedtls_cipher_context_t{
    constmbedtls_cipher_info_t*cipher_info;

    intkey_bitlen;

    mbedtls_operation_toperation;

    #ifdefined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
    void(*add_padding)(unsignedchar*output,size_tolen,size_tdata_len);
    int(*get_padding)(unsignedchar*input,size_tilen,size_t*data_len);
    #endif

    unsignedcharunprocessed_data[MBEDTLS_MAX_BLOCK_LENGTH];

    size_tunprocessed_len;

    unsignedchariv[MBEDTLS_MAX_IV_LENGTH];

    size_tiv_size;

    void*cipher_ctx;

    #ifdefined(MBEDTLS_CMAC_C)
    mbedtls_cmac_context_t*cmac_ctx;
    #endif

    #ifdefined(MBEDTLS_USE_PSA_CRYPTO)
    unsignedcharpsa_enabled;
    #endif/*MBEDTLS_USE_PSA_CRYPTO*/

    }mbedtls_cipher_context_t;

    constint*mbedtls_cipher_list(void);

    constmbedtls_cipher_info_t*mbedtls_cipher_info_from_string(constchar*cipher_name);

    constmbedtls_cipher_info_t*mbedtls_cipher_info_from_type(constmbedtls_cipher_type_tcipher_type);

    constmbedtls_cipher_info_t*mbedtls_cipher_info_from_values(constmbedtls_cipher_id_tcipher_id,
    intkey_bitlen,
    constmbedtls_cipher_mode_tmode);

    voidmbedtls_cipher_init(mbedtls_cipher_context_t*ctx);

    voidmbedtls_cipher_free(mbedtls_cipher_context_t*ctx);

    intmbedtls_cipher_setup(mbedtls_cipher_context_t*ctx,
    constmbedtls_cipher_info_t*cipher_info);

    #ifdefined(MBEDTLS_USE_PSA_CRYPTO)
    intmbedtls_cipher_setup_psa(mbedtls_cipher_context_t*ctx,
    constmbedtls_cipher_info_t*cipher_info,
    size_ttaglen);
    #endif/*MBEDTLS_USE_PSA_CRYPTO*/

    staticinlineunsignedintmbedtls_cipher_get_block_size(
    constmbedtls_cipher_context_t*ctx)
    {
    MBEDTLS_INTERNAL_VALIDATE_RET(ctx!=NULL,0);
    if(ctx->cipher_info==NULL){
    return0;
    }

    returnctx->cipher_info->block_size;
    }

    staticinlinembedtls_cipher_mode_tmbedtls_cipher_get_cipher_mode(
    constmbedtls_cipher_context_t*ctx)
    {
    MBEDTLS_INTERNAL_VALIDATE_RET(ctx!=NULL,MBEDTLS_MODE_NONE);
    if(ctx->cipher_info==NULL){
    returnMBEDTLS_MODE_NONE;
    }

    returnctx->cipher_info->mode;
    }

    staticinlineintmbedtls_cipher_get_iv_size(
    constmbedtls_cipher_context_t*ctx)
    {
    MBEDTLS_INTERNAL_VALIDATE_RET(ctx!=NULL,0);
    if(ctx->cipher_info==NULL){
    return0;
    }

    if(ctx->iv_size!=0){
    return(int)ctx->iv_size;
    }

    return(int)ctx->cipher_info->iv_size;
    }

    staticinlinembedtls_cipher_type_tmbedtls_cipher_get_type(
    constmbedtls_cipher_context_t*ctx)
    {
    MBEDTLS_INTERNAL_VALIDATE_RET(
    ctx!=NULL,MBEDTLS_CIPHER_NONE);
    if(ctx->cipher_info==NULL){
    returnMBEDTLS_CIPHER_NONE;
    }

    returnctx->cipher_info->type;
    }

    staticinlineconstchar*mbedtls_cipher_get_name(
    constmbedtls_cipher_context_t*ctx)
    {
    MBEDTLS_INTERNAL_VALIDATE_RET(ctx!=NULL,0);
    if(ctx->cipher_info==NULL){
    return0;
    }

    returnctx->cipher_info->name;
    }

    staticinlineintmbedtls_cipher_get_key_bitlen(
    constmbedtls_cipher_context_t*ctx)
    {
    MBEDTLS_INTERNAL_VALIDATE_RET(
    ctx!=NULL,MBEDTLS_KEY_LENGTH_NONE);
    if(ctx->cipher_info==NULL){
    returnMBEDTLS_KEY_LENGTH_NONE;
    }

    return(int)ctx->cipher_info->key_bitlen;
    }

    staticinlinembedtls_operation_tmbedtls_cipher_get_operation(
    constmbedtls_cipher_context_t*ctx)
    {
    MBEDTLS_INTERNAL_VALIDATE_RET(
    ctx!=NULL,MBEDTLS_OPERATION_NONE);
    if(ctx->cipher_info==NULL){
    returnMBEDTLS_OPERATION_NONE;
    }

    returnctx->operation;
    }

    intmbedtls_cipher_setkey(mbedtls_cipher_context_t*ctx,
    constunsignedchar*key,
    intkey_bitlen,
    constmbedtls_operation_toperation);

    #ifdefined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
    intmbedtls_cipher_set_padding_mode(mbedtls_cipher_context_t*ctx,
    mbedtls_cipher_padding_tmode);
    #endif/*MBEDTLS_CIPHER_MODE_WITH_PADDING*/

    intmbedtls_cipher_set_iv(mbedtls_cipher_context_t*ctx,
    constunsignedchar*iv,
    size_tiv_len);

    intmbedtls_cipher_reset(mbedtls_cipher_context_t*ctx);

    #ifdefined(MBEDTLS_GCM_C)||defined(MBEDTLS_CHACHAPOLY_C)
    intmbedtls_cipher_update_ad(mbedtls_cipher_context_t*ctx,
    constunsignedchar*ad,size_tad_len);
    #endif/*MBEDTLS_GCM_C||MBEDTLS_CHACHAPOLY_C*/

    intmbedtls_cipher_update(mbedtls_cipher_context_t*ctx,
    constunsignedchar*input,
    size_tilen,unsignedchar*output,
    size_t*olen);

    intmbedtls_cipher_finish(mbedtls_cipher_context_t*ctx,
    unsignedchar*output,size_t*olen);

    #ifdefined(MBEDTLS_GCM_C)||defined(MBEDTLS_CHACHAPOLY_C)
    intmbedtls_cipher_write_tag(mbedtls_cipher_context_t*ctx,
    unsignedchar*tag,size_ttag_len);

    intmbedtls_cipher_check_tag(mbedtls_cipher_context_t*ctx,
    constunsignedchar*tag,size_ttag_len);
    #endif/*MBEDTLS_GCM_C||MBEDTLS_CHACHAPOLY_C*/

    intmbedtls_cipher_crypt(mbedtls_cipher_context_t*ctx,
    constunsignedchar*iv,size_tiv_len,
    constunsignedchar*input,size_tilen,
    unsignedchar*output,size_t*olen);

    #ifdefined(MBEDTLS_CIPHER_MODE_AEAD)
    #if!defined(MBEDTLS_DEPRECATED_REMOVED)
    #ifdefined(MBEDTLS_DEPRECATED_WARNING)
    #defineMBEDTLS_DEPRECATED__attribute__((deprecated))
    #else
    #defineMBEDTLS_DEPRECATED
    #endif/*MBEDTLS_DEPRECATED_WARNING*/
    intMBEDTLS_DEPRECATEDmbedtls_cipher_auth_encrypt(
    mbedtls_cipher_context_t*ctx,
    constunsignedchar*iv,size_tiv_len,
    constunsignedchar*ad,size_tad_len,
    constunsignedchar*input,size_tilen,
    unsignedchar*output,size_t*olen,
    unsignedchar*tag,size_ttag_len);

    intMBEDTLS_DEPRECATEDmbedtls_cipher_auth_decrypt(
    mbedtls_cipher_context_t*ctx,
    constunsignedchar*iv,size_tiv_len,
    constunsignedchar*ad,size_tad_len,
    constunsignedchar*input,size_tilen,
    unsignedchar*output,size_t*olen,
    constunsignedchar*tag,size_ttag_len);
    #undefMBEDTLS_DEPRECATED
    #endif/*MBEDTLS_DEPRECATED_REMOVED*/
    #endif/*MBEDTLS_CIPHER_MODE_AEAD*/

    #ifdefined(MBEDTLS_CIPHER_MODE_AEAD)||defined(MBEDTLS_NIST_KW_C)
    intmbedtls_cipher_auth_encrypt_ext(mbedtls_cipher_context_t*ctx,
    constunsignedchar*iv,size_tiv_len,
    constunsignedchar*ad,size_tad_len,
    constunsignedchar*input,size_tilen,
    unsignedchar*output,size_toutput_len,
    size_t*olen,size_ttag_len);

    intmbedtls_cipher_auth_decrypt_ext(mbedtls_cipher_context_t*ctx,
    constunsignedchar*iv,size_tiv_len,
    constunsignedchar*ad,size_tad_len,
    constunsignedchar*input,size_tilen,
    unsignedchar*output,size_toutput_len,
    size_t*olen,size_ttag_len);
    #endif/*MBEDTLS_CIPHER_MODE_AEAD||MBEDTLS_NIST_KW_C*/
    #ifdef__cplusplus
    }
    #endif

    #endif/*MBEDTLS_CIPHER_H*/