Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 1 | /** |
| 2 | * \file cipher.h |
Paul Bakker | 9af723c | 2014-05-01 13:03:14 +0200 | [diff] [blame] | 3 | * |
Rose Zadik | 826f264 | 2018-04-19 14:01:29 +0100 | [diff] [blame] | 4 | * \brief This file contains an abstraction interface for use with the cipher |
| 5 | * primitives provided by the library. It provides a common interface to all of |
| 6 | * the available cipher operations. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 7 | * |
| 8 | * \author Adriaan de Jong <dejong@fox-it.com> |
Darryl Green | a40a101 | 2018-01-05 15:33:17 +0000 | [diff] [blame] | 9 | */ |
| 10 | /* |
Bence Szépkúti | 1e14827 | 2020-08-07 13:07:28 +0200 | [diff] [blame] | 11 | * Copyright The Mbed TLS Contributors |
Manuel Pégourié-Gonnard | 37ff140 | 2015-09-04 14:21:07 +0200 | [diff] [blame] | 12 | * SPDX-License-Identifier: Apache-2.0 |
| 13 | * |
| 14 | * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 15 | * not use this file except in compliance with the License. |
| 16 | * You may obtain a copy of the License at |
| 17 | * |
| 18 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 19 | * |
| 20 | * Unless required by applicable law or agreed to in writing, software |
| 21 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 22 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 23 | * See the License for the specific language governing permissions and |
| 24 | * limitations under the License. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 25 | */ |
| 26 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 27 | #ifndef MBEDTLS_CIPHER_H |
| 28 | #define MBEDTLS_CIPHER_H |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 29 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 30 | #if !defined(MBEDTLS_CONFIG_FILE) |
Jaeden Amero | c49fbbf | 2019-07-04 20:01:14 +0100 | [diff] [blame] | 31 | #include "mbedtls/config.h" |
Manuel Pégourié-Gonnard | cef4ad2 | 2014-04-29 12:39:06 +0200 | [diff] [blame] | 32 | #else |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 33 | #include MBEDTLS_CONFIG_FILE |
Manuel Pégourié-Gonnard | cef4ad2 | 2014-04-29 12:39:06 +0200 | [diff] [blame] | 34 | #endif |
Manuel Pégourié-Gonnard | 43a4780 | 2013-09-03 16:35:53 +0200 | [diff] [blame] | 35 | |
Rich Evans | 00ab470 | 2015-02-06 13:43:58 +0000 | [diff] [blame] | 36 | #include <stddef.h> |
Jaeden Amero | c49fbbf | 2019-07-04 20:01:14 +0100 | [diff] [blame] | 37 | #include "mbedtls/platform_util.h" |
Rich Evans | 00ab470 | 2015-02-06 13:43:58 +0000 | [diff] [blame] | 38 | |
Manuel Pégourié-Gonnard | dca3a5d | 2018-05-07 10:43:27 +0200 | [diff] [blame] | 39 | #if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CCM_C) || defined(MBEDTLS_CHACHAPOLY_C) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 40 | #define MBEDTLS_CIPHER_MODE_AEAD |
Manuel Pégourié-Gonnard | 43a4780 | 2013-09-03 16:35:53 +0200 | [diff] [blame] | 41 | #endif |
| 42 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 43 | #if defined(MBEDTLS_CIPHER_MODE_CBC) |
| 44 | #define MBEDTLS_CIPHER_MODE_WITH_PADDING |
Manuel Pégourié-Gonnard | 989ed38 | 2013-09-13 14:41:45 +0200 | [diff] [blame] | 45 | #endif |
| 46 | |
Simon Butcher | c796573 | 2018-07-27 17:13:39 +0100 | [diff] [blame] | 47 | #if defined(MBEDTLS_ARC4_C) || defined(MBEDTLS_CIPHER_NULL_CIPHER) || \ |
| 48 | defined(MBEDTLS_CHACHA20_C) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 49 | #define MBEDTLS_CIPHER_MODE_STREAM |
Manuel Pégourié-Gonnard | b8ca723 | 2014-12-02 10:09:10 +0100 | [diff] [blame] | 50 | #endif |
| 51 | |
Manuel Pégourié-Gonnard | 0223ab9 | 2015-10-05 11:40:01 +0100 | [diff] [blame] | 52 | #if ( defined(__ARMCC_VERSION) || defined(_MSC_VER) ) && \ |
| 53 | !defined(inline) && !defined(__cplusplus) |
Paul Bakker | 569df2c | 2011-06-21 07:48:07 +0000 | [diff] [blame] | 54 | #define inline __inline |
Manuel Pégourié-Gonnard | 20af64d | 2015-07-07 18:33:39 +0200 | [diff] [blame] | 55 | #endif |
Paul Bakker | af5c85f | 2011-04-18 03:47:52 +0000 | [diff] [blame] | 56 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 57 | #define MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE -0x6080 /**< The selected feature is not available. */ |
| 58 | #define MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA -0x6100 /**< Bad input parameters. */ |
| 59 | #define MBEDTLS_ERR_CIPHER_ALLOC_FAILED -0x6180 /**< Failed to allocate memory. */ |
| 60 | #define MBEDTLS_ERR_CIPHER_INVALID_PADDING -0x6200 /**< Input data contains invalid padding and is rejected. */ |
| 61 | #define MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED -0x6280 /**< Decryption of block requires a full block. */ |
| 62 | #define MBEDTLS_ERR_CIPHER_AUTH_FAILED -0x6300 /**< Authentication failed (for AEAD modes). */ |
| 63 | #define MBEDTLS_ERR_CIPHER_INVALID_CONTEXT -0x6380 /**< The context is invalid. For example, because it was freed. */ |
Ron Eldor | 9924bdc | 2018-10-04 10:59:13 +0300 | [diff] [blame] | 64 | |
| 65 | /* MBEDTLS_ERR_CIPHER_HW_ACCEL_FAILED is deprecated and should not be used. */ |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 66 | #define MBEDTLS_ERR_CIPHER_HW_ACCEL_FAILED -0x6400 /**< Cipher hardware accelerator failed. */ |
Paul Bakker | 343a870 | 2011-06-09 14:27:58 +0000 | [diff] [blame] | 67 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 68 | #define MBEDTLS_CIPHER_VARIABLE_IV_LEN 0x01 /**< Cipher accepts IVs of variable length. */ |
| 69 | #define MBEDTLS_CIPHER_VARIABLE_KEY_LEN 0x02 /**< Cipher accepts keys of variable length. */ |
Manuel Pégourié-Gonnard | 81754a0 | 2014-06-23 11:33:18 +0200 | [diff] [blame] | 70 | |
Paul Bakker | 407a0da | 2013-06-27 14:29:21 +0200 | [diff] [blame] | 71 | #ifdef __cplusplus |
| 72 | extern "C" { |
| 73 | #endif |
| 74 | |
Hanno Becker | bbca8c5 | 2017-09-25 14:53:51 +0100 | [diff] [blame] | 75 | /** |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 76 | * \brief Supported cipher types. |
Hanno Becker | bbca8c5 | 2017-09-25 14:53:51 +0100 | [diff] [blame] | 77 | * |
Rose Zadik | 826f264 | 2018-04-19 14:01:29 +0100 | [diff] [blame] | 78 | * \warning RC4 and DES are considered weak ciphers and their use |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 79 | * constitutes a security risk. Arm recommends considering stronger |
| 80 | * ciphers instead. |
Hanno Becker | bbca8c5 | 2017-09-25 14:53:51 +0100 | [diff] [blame] | 81 | */ |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 82 | typedef enum { |
Rose Zadik | 4c368e8 | 2018-04-19 14:24:11 +0100 | [diff] [blame] | 83 | MBEDTLS_CIPHER_ID_NONE = 0, /**< Placeholder to mark the end of cipher ID lists. */ |
| 84 | MBEDTLS_CIPHER_ID_NULL, /**< The identity cipher, treated as a stream cipher. */ |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 85 | MBEDTLS_CIPHER_ID_AES, /**< The AES cipher. */ |
| 86 | MBEDTLS_CIPHER_ID_DES, /**< The DES cipher. */ |
Rose Zadik | 93f9919 | 2018-04-19 14:41:33 +0100 | [diff] [blame] | 87 | MBEDTLS_CIPHER_ID_3DES, /**< The Triple DES cipher. */ |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 88 | MBEDTLS_CIPHER_ID_CAMELLIA, /**< The Camellia cipher. */ |
| 89 | MBEDTLS_CIPHER_ID_BLOWFISH, /**< The Blowfish cipher. */ |
Rose Zadik | 826f264 | 2018-04-19 14:01:29 +0100 | [diff] [blame] | 90 | MBEDTLS_CIPHER_ID_ARC4, /**< The RC4 cipher. */ |
Manuel Pégourié-Gonnard | a3712be | 2018-05-22 15:58:50 +0200 | [diff] [blame] | 91 | MBEDTLS_CIPHER_ID_ARIA, /**< The Aria cipher. */ |
Manuel Pégourié-Gonnard | b500f8b | 2018-05-08 12:43:48 +0200 | [diff] [blame] | 92 | MBEDTLS_CIPHER_ID_CHACHA20, /**< The ChaCha20 cipher. */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 93 | } mbedtls_cipher_id_t; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 94 | |
Hanno Becker | bbca8c5 | 2017-09-25 14:53:51 +0100 | [diff] [blame] | 95 | /** |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 96 | * \brief Supported {cipher type, cipher mode} pairs. |
Hanno Becker | bbca8c5 | 2017-09-25 14:53:51 +0100 | [diff] [blame] | 97 | * |
Rose Zadik | 826f264 | 2018-04-19 14:01:29 +0100 | [diff] [blame] | 98 | * \warning RC4 and DES are considered weak ciphers and their use |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 99 | * constitutes a security risk. Arm recommends considering stronger |
Hanno Becker | bbca8c5 | 2017-09-25 14:53:51 +0100 | [diff] [blame] | 100 | * ciphers instead. |
| 101 | */ |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 102 | typedef enum { |
Rose Zadik | 4c368e8 | 2018-04-19 14:24:11 +0100 | [diff] [blame] | 103 | MBEDTLS_CIPHER_NONE = 0, /**< Placeholder to mark the end of cipher-pair lists. */ |
Rose Zadik | c441f74 | 2018-04-19 14:38:20 +0100 | [diff] [blame] | 104 | MBEDTLS_CIPHER_NULL, /**< The identity stream cipher. */ |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 105 | MBEDTLS_CIPHER_AES_128_ECB, /**< AES cipher with 128-bit ECB mode. */ |
| 106 | MBEDTLS_CIPHER_AES_192_ECB, /**< AES cipher with 192-bit ECB mode. */ |
| 107 | MBEDTLS_CIPHER_AES_256_ECB, /**< AES cipher with 256-bit ECB mode. */ |
| 108 | MBEDTLS_CIPHER_AES_128_CBC, /**< AES cipher with 128-bit CBC mode. */ |
| 109 | MBEDTLS_CIPHER_AES_192_CBC, /**< AES cipher with 192-bit CBC mode. */ |
| 110 | MBEDTLS_CIPHER_AES_256_CBC, /**< AES cipher with 256-bit CBC mode. */ |
| 111 | MBEDTLS_CIPHER_AES_128_CFB128, /**< AES cipher with 128-bit CFB128 mode. */ |
| 112 | MBEDTLS_CIPHER_AES_192_CFB128, /**< AES cipher with 192-bit CFB128 mode. */ |
| 113 | MBEDTLS_CIPHER_AES_256_CFB128, /**< AES cipher with 256-bit CFB128 mode. */ |
| 114 | MBEDTLS_CIPHER_AES_128_CTR, /**< AES cipher with 128-bit CTR mode. */ |
| 115 | MBEDTLS_CIPHER_AES_192_CTR, /**< AES cipher with 192-bit CTR mode. */ |
| 116 | MBEDTLS_CIPHER_AES_256_CTR, /**< AES cipher with 256-bit CTR mode. */ |
| 117 | MBEDTLS_CIPHER_AES_128_GCM, /**< AES cipher with 128-bit GCM mode. */ |
| 118 | MBEDTLS_CIPHER_AES_192_GCM, /**< AES cipher with 192-bit GCM mode. */ |
| 119 | MBEDTLS_CIPHER_AES_256_GCM, /**< AES cipher with 256-bit GCM mode. */ |
| 120 | MBEDTLS_CIPHER_CAMELLIA_128_ECB, /**< Camellia cipher with 128-bit ECB mode. */ |
| 121 | MBEDTLS_CIPHER_CAMELLIA_192_ECB, /**< Camellia cipher with 192-bit ECB mode. */ |
| 122 | MBEDTLS_CIPHER_CAMELLIA_256_ECB, /**< Camellia cipher with 256-bit ECB mode. */ |
| 123 | MBEDTLS_CIPHER_CAMELLIA_128_CBC, /**< Camellia cipher with 128-bit CBC mode. */ |
| 124 | MBEDTLS_CIPHER_CAMELLIA_192_CBC, /**< Camellia cipher with 192-bit CBC mode. */ |
| 125 | MBEDTLS_CIPHER_CAMELLIA_256_CBC, /**< Camellia cipher with 256-bit CBC mode. */ |
| 126 | MBEDTLS_CIPHER_CAMELLIA_128_CFB128, /**< Camellia cipher with 128-bit CFB128 mode. */ |
| 127 | MBEDTLS_CIPHER_CAMELLIA_192_CFB128, /**< Camellia cipher with 192-bit CFB128 mode. */ |
| 128 | MBEDTLS_CIPHER_CAMELLIA_256_CFB128, /**< Camellia cipher with 256-bit CFB128 mode. */ |
| 129 | MBEDTLS_CIPHER_CAMELLIA_128_CTR, /**< Camellia cipher with 128-bit CTR mode. */ |
| 130 | MBEDTLS_CIPHER_CAMELLIA_192_CTR, /**< Camellia cipher with 192-bit CTR mode. */ |
| 131 | MBEDTLS_CIPHER_CAMELLIA_256_CTR, /**< Camellia cipher with 256-bit CTR mode. */ |
| 132 | MBEDTLS_CIPHER_CAMELLIA_128_GCM, /**< Camellia cipher with 128-bit GCM mode. */ |
| 133 | MBEDTLS_CIPHER_CAMELLIA_192_GCM, /**< Camellia cipher with 192-bit GCM mode. */ |
| 134 | MBEDTLS_CIPHER_CAMELLIA_256_GCM, /**< Camellia cipher with 256-bit GCM mode. */ |
| 135 | MBEDTLS_CIPHER_DES_ECB, /**< DES cipher with ECB mode. */ |
| 136 | MBEDTLS_CIPHER_DES_CBC, /**< DES cipher with CBC mode. */ |
| 137 | MBEDTLS_CIPHER_DES_EDE_ECB, /**< DES cipher with EDE ECB mode. */ |
| 138 | MBEDTLS_CIPHER_DES_EDE_CBC, /**< DES cipher with EDE CBC mode. */ |
| 139 | MBEDTLS_CIPHER_DES_EDE3_ECB, /**< DES cipher with EDE3 ECB mode. */ |
| 140 | MBEDTLS_CIPHER_DES_EDE3_CBC, /**< DES cipher with EDE3 CBC mode. */ |
| 141 | MBEDTLS_CIPHER_BLOWFISH_ECB, /**< Blowfish cipher with ECB mode. */ |
| 142 | MBEDTLS_CIPHER_BLOWFISH_CBC, /**< Blowfish cipher with CBC mode. */ |
| 143 | MBEDTLS_CIPHER_BLOWFISH_CFB64, /**< Blowfish cipher with CFB64 mode. */ |
| 144 | MBEDTLS_CIPHER_BLOWFISH_CTR, /**< Blowfish cipher with CTR mode. */ |
Rose Zadik | 826f264 | 2018-04-19 14:01:29 +0100 | [diff] [blame] | 145 | MBEDTLS_CIPHER_ARC4_128, /**< RC4 cipher with 128-bit mode. */ |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 146 | MBEDTLS_CIPHER_AES_128_CCM, /**< AES cipher with 128-bit CCM mode. */ |
| 147 | MBEDTLS_CIPHER_AES_192_CCM, /**< AES cipher with 192-bit CCM mode. */ |
| 148 | MBEDTLS_CIPHER_AES_256_CCM, /**< AES cipher with 256-bit CCM mode. */ |
| 149 | MBEDTLS_CIPHER_CAMELLIA_128_CCM, /**< Camellia cipher with 128-bit CCM mode. */ |
| 150 | MBEDTLS_CIPHER_CAMELLIA_192_CCM, /**< Camellia cipher with 192-bit CCM mode. */ |
| 151 | MBEDTLS_CIPHER_CAMELLIA_256_CCM, /**< Camellia cipher with 256-bit CCM mode. */ |
Manuel Pégourié-Gonnard | a3712be | 2018-05-22 15:58:50 +0200 | [diff] [blame] | 152 | MBEDTLS_CIPHER_ARIA_128_ECB, /**< Aria cipher with 128-bit key and ECB mode. */ |
| 153 | MBEDTLS_CIPHER_ARIA_192_ECB, /**< Aria cipher with 192-bit key and ECB mode. */ |
| 154 | MBEDTLS_CIPHER_ARIA_256_ECB, /**< Aria cipher with 256-bit key and ECB mode. */ |
| 155 | MBEDTLS_CIPHER_ARIA_128_CBC, /**< Aria cipher with 128-bit key and CBC mode. */ |
| 156 | MBEDTLS_CIPHER_ARIA_192_CBC, /**< Aria cipher with 192-bit key and CBC mode. */ |
| 157 | MBEDTLS_CIPHER_ARIA_256_CBC, /**< Aria cipher with 256-bit key and CBC mode. */ |
| 158 | MBEDTLS_CIPHER_ARIA_128_CFB128, /**< Aria cipher with 128-bit key and CFB-128 mode. */ |
| 159 | MBEDTLS_CIPHER_ARIA_192_CFB128, /**< Aria cipher with 192-bit key and CFB-128 mode. */ |
| 160 | MBEDTLS_CIPHER_ARIA_256_CFB128, /**< Aria cipher with 256-bit key and CFB-128 mode. */ |
| 161 | MBEDTLS_CIPHER_ARIA_128_CTR, /**< Aria cipher with 128-bit key and CTR mode. */ |
| 162 | MBEDTLS_CIPHER_ARIA_192_CTR, /**< Aria cipher with 192-bit key and CTR mode. */ |
| 163 | MBEDTLS_CIPHER_ARIA_256_CTR, /**< Aria cipher with 256-bit key and CTR mode. */ |
| 164 | MBEDTLS_CIPHER_ARIA_128_GCM, /**< Aria cipher with 128-bit key and GCM mode. */ |
| 165 | MBEDTLS_CIPHER_ARIA_192_GCM, /**< Aria cipher with 192-bit key and GCM mode. */ |
| 166 | MBEDTLS_CIPHER_ARIA_256_GCM, /**< Aria cipher with 256-bit key and GCM mode. */ |
| 167 | MBEDTLS_CIPHER_ARIA_128_CCM, /**< Aria cipher with 128-bit key and CCM mode. */ |
| 168 | MBEDTLS_CIPHER_ARIA_192_CCM, /**< Aria cipher with 192-bit key and CCM mode. */ |
| 169 | MBEDTLS_CIPHER_ARIA_256_CCM, /**< Aria cipher with 256-bit key and CCM mode. */ |
Simon Butcher | 6873c84 | 2018-04-29 13:03:20 +0100 | [diff] [blame] | 170 | MBEDTLS_CIPHER_AES_128_OFB, /**< AES 128-bit cipher in OFB mode. */ |
| 171 | MBEDTLS_CIPHER_AES_192_OFB, /**< AES 192-bit cipher in OFB mode. */ |
| 172 | MBEDTLS_CIPHER_AES_256_OFB, /**< AES 256-bit cipher in OFB mode. */ |
Jaeden Amero | c653990 | 2018-04-30 17:17:41 +0100 | [diff] [blame] | 173 | MBEDTLS_CIPHER_AES_128_XTS, /**< AES 128-bit cipher in XTS block mode. */ |
| 174 | MBEDTLS_CIPHER_AES_256_XTS, /**< AES 256-bit cipher in XTS block mode. */ |
Manuel Pégourié-Gonnard | b500f8b | 2018-05-08 12:43:48 +0200 | [diff] [blame] | 175 | MBEDTLS_CIPHER_CHACHA20, /**< ChaCha20 stream cipher. */ |
| 176 | MBEDTLS_CIPHER_CHACHA20_POLY1305, /**< ChaCha20-Poly1305 AEAD cipher. */ |
Jack Lloyd | ffdf288 | 2019-03-07 17:00:32 -0500 | [diff] [blame] | 177 | MBEDTLS_CIPHER_AES_128_KW, /**< AES cipher with 128-bit NIST KW mode. */ |
| 178 | MBEDTLS_CIPHER_AES_192_KW, /**< AES cipher with 192-bit NIST KW mode. */ |
| 179 | MBEDTLS_CIPHER_AES_256_KW, /**< AES cipher with 256-bit NIST KW mode. */ |
| 180 | MBEDTLS_CIPHER_AES_128_KWP, /**< AES cipher with 128-bit NIST KWP mode. */ |
| 181 | MBEDTLS_CIPHER_AES_192_KWP, /**< AES cipher with 192-bit NIST KWP mode. */ |
| 182 | MBEDTLS_CIPHER_AES_256_KWP, /**< AES cipher with 256-bit NIST KWP mode. */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 183 | } mbedtls_cipher_type_t; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 184 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 185 | /** Supported cipher modes. */ |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 186 | typedef enum { |
Hanno Becker | e5a0450 | 2018-11-08 16:57:42 +0000 | [diff] [blame] | 187 | MBEDTLS_MODE_NONE = 0, /**< None. */ |
| 188 | MBEDTLS_MODE_ECB, /**< The ECB cipher mode. */ |
| 189 | MBEDTLS_MODE_CBC, /**< The CBC cipher mode. */ |
| 190 | MBEDTLS_MODE_CFB, /**< The CFB cipher mode. */ |
| 191 | MBEDTLS_MODE_OFB, /**< The OFB cipher mode. */ |
| 192 | MBEDTLS_MODE_CTR, /**< The CTR cipher mode. */ |
| 193 | MBEDTLS_MODE_GCM, /**< The GCM cipher mode. */ |
| 194 | MBEDTLS_MODE_STREAM, /**< The stream cipher mode. */ |
| 195 | MBEDTLS_MODE_CCM, /**< The CCM cipher mode. */ |
| 196 | MBEDTLS_MODE_XTS, /**< The XTS cipher mode. */ |
Manuel Pégourié-Gonnard | f57bf8b | 2018-06-18 11:14:09 +0200 | [diff] [blame] | 197 | MBEDTLS_MODE_CHACHAPOLY, /**< The ChaCha-Poly cipher mode. */ |
Jack Lloyd | ffdf288 | 2019-03-07 17:00:32 -0500 | [diff] [blame] | 198 | MBEDTLS_MODE_KW, /**< The SP800-38F KW mode */ |
| 199 | MBEDTLS_MODE_KWP, /**< The SP800-38F KWP mode */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 200 | } mbedtls_cipher_mode_t; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 201 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 202 | /** Supported cipher padding types. */ |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 203 | typedef enum { |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 204 | MBEDTLS_PADDING_PKCS7 = 0, /**< PKCS7 padding (default). */ |
| 205 | MBEDTLS_PADDING_ONE_AND_ZEROS, /**< ISO/IEC 7816-4 padding. */ |
| 206 | MBEDTLS_PADDING_ZEROS_AND_LEN, /**< ANSI X.923 padding. */ |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 207 | MBEDTLS_PADDING_ZEROS, /**< Zero padding (not reversible). */ |
| 208 | MBEDTLS_PADDING_NONE, /**< Never pad (full blocks only). */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 209 | } mbedtls_cipher_padding_t; |
Manuel Pégourié-Gonnard | d5fdcaf | 2013-07-24 18:05:00 +0200 | [diff] [blame] | 210 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 211 | /** Type of operation. */ |
Manuel Pégourié-Gonnard | d5fdcaf | 2013-07-24 18:05:00 +0200 | [diff] [blame] | 212 | typedef enum { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 213 | MBEDTLS_OPERATION_NONE = -1, |
| 214 | MBEDTLS_DECRYPT = 0, |
| 215 | MBEDTLS_ENCRYPT, |
| 216 | } mbedtls_operation_t; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 217 | |
| 218 | enum { |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 219 | /** Undefined key length. */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 220 | MBEDTLS_KEY_LENGTH_NONE = 0, |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 221 | /** Key length, in bits (including parity), for DES keys. */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 222 | MBEDTLS_KEY_LENGTH_DES = 64, |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 223 | /** Key length in bits, including parity, for DES in two-key EDE. */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 224 | MBEDTLS_KEY_LENGTH_DES_EDE = 128, |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 225 | /** Key length in bits, including parity, for DES in three-key EDE. */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 226 | MBEDTLS_KEY_LENGTH_DES_EDE3 = 192, |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 227 | }; |
| 228 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 229 | /** Maximum length of any IV, in Bytes. */ |
Hanno Becker | 1588983 | 2020-09-08 11:29:11 +0100 | [diff] [blame] | 230 | /* This should ideally be derived automatically from list of ciphers. |
| 231 | * This should be kept in sync with MBEDTLS_SSL_MAX_IV_LENGTH defined |
| 232 | * in ssl_internal.h. */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 233 | #define MBEDTLS_MAX_IV_LENGTH 16 |
Hanno Becker | 27a2688 | 2020-08-07 11:30:05 +0100 | [diff] [blame] | 234 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 235 | /** Maximum block size of any cipher, in Bytes. */ |
Hanno Becker | 1588983 | 2020-09-08 11:29:11 +0100 | [diff] [blame] | 236 | /* This should ideally be derived automatically from list of ciphers. |
| 237 | * This should be kept in sync with MBEDTLS_SSL_MAX_BLOCK_LENGTH defined |
| 238 | * in ssl_internal.h. */ |
Manuel Pégourié-Gonnard | 32902e6 | 2018-05-10 12:30:19 +0200 | [diff] [blame] | 239 | #define MBEDTLS_MAX_BLOCK_LENGTH 16 |
Manuel Pégourié-Gonnard | 0b58c15 | 2013-10-24 17:17:54 +0200 | [diff] [blame] | 240 | |
Hanno Becker | 27a2688 | 2020-08-07 11:30:05 +0100 | [diff] [blame] | 241 | /** Maximum key length, in Bytes. */ |
| 242 | /* This should ideally be derived automatically from list of ciphers. |
| 243 | * For now, only check whether XTS is enabled which uses 64 Byte keys, |
Hanno Becker | 1588983 | 2020-09-08 11:29:11 +0100 | [diff] [blame] | 244 | * and use 32 Bytes as an upper bound for the maximum key length otherwise. |
| 245 | * This should be kept in sync with MBEDTLS_SSL_MAX_BLOCK_LENGTH defined |
| 246 | * in ssl_internal.h, which however deliberately ignores the case of XTS |
| 247 | * since the latter isn't used in SSL/TLS. */ |
Hanno Becker | 27a2688 | 2020-08-07 11:30:05 +0100 | [diff] [blame] | 248 | #if defined(MBEDTLS_CIPHER_MODE_XTS) |
| 249 | #define MBEDTLS_MAX_KEY_LENGTH 64 |
| 250 | #else |
| 251 | #define MBEDTLS_MAX_KEY_LENGTH 32 |
| 252 | #endif /* MBEDTLS_CIPHER_MODE_XTS */ |
| 253 | |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 254 | /** |
Manuel Pégourié-Gonnard | 5a74e8b | 2015-05-06 17:10:55 +0100 | [diff] [blame] | 255 | * Base cipher information (opaque struct). |
Paul Bakker | 343a870 | 2011-06-09 14:27:58 +0000 | [diff] [blame] | 256 | */ |
Manuel Pégourié-Gonnard | 5a74e8b | 2015-05-06 17:10:55 +0100 | [diff] [blame] | 257 | typedef struct mbedtls_cipher_base_t mbedtls_cipher_base_t; |
Paul Bakker | 343a870 | 2011-06-09 14:27:58 +0000 | [diff] [blame] | 258 | |
| 259 | /** |
Simon Butcher | 327398a | 2016-10-05 14:09:11 +0100 | [diff] [blame] | 260 | * CMAC context (opaque struct). |
| 261 | */ |
| 262 | typedef struct mbedtls_cmac_context_t mbedtls_cmac_context_t; |
| 263 | |
| 264 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 265 | * Cipher information. Allows calling cipher functions |
| 266 | * in a generic way. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 267 | */ |
Dawid Drozd | 428cc52 | 2018-07-24 10:02:47 +0200 | [diff] [blame] | 268 | typedef struct mbedtls_cipher_info_t |
| 269 | { |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 270 | /** Full cipher identifier. For example, |
| 271 | * MBEDTLS_CIPHER_AES_256_CBC. |
| 272 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 273 | mbedtls_cipher_type_t type; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 274 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 275 | /** The cipher mode. For example, MBEDTLS_MODE_CBC. */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 276 | mbedtls_cipher_mode_t mode; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 277 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 278 | /** The cipher key length, in bits. This is the |
| 279 | * default length for variable sized ciphers. |
| 280 | * Includes parity bits for ciphers like DES. |
| 281 | */ |
Manuel Pégourié-Gonnard | 898e0aa | 2015-06-18 15:28:12 +0200 | [diff] [blame] | 282 | unsigned int key_bitlen; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 283 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 284 | /** Name of the cipher. */ |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 285 | const char * name; |
| 286 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 287 | /** IV or nonce size, in Bytes. |
| 288 | * For ciphers that accept variable IV sizes, |
| 289 | * this is the recommended size. |
| 290 | */ |
Paul Bakker | 23986e5 | 2011-04-24 08:57:21 +0000 | [diff] [blame] | 291 | unsigned int iv_size; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 292 | |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 293 | /** Bitflag comprised of MBEDTLS_CIPHER_VARIABLE_IV_LEN and |
| 294 | * MBEDTLS_CIPHER_VARIABLE_KEY_LEN indicating whether the |
| 295 | * cipher supports variable IV or variable key sizes, respectively. |
| 296 | */ |
Manuel Pégourié-Gonnard | 81754a0 | 2014-06-23 11:33:18 +0200 | [diff] [blame] | 297 | int flags; |
Manuel Pégourié-Gonnard | a235b5b | 2013-09-03 13:25:52 +0200 | [diff] [blame] | 298 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 299 | /** The block size, in Bytes. */ |
Paul Bakker | 23986e5 | 2011-04-24 08:57:21 +0000 | [diff] [blame] | 300 | unsigned int block_size; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 301 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 302 | /** Struct for base cipher information and functions. */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 303 | const mbedtls_cipher_base_t *base; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 304 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 305 | } mbedtls_cipher_info_t; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 306 | |
| 307 | /** |
Paul Bakker | 2028156 | 2011-11-11 10:34:04 +0000 | [diff] [blame] | 308 | * Generic cipher context. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 309 | */ |
Dawid Drozd | 428cc52 | 2018-07-24 10:02:47 +0200 | [diff] [blame] | 310 | typedef struct mbedtls_cipher_context_t |
| 311 | { |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 312 | /** Information about the associated cipher. */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 313 | const mbedtls_cipher_info_t *cipher_info; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 314 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 315 | /** Key length to use. */ |
Manuel Pégourié-Gonnard | 898e0aa | 2015-06-18 15:28:12 +0200 | [diff] [blame] | 316 | int key_bitlen; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 317 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 318 | /** Operation that the key of the context has been |
| 319 | * initialized for. |
| 320 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 321 | mbedtls_operation_t operation; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 322 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 323 | #if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING) |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 324 | /** Padding functions to use, if relevant for |
| 325 | * the specific cipher mode. |
| 326 | */ |
Manuel Pégourié-Gonnard | ac56a1a | 2013-07-25 12:31:10 +0200 | [diff] [blame] | 327 | void (*add_padding)( unsigned char *output, size_t olen, size_t data_len ); |
| 328 | int (*get_padding)( unsigned char *input, size_t ilen, size_t *data_len ); |
Manuel Pégourié-Gonnard | b8ca723 | 2014-12-02 10:09:10 +0100 | [diff] [blame] | 329 | #endif |
Manuel Pégourié-Gonnard | ac56a1a | 2013-07-25 12:31:10 +0200 | [diff] [blame] | 330 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 331 | /** Buffer for input that has not been processed yet. */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 332 | unsigned char unprocessed_data[MBEDTLS_MAX_BLOCK_LENGTH]; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 333 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 334 | /** Number of Bytes that have not been processed yet. */ |
Paul Bakker | 23986e5 | 2011-04-24 08:57:21 +0000 | [diff] [blame] | 335 | size_t unprocessed_len; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 336 | |
Jaeden Amero | c653990 | 2018-04-30 17:17:41 +0100 | [diff] [blame] | 337 | /** Current IV or NONCE_COUNTER for CTR-mode, data unit (or sector) number |
| 338 | * for XTS-mode. */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 339 | unsigned char iv[MBEDTLS_MAX_IV_LENGTH]; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 340 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 341 | /** IV size in Bytes, for ciphers with variable-length IVs. */ |
Manuel Pégourié-Gonnard | 9c853b9 | 2013-09-03 13:04:44 +0200 | [diff] [blame] | 342 | size_t iv_size; |
| 343 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 344 | /** The cipher-specific context. */ |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 345 | void *cipher_ctx; |
Simon Butcher | 327398a | 2016-10-05 14:09:11 +0100 | [diff] [blame] | 346 | |
| 347 | #if defined(MBEDTLS_CMAC_C) |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 348 | /** CMAC-specific context. */ |
Simon Butcher | 327398a | 2016-10-05 14:09:11 +0100 | [diff] [blame] | 349 | mbedtls_cmac_context_t *cmac_ctx; |
| 350 | #endif |
Hanno Becker | 1cb3653 | 2018-11-09 16:20:29 +0000 | [diff] [blame] | 351 | |
| 352 | #if defined(MBEDTLS_USE_PSA_CRYPTO) |
| 353 | /** Indicates whether the cipher operations should be performed |
| 354 | * by Mbed TLS' own crypto library or an external implementation |
| 355 | * of the PSA Crypto API. |
Hanno Becker | 7909c4c | 2018-11-20 11:34:34 +0000 | [diff] [blame] | 356 | * This is unset if the cipher context was established through |
| 357 | * mbedtls_cipher_setup(), and set if it was established through |
Hanno Becker | 1cb3653 | 2018-11-09 16:20:29 +0000 | [diff] [blame] | 358 | * mbedtls_cipher_setup_psa(). |
| 359 | */ |
| 360 | unsigned char psa_enabled; |
| 361 | #endif /* MBEDTLS_USE_PSA_CRYPTO */ |
| 362 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 363 | } mbedtls_cipher_context_t; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 364 | |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 365 | /** |
Hanno Becker | d7503a7 | 2018-11-08 15:55:24 +0000 | [diff] [blame] | 366 | * \brief This function retrieves the list of ciphers supported |
| 367 | * by the generic cipher module. |
Paul Bakker | 72f6266 | 2011-01-16 21:27:44 +0000 | [diff] [blame] | 368 | * |
Hanno Becker | d7503a7 | 2018-11-08 15:55:24 +0000 | [diff] [blame] | 369 | * For any cipher identifier in the returned list, you can |
| 370 | * obtain the corresponding generic cipher information structure |
| 371 | * via mbedtls_cipher_info_from_type(), which can then be used |
| 372 | * to prepare a cipher context via mbedtls_cipher_setup(). |
| 373 | * |
| 374 | * |
| 375 | * \return A statically-allocated array of cipher identifiers |
| 376 | * of type cipher_type_t. The last entry is zero. |
Paul Bakker | 72f6266 | 2011-01-16 21:27:44 +0000 | [diff] [blame] | 377 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 378 | const int *mbedtls_cipher_list( void ); |
Paul Bakker | 72f6266 | 2011-01-16 21:27:44 +0000 | [diff] [blame] | 379 | |
| 380 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 381 | * \brief This function retrieves the cipher-information |
| 382 | * structure associated with the given cipher name. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 383 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 384 | * \param cipher_name Name of the cipher to search for. This must not be |
| 385 | * \c NULL. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 386 | * |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 387 | * \return The cipher information structure associated with the |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 388 | * given \p cipher_name. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 389 | * \return \c NULL if the associated cipher information is not found. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 390 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 391 | const mbedtls_cipher_info_t *mbedtls_cipher_info_from_string( const char *cipher_name ); |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 392 | |
| 393 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 394 | * \brief This function retrieves the cipher-information |
| 395 | * structure associated with the given cipher type. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 396 | * |
| 397 | * \param cipher_type Type of the cipher to search for. |
| 398 | * |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 399 | * \return The cipher information structure associated with the |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 400 | * given \p cipher_type. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 401 | * \return \c NULL if the associated cipher information is not found. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 402 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 403 | const mbedtls_cipher_info_t *mbedtls_cipher_info_from_type( const mbedtls_cipher_type_t cipher_type ); |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 404 | |
| 405 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 406 | * \brief This function retrieves the cipher-information |
| 407 | * structure associated with the given cipher ID, |
| 408 | * key size and mode. |
Paul Bakker | f46b695 | 2013-09-09 00:08:26 +0200 | [diff] [blame] | 409 | * |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 410 | * \param cipher_id The ID of the cipher to search for. For example, |
| 411 | * #MBEDTLS_CIPHER_ID_AES. |
| 412 | * \param key_bitlen The length of the key in bits. |
| 413 | * \param mode The cipher mode. For example, #MBEDTLS_MODE_CBC. |
Paul Bakker | f46b695 | 2013-09-09 00:08:26 +0200 | [diff] [blame] | 414 | * |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 415 | * \return The cipher information structure associated with the |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 416 | * given \p cipher_id. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 417 | * \return \c NULL if the associated cipher information is not found. |
Paul Bakker | f46b695 | 2013-09-09 00:08:26 +0200 | [diff] [blame] | 418 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 419 | const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id, |
Manuel Pégourié-Gonnard | b8186a5 | 2015-06-18 14:58:58 +0200 | [diff] [blame] | 420 | int key_bitlen, |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 421 | const mbedtls_cipher_mode_t mode ); |
Paul Bakker | f46b695 | 2013-09-09 00:08:26 +0200 | [diff] [blame] | 422 | |
| 423 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 424 | * \brief This function initializes a \p cipher_context as NONE. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 425 | * |
| 426 | * \param ctx The context to be initialized. This must not be \c NULL. |
Paul Bakker | 84bbeb5 | 2014-07-01 14:53:22 +0200 | [diff] [blame] | 427 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 428 | void mbedtls_cipher_init( mbedtls_cipher_context_t *ctx ); |
Paul Bakker | 84bbeb5 | 2014-07-01 14:53:22 +0200 | [diff] [blame] | 429 | |
| 430 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 431 | * \brief This function frees and clears the cipher-specific |
| 432 | * context of \p ctx. Freeing \p ctx itself remains the |
| 433 | * responsibility of the caller. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 434 | * |
| 435 | * \param ctx The context to be freed. If this is \c NULL, the |
| 436 | * function has no effect, otherwise this must point to an |
| 437 | * initialized context. |
Paul Bakker | 84bbeb5 | 2014-07-01 14:53:22 +0200 | [diff] [blame] | 438 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 439 | void mbedtls_cipher_free( mbedtls_cipher_context_t *ctx ); |
Paul Bakker | 84bbeb5 | 2014-07-01 14:53:22 +0200 | [diff] [blame] | 440 | |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 441 | |
Paul Bakker | 84bbeb5 | 2014-07-01 14:53:22 +0200 | [diff] [blame] | 442 | /** |
Hanno Becker | b1f0872 | 2018-11-09 16:09:19 +0000 | [diff] [blame] | 443 | * \brief This function initializes a cipher context for |
| 444 | * use with the given cipher primitive. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 445 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 446 | * \param ctx The context to initialize. This must be initialized. |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 447 | * \param cipher_info The cipher to use. |
Paul Bakker | 84bbeb5 | 2014-07-01 14:53:22 +0200 | [diff] [blame] | 448 | * |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 449 | * \return \c 0 on success. |
Rose Zadik | 4c368e8 | 2018-04-19 14:24:11 +0100 | [diff] [blame] | 450 | * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on |
| 451 | * parameter-verification failure. |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 452 | * \return #MBEDTLS_ERR_CIPHER_ALLOC_FAILED if allocation of the |
Rose Zadik | 4c368e8 | 2018-04-19 14:24:11 +0100 | [diff] [blame] | 453 | * cipher-specific context fails. |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 454 | * |
| 455 | * \internal Currently, the function also clears the structure. |
| 456 | * In future versions, the caller will be required to call |
| 457 | * mbedtls_cipher_init() on the structure first. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 458 | */ |
Hanno Becker | f4fb876 | 2018-11-08 15:57:42 +0000 | [diff] [blame] | 459 | int mbedtls_cipher_setup( mbedtls_cipher_context_t *ctx, |
| 460 | const mbedtls_cipher_info_t *cipher_info ); |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 461 | |
Hanno Becker | 098c9de | 2018-11-09 16:10:57 +0000 | [diff] [blame] | 462 | #if defined(MBEDTLS_USE_PSA_CRYPTO) |
| 463 | /** |
| 464 | * \brief This function initializes a cipher context for |
| 465 | * PSA-based use with the given cipher primitive. |
| 466 | * |
| 467 | * \note See #MBEDTLS_USE_PSA_CRYPTO for information on PSA. |
| 468 | * |
| 469 | * \param ctx The context to initialize. May not be \c NULL. |
| 470 | * \param cipher_info The cipher to use. |
Hanno Becker | f133640 | 2018-11-12 16:26:27 +0000 | [diff] [blame] | 471 | * \param taglen For AEAD ciphers, the length in bytes of the |
| 472 | * authentication tag to use. Subsequent uses of |
| 473 | * mbedtls_cipher_auth_encrypt() or |
| 474 | * mbedtls_cipher_auth_decrypt() must provide |
| 475 | * the same tag length. |
| 476 | * For non-AEAD ciphers, the value must be \c 0. |
Hanno Becker | 098c9de | 2018-11-09 16:10:57 +0000 | [diff] [blame] | 477 | * |
| 478 | * \return \c 0 on success. |
| 479 | * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on |
| 480 | * parameter-verification failure. |
| 481 | * \return #MBEDTLS_ERR_CIPHER_ALLOC_FAILED if allocation of the |
| 482 | * cipher-specific context fails. |
| 483 | */ |
| 484 | int mbedtls_cipher_setup_psa( mbedtls_cipher_context_t *ctx, |
Hanno Becker | f133640 | 2018-11-12 16:26:27 +0000 | [diff] [blame] | 485 | const mbedtls_cipher_info_t *cipher_info, |
| 486 | size_t taglen ); |
Hanno Becker | 098c9de | 2018-11-09 16:10:57 +0000 | [diff] [blame] | 487 | #endif /* MBEDTLS_USE_PSA_CRYPTO */ |
| 488 | |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 489 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 490 | * \brief This function returns the block size of the given cipher. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 491 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 492 | * \param ctx The context of the cipher. This must be initialized. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 493 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 494 | * \return The block size of the underlying cipher. |
| 495 | * \return \c 0 if \p ctx has not been initialized. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 496 | */ |
Hanno Becker | f4fb876 | 2018-11-08 15:57:42 +0000 | [diff] [blame] | 497 | static inline unsigned int mbedtls_cipher_get_block_size( |
| 498 | const mbedtls_cipher_context_t *ctx ) |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 499 | { |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 500 | MBEDTLS_INTERNAL_VALIDATE_RET( ctx != NULL, 0 ); |
| 501 | if( ctx->cipher_info == NULL ) |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 502 | return 0; |
| 503 | |
| 504 | return ctx->cipher_info->block_size; |
| 505 | } |
| 506 | |
| 507 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 508 | * \brief This function returns the mode of operation for |
| 509 | * the cipher. For example, MBEDTLS_MODE_CBC. |
Paul Bakker | f7e5bb5 | 2011-11-11 10:53:37 +0000 | [diff] [blame] | 510 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 511 | * \param ctx The context of the cipher. This must be initialized. |
Paul Bakker | f7e5bb5 | 2011-11-11 10:53:37 +0000 | [diff] [blame] | 512 | * |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 513 | * \return The mode of operation. |
| 514 | * \return #MBEDTLS_MODE_NONE if \p ctx has not been initialized. |
Paul Bakker | f7e5bb5 | 2011-11-11 10:53:37 +0000 | [diff] [blame] | 515 | */ |
Hanno Becker | f4fb876 | 2018-11-08 15:57:42 +0000 | [diff] [blame] | 516 | static inline mbedtls_cipher_mode_t mbedtls_cipher_get_cipher_mode( |
| 517 | const mbedtls_cipher_context_t *ctx ) |
Paul Bakker | f7e5bb5 | 2011-11-11 10:53:37 +0000 | [diff] [blame] | 518 | { |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 519 | MBEDTLS_INTERNAL_VALIDATE_RET( ctx != NULL, MBEDTLS_MODE_NONE ); |
| 520 | if( ctx->cipher_info == NULL ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 521 | return MBEDTLS_MODE_NONE; |
Paul Bakker | f7e5bb5 | 2011-11-11 10:53:37 +0000 | [diff] [blame] | 522 | |
| 523 | return ctx->cipher_info->mode; |
| 524 | } |
| 525 | |
| 526 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 527 | * \brief This function returns the size of the IV or nonce |
| 528 | * of the cipher, in Bytes. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 529 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 530 | * \param ctx The context of the cipher. This must be initialized. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 531 | * |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 532 | * \return The recommended IV size if no IV has been set. |
Rose Zadik | 4c368e8 | 2018-04-19 14:24:11 +0100 | [diff] [blame] | 533 | * \return \c 0 for ciphers not using an IV or a nonce. |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 534 | * \return The actual size if an IV has been set. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 535 | */ |
Hanno Becker | f4fb876 | 2018-11-08 15:57:42 +0000 | [diff] [blame] | 536 | static inline int mbedtls_cipher_get_iv_size( |
| 537 | const mbedtls_cipher_context_t *ctx ) |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 538 | { |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 539 | MBEDTLS_INTERNAL_VALIDATE_RET( ctx != NULL, 0 ); |
| 540 | if( ctx->cipher_info == NULL ) |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 541 | return 0; |
| 542 | |
Manuel Pégourié-Gonnard | 9c853b9 | 2013-09-03 13:04:44 +0200 | [diff] [blame] | 543 | if( ctx->iv_size != 0 ) |
Paul Bakker | b9cfaa0 | 2013-10-11 18:58:55 +0200 | [diff] [blame] | 544 | return (int) ctx->iv_size; |
Manuel Pégourié-Gonnard | 9c853b9 | 2013-09-03 13:04:44 +0200 | [diff] [blame] | 545 | |
Manuel Pégourié-Gonnard | 46c4fa1 | 2015-08-12 09:27:55 +0200 | [diff] [blame] | 546 | return (int) ctx->cipher_info->iv_size; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 547 | } |
| 548 | |
| 549 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 550 | * \brief This function returns the type of the given cipher. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 551 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 552 | * \param ctx The context of the cipher. This must be initialized. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 553 | * |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 554 | * \return The type of the cipher. |
| 555 | * \return #MBEDTLS_CIPHER_NONE if \p ctx has not been initialized. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 556 | */ |
Hanno Becker | f4fb876 | 2018-11-08 15:57:42 +0000 | [diff] [blame] | 557 | static inline mbedtls_cipher_type_t mbedtls_cipher_get_type( |
| 558 | const mbedtls_cipher_context_t *ctx ) |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 559 | { |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 560 | MBEDTLS_INTERNAL_VALIDATE_RET( |
| 561 | ctx != NULL, MBEDTLS_CIPHER_NONE ); |
| 562 | if( ctx->cipher_info == NULL ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 563 | return MBEDTLS_CIPHER_NONE; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 564 | |
| 565 | return ctx->cipher_info->type; |
| 566 | } |
| 567 | |
| 568 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 569 | * \brief This function returns the name of the given cipher |
| 570 | * as a string. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 571 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 572 | * \param ctx The context of the cipher. This must be initialized. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 573 | * |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 574 | * \return The name of the cipher. |
| 575 | * \return NULL if \p ctx has not been not initialized. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 576 | */ |
Hanno Becker | f4fb876 | 2018-11-08 15:57:42 +0000 | [diff] [blame] | 577 | static inline const char *mbedtls_cipher_get_name( |
| 578 | const mbedtls_cipher_context_t *ctx ) |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 579 | { |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 580 | MBEDTLS_INTERNAL_VALIDATE_RET( ctx != NULL, 0 ); |
| 581 | if( ctx->cipher_info == NULL ) |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 582 | return 0; |
| 583 | |
| 584 | return ctx->cipher_info->name; |
| 585 | } |
| 586 | |
| 587 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 588 | * \brief This function returns the key length of the cipher. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 589 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 590 | * \param ctx The context of the cipher. This must be initialized. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 591 | * |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 592 | * \return The key length of the cipher in bits. |
| 593 | * \return #MBEDTLS_KEY_LENGTH_NONE if ctx \p has not been |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 594 | * initialized. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 595 | */ |
Hanno Becker | f4fb876 | 2018-11-08 15:57:42 +0000 | [diff] [blame] | 596 | static inline int mbedtls_cipher_get_key_bitlen( |
| 597 | const mbedtls_cipher_context_t *ctx ) |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 598 | { |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 599 | MBEDTLS_INTERNAL_VALIDATE_RET( |
| 600 | ctx != NULL, MBEDTLS_KEY_LENGTH_NONE ); |
| 601 | if( ctx->cipher_info == NULL ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 602 | return MBEDTLS_KEY_LENGTH_NONE; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 603 | |
Manuel Pégourié-Gonnard | 46c4fa1 | 2015-08-12 09:27:55 +0200 | [diff] [blame] | 604 | return (int) ctx->cipher_info->key_bitlen; |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 605 | } |
| 606 | |
| 607 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 608 | * \brief This function returns the operation of the given cipher. |
Paul Bakker | f7e5bb5 | 2011-11-11 10:53:37 +0000 | [diff] [blame] | 609 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 610 | * \param ctx The context of the cipher. This must be initialized. |
Paul Bakker | f7e5bb5 | 2011-11-11 10:53:37 +0000 | [diff] [blame] | 611 | * |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 612 | * \return The type of operation: #MBEDTLS_ENCRYPT or #MBEDTLS_DECRYPT. |
| 613 | * \return #MBEDTLS_OPERATION_NONE if \p ctx has not been initialized. |
Paul Bakker | f7e5bb5 | 2011-11-11 10:53:37 +0000 | [diff] [blame] | 614 | */ |
Hanno Becker | f4fb876 | 2018-11-08 15:57:42 +0000 | [diff] [blame] | 615 | static inline mbedtls_operation_t mbedtls_cipher_get_operation( |
| 616 | const mbedtls_cipher_context_t *ctx ) |
Paul Bakker | f7e5bb5 | 2011-11-11 10:53:37 +0000 | [diff] [blame] | 617 | { |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 618 | MBEDTLS_INTERNAL_VALIDATE_RET( |
| 619 | ctx != NULL, MBEDTLS_OPERATION_NONE ); |
| 620 | if( ctx->cipher_info == NULL ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 621 | return MBEDTLS_OPERATION_NONE; |
Paul Bakker | f7e5bb5 | 2011-11-11 10:53:37 +0000 | [diff] [blame] | 622 | |
| 623 | return ctx->operation; |
| 624 | } |
| 625 | |
| 626 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 627 | * \brief This function sets the key to use with the given context. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 628 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 629 | * \param ctx The generic cipher context. This must be initialized and |
| 630 | * bound to a cipher information structure. |
| 631 | * \param key The key to use. This must be a readable buffer of at |
| 632 | * least \p key_bitlen Bits. |
| 633 | * \param key_bitlen The key length to use, in Bits. |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 634 | * \param operation The operation that the key will be used for: |
| 635 | * #MBEDTLS_ENCRYPT or #MBEDTLS_DECRYPT. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 636 | * |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 637 | * \return \c 0 on success. |
Rose Zadik | 4c368e8 | 2018-04-19 14:24:11 +0100 | [diff] [blame] | 638 | * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on |
| 639 | * parameter-verification failure. |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 640 | * \return A cipher-specific error code on failure. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 641 | */ |
Hanno Becker | f4fb876 | 2018-11-08 15:57:42 +0000 | [diff] [blame] | 642 | int mbedtls_cipher_setkey( mbedtls_cipher_context_t *ctx, |
| 643 | const unsigned char *key, |
| 644 | int key_bitlen, |
| 645 | const mbedtls_operation_t operation ); |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 646 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 647 | #if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING) |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 648 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 649 | * \brief This function sets the padding mode, for cipher modes |
| 650 | * that use padding. |
Manuel Pégourié-Gonnard | d5fdcaf | 2013-07-24 18:05:00 +0200 | [diff] [blame] | 651 | * |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 652 | * The default passing mode is PKCS7 padding. |
Manuel Pégourié-Gonnard | d5fdcaf | 2013-07-24 18:05:00 +0200 | [diff] [blame] | 653 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 654 | * \param ctx The generic cipher context. This must be initialized and |
| 655 | * bound to a cipher information structure. |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 656 | * \param mode The padding mode. |
| 657 | * |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 658 | * \return \c 0 on success. |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 659 | * \return #MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE |
| 660 | * if the selected padding mode is not supported. |
| 661 | * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA if the cipher mode |
Paul Bakker | 1a45d91 | 2013-08-14 12:04:26 +0200 | [diff] [blame] | 662 | * does not support padding. |
Manuel Pégourié-Gonnard | d5fdcaf | 2013-07-24 18:05:00 +0200 | [diff] [blame] | 663 | */ |
Hanno Becker | f4fb876 | 2018-11-08 15:57:42 +0000 | [diff] [blame] | 664 | int mbedtls_cipher_set_padding_mode( mbedtls_cipher_context_t *ctx, |
| 665 | mbedtls_cipher_padding_t mode ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 666 | #endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */ |
Manuel Pégourié-Gonnard | d5fdcaf | 2013-07-24 18:05:00 +0200 | [diff] [blame] | 667 | |
| 668 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 669 | * \brief This function sets the initialization vector (IV) |
| 670 | * or nonce. |
Manuel Pégourié-Gonnard | 9c853b9 | 2013-09-03 13:04:44 +0200 | [diff] [blame] | 671 | * |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 672 | * \note Some ciphers do not use IVs nor nonce. For these |
| 673 | * ciphers, this function has no effect. |
| 674 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 675 | * \param ctx The generic cipher context. This must be initialized and |
| 676 | * bound to a cipher information structure. |
| 677 | * \param iv The IV to use, or NONCE_COUNTER for CTR-mode ciphers. This |
| 678 | * must be a readable buffer of at least \p iv_len Bytes. |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 679 | * \param iv_len The IV length for ciphers with variable-size IV. |
| 680 | * This parameter is discarded by ciphers with fixed-size IV. |
Manuel Pégourié-Gonnard | 9c853b9 | 2013-09-03 13:04:44 +0200 | [diff] [blame] | 681 | * |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 682 | * \return \c 0 on success. |
Rose Zadik | 4c368e8 | 2018-04-19 14:24:11 +0100 | [diff] [blame] | 683 | * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on |
| 684 | * parameter-verification failure. |
Manuel Pégourié-Gonnard | 9c853b9 | 2013-09-03 13:04:44 +0200 | [diff] [blame] | 685 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 686 | int mbedtls_cipher_set_iv( mbedtls_cipher_context_t *ctx, |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 687 | const unsigned char *iv, |
| 688 | size_t iv_len ); |
Manuel Pégourié-Gonnard | 9c853b9 | 2013-09-03 13:04:44 +0200 | [diff] [blame] | 689 | |
| 690 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 691 | * \brief This function resets the cipher state. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 692 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 693 | * \param ctx The generic cipher context. This must be initialized. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 694 | * |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 695 | * \return \c 0 on success. |
Rose Zadik | 4c368e8 | 2018-04-19 14:24:11 +0100 | [diff] [blame] | 696 | * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on |
| 697 | * parameter-verification failure. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 698 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 699 | int mbedtls_cipher_reset( mbedtls_cipher_context_t *ctx ); |
Manuel Pégourié-Gonnard | 2adc40c | 2013-09-03 13:54:12 +0200 | [diff] [blame] | 700 | |
Manuel Pégourié-Gonnard | dca3a5d | 2018-05-07 10:43:27 +0200 | [diff] [blame] | 701 | #if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) |
Manuel Pégourié-Gonnard | 2adc40c | 2013-09-03 13:54:12 +0200 | [diff] [blame] | 702 | /** |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 703 | * \brief This function adds additional data for AEAD ciphers. |
| 704 | * Currently supported with GCM and ChaCha20+Poly1305. |
| 705 | * This must be called exactly once, after |
| 706 | * mbedtls_cipher_reset(). |
Manuel Pégourié-Gonnard | 2adc40c | 2013-09-03 13:54:12 +0200 | [diff] [blame] | 707 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 708 | * \param ctx The generic cipher context. This must be initialized. |
| 709 | * \param ad The additional data to use. This must be a readable |
| 710 | * buffer of at least \p ad_len Bytes. |
Andrzej Kurek | 02f39ac | 2019-02-08 06:50:55 -0500 | [diff] [blame] | 711 | * \param ad_len The length of \p ad in Bytes. |
Manuel Pégourié-Gonnard | 2adc40c | 2013-09-03 13:54:12 +0200 | [diff] [blame] | 712 | * |
Andrzej Kurek | 57f04e5 | 2019-02-08 06:44:43 -0500 | [diff] [blame] | 713 | * \return \c 0 on success. |
| 714 | * \return A specific error code on failure. |
Manuel Pégourié-Gonnard | 2adc40c | 2013-09-03 13:54:12 +0200 | [diff] [blame] | 715 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 716 | int mbedtls_cipher_update_ad( mbedtls_cipher_context_t *ctx, |
Manuel Pégourié-Gonnard | 2adc40c | 2013-09-03 13:54:12 +0200 | [diff] [blame] | 717 | const unsigned char *ad, size_t ad_len ); |
Manuel Pégourié-Gonnard | dca3a5d | 2018-05-07 10:43:27 +0200 | [diff] [blame] | 718 | #endif /* MBEDTLS_GCM_C || MBEDTLS_CHACHAPOLY_C */ |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 719 | |
| 720 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 721 | * \brief The generic cipher update function. It encrypts or |
| 722 | * decrypts using the given cipher context. Writes as |
| 723 | * many block-sized blocks of data as possible to output. |
| 724 | * Any data that cannot be written immediately is either |
| 725 | * added to the next block, or flushed when |
| 726 | * mbedtls_cipher_finish() is called. |
| 727 | * Exception: For MBEDTLS_MODE_ECB, expects a single block |
| 728 | * in size. For example, 16 Bytes for AES. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 729 | * |
Rose Zadik | 4c368e8 | 2018-04-19 14:24:11 +0100 | [diff] [blame] | 730 | * \note If the underlying cipher is used in GCM mode, all calls |
| 731 | * to this function, except for the last one before |
| 732 | * mbedtls_cipher_finish(), must have \p ilen as a |
| 733 | * multiple of the block size of the cipher. |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 734 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 735 | * \param ctx The generic cipher context. This must be initialized and |
| 736 | * bound to a key. |
| 737 | * \param input The buffer holding the input data. This must be a |
| 738 | * readable buffer of at least \p ilen Bytes. |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 739 | * \param ilen The length of the input data. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 740 | * \param output The buffer for the output data. This must be able to |
| 741 | * hold at least `ilen + block_size`. This must not be the |
| 742 | * same buffer as \p input. |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 743 | * \param olen The length of the output data, to be updated with the |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 744 | * actual number of Bytes written. This must not be |
| 745 | * \c NULL. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 746 | * |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 747 | * \return \c 0 on success. |
Rose Zadik | 4c368e8 | 2018-04-19 14:24:11 +0100 | [diff] [blame] | 748 | * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on |
| 749 | * parameter-verification failure. |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 750 | * \return #MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE on an |
| 751 | * unsupported mode for a cipher. |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 752 | * \return A cipher-specific error code on failure. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 753 | */ |
Hanno Becker | f4fb876 | 2018-11-08 15:57:42 +0000 | [diff] [blame] | 754 | int mbedtls_cipher_update( mbedtls_cipher_context_t *ctx, |
| 755 | const unsigned char *input, |
| 756 | size_t ilen, unsigned char *output, |
| 757 | size_t *olen ); |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 758 | |
| 759 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 760 | * \brief The generic cipher finalization function. If data still |
| 761 | * needs to be flushed from an incomplete block, the data |
| 762 | * contained in it is padded to the size of |
| 763 | * the last block, and written to the \p output buffer. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 764 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 765 | * \param ctx The generic cipher context. This must be initialized and |
| 766 | * bound to a key. |
| 767 | * \param output The buffer to write data to. This needs to be a writable |
| 768 | * buffer of at least \p block_size Bytes. |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 769 | * \param olen The length of the data written to the \p output buffer. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 770 | * This may not be \c NULL. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 771 | * |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 772 | * \return \c 0 on success. |
Rose Zadik | 4c368e8 | 2018-04-19 14:24:11 +0100 | [diff] [blame] | 773 | * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on |
| 774 | * parameter-verification failure. |
| 775 | * \return #MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED on decryption |
| 776 | * expecting a full block but not receiving one. |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 777 | * \return #MBEDTLS_ERR_CIPHER_INVALID_PADDING on invalid padding |
| 778 | * while decrypting. |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 779 | * \return A cipher-specific error code on failure. |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 780 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 781 | int mbedtls_cipher_finish( mbedtls_cipher_context_t *ctx, |
Manuel Pégourié-Gonnard | aa9ffc5 | 2013-09-03 16:19:22 +0200 | [diff] [blame] | 782 | unsigned char *output, size_t *olen ); |
| 783 | |
Manuel Pégourié-Gonnard | dca3a5d | 2018-05-07 10:43:27 +0200 | [diff] [blame] | 784 | #if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) |
Manuel Pégourié-Gonnard | aa9ffc5 | 2013-09-03 16:19:22 +0200 | [diff] [blame] | 785 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 786 | * \brief This function writes a tag for AEAD ciphers. |
Daniel King | 8fe4701 | 2016-05-17 20:33:28 -0300 | [diff] [blame] | 787 | * Currently supported with GCM and ChaCha20+Poly1305. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 788 | * This must be called after mbedtls_cipher_finish(). |
Manuel Pégourié-Gonnard | aa9ffc5 | 2013-09-03 16:19:22 +0200 | [diff] [blame] | 789 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 790 | * \param ctx The generic cipher context. This must be initialized, |
| 791 | * bound to a key, and have just completed a cipher |
| 792 | * operation through mbedtls_cipher_finish() the tag for |
| 793 | * which should be written. |
| 794 | * \param tag The buffer to write the tag to. This must be a writable |
| 795 | * buffer of at least \p tag_len Bytes. |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 796 | * \param tag_len The length of the tag to write. |
Manuel Pégourié-Gonnard | aa9ffc5 | 2013-09-03 16:19:22 +0200 | [diff] [blame] | 797 | * |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 798 | * \return \c 0 on success. |
| 799 | * \return A specific error code on failure. |
Manuel Pégourié-Gonnard | aa9ffc5 | 2013-09-03 16:19:22 +0200 | [diff] [blame] | 800 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 801 | int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx, |
Manuel Pégourié-Gonnard | aa9ffc5 | 2013-09-03 16:19:22 +0200 | [diff] [blame] | 802 | unsigned char *tag, size_t tag_len ); |
| 803 | |
| 804 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 805 | * \brief This function checks the tag for AEAD ciphers. |
Daniel King | 8fe4701 | 2016-05-17 20:33:28 -0300 | [diff] [blame] | 806 | * Currently supported with GCM and ChaCha20+Poly1305. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 807 | * This must be called after mbedtls_cipher_finish(). |
Manuel Pégourié-Gonnard | aa9ffc5 | 2013-09-03 16:19:22 +0200 | [diff] [blame] | 808 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 809 | * \param ctx The generic cipher context. This must be initialized. |
| 810 | * \param tag The buffer holding the tag. This must be a readable |
| 811 | * buffer of at least \p tag_len Bytes. |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 812 | * \param tag_len The length of the tag to check. |
Manuel Pégourié-Gonnard | aa9ffc5 | 2013-09-03 16:19:22 +0200 | [diff] [blame] | 813 | * |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 814 | * \return \c 0 on success. |
| 815 | * \return A specific error code on failure. |
Manuel Pégourié-Gonnard | aa9ffc5 | 2013-09-03 16:19:22 +0200 | [diff] [blame] | 816 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 817 | int mbedtls_cipher_check_tag( mbedtls_cipher_context_t *ctx, |
Manuel Pégourié-Gonnard | aa9ffc5 | 2013-09-03 16:19:22 +0200 | [diff] [blame] | 818 | const unsigned char *tag, size_t tag_len ); |
Manuel Pégourié-Gonnard | dca3a5d | 2018-05-07 10:43:27 +0200 | [diff] [blame] | 819 | #endif /* MBEDTLS_GCM_C || MBEDTLS_CHACHAPOLY_C */ |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 820 | |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 821 | /** |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 822 | * \brief The generic all-in-one encryption/decryption function, |
| 823 | * for all ciphers except AEAD constructs. |
Manuel Pégourié-Gonnard | 3c1d150 | 2014-05-12 13:46:08 +0200 | [diff] [blame] | 824 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 825 | * \param ctx The generic cipher context. This must be initialized. |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 826 | * \param iv The IV to use, or NONCE_COUNTER for CTR-mode ciphers. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 827 | * This must be a readable buffer of at least \p iv_len |
| 828 | * Bytes. |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 829 | * \param iv_len The IV length for ciphers with variable-size IV. |
| 830 | * This parameter is discarded by ciphers with fixed-size |
| 831 | * IV. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 832 | * \param input The buffer holding the input data. This must be a |
| 833 | * readable buffer of at least \p ilen Bytes. |
| 834 | * \param ilen The length of the input data in Bytes. |
| 835 | * \param output The buffer for the output data. This must be able to |
| 836 | * hold at least `ilen + block_size`. This must not be the |
| 837 | * same buffer as \p input. |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 838 | * \param olen The length of the output data, to be updated with the |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 839 | * actual number of Bytes written. This must not be |
| 840 | * \c NULL. |
Manuel Pégourié-Gonnard | 3c1d150 | 2014-05-12 13:46:08 +0200 | [diff] [blame] | 841 | * |
Rose Zadik | 9ba6b62 | 2018-01-24 12:59:19 +0000 | [diff] [blame] | 842 | * \note Some ciphers do not use IVs nor nonce. For these |
| 843 | * ciphers, use \p iv = NULL and \p iv_len = 0. |
Manuel Pégourié-Gonnard | 3c1d150 | 2014-05-12 13:46:08 +0200 | [diff] [blame] | 844 | * |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 845 | * \return \c 0 on success. |
Rose Zadik | 4c368e8 | 2018-04-19 14:24:11 +0100 | [diff] [blame] | 846 | * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on |
| 847 | * parameter-verification failure. |
| 848 | * \return #MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED on decryption |
| 849 | * expecting a full block but not receiving one. |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 850 | * \return #MBEDTLS_ERR_CIPHER_INVALID_PADDING on invalid padding |
| 851 | * while decrypting. |
Rose Zadik | b5607bf | 2018-04-16 10:34:51 +0100 | [diff] [blame] | 852 | * \return A cipher-specific error code on failure. |
Manuel Pégourié-Gonnard | 3c1d150 | 2014-05-12 13:46:08 +0200 | [diff] [blame] | 853 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 854 | int mbedtls_cipher_crypt( mbedtls_cipher_context_t *ctx, |
Manuel Pégourié-Gonnard | 3c1d150 | 2014-05-12 13:46:08 +0200 | [diff] [blame] | 855 | const unsigned char *iv, size_t iv_len, |
| 856 | const unsigned char *input, size_t ilen, |
| 857 | unsigned char *output, size_t *olen ); |
| 858 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 859 | #if defined(MBEDTLS_CIPHER_MODE_AEAD) |
Manuel Pégourié-Gonnard | 513c243 | 2020-12-01 10:34:57 +0100 | [diff] [blame] | 860 | #if ! defined(MBEDTLS_DEPRECATED_REMOVED) |
| 861 | #if defined(MBEDTLS_DEPRECATED_WARNING) |
| 862 | #define MBEDTLS_DEPRECATED __attribute__((deprecated)) |
| 863 | #else |
| 864 | #define MBEDTLS_DEPRECATED |
| 865 | #endif /* MBEDTLS_DEPRECATED_WARNING */ |
Manuel Pégourié-Gonnard | 4562ffe | 2014-05-13 12:19:29 +0200 | [diff] [blame] | 866 | /** |
Manuel Pégourié-Gonnard | f2ffbc4 | 2020-12-01 09:57:55 +0100 | [diff] [blame] | 867 | * \brief The generic authenticated encryption (AEAD) function. |
| 868 | * |
Manuel Pégourié-Gonnard | 513c243 | 2020-12-01 10:34:57 +0100 | [diff] [blame] | 869 | * \deprecated Superseded by mbedtls_cipher_auth_encrypt_ext(). |
| 870 | * |
Manuel Pégourié-Gonnard | f2ffbc4 | 2020-12-01 09:57:55 +0100 | [diff] [blame] | 871 | * \note This function only supports AEAD algorithms, not key |
| 872 | * wrapping algorithms such as NIST_KW; for this, see |
| 873 | * mbedtls_cipher_auth_encrypt_ext(). |
Manuel Pégourié-Gonnard | 4562ffe | 2014-05-13 12:19:29 +0200 | [diff] [blame] | 874 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 875 | * \param ctx The generic cipher context. This must be initialized and |
Manuel Pégourié-Gonnard | f2ffbc4 | 2020-12-01 09:57:55 +0100 | [diff] [blame] | 876 | * bound to a key associated with an AEAD algorithm. |
Manuel Pégourié-Gonnard | 3ba84d5 | 2020-11-20 10:17:20 +0100 | [diff] [blame] | 877 | * \param iv The nonce to use. This must be a readable buffer of |
| 878 | * at least \p iv_len Bytes and must not be \c NULL. |
| 879 | * \param iv_len The length of the nonce. This must satisfy the |
| 880 | * constraints imposed by the AEAD cipher used. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 881 | * \param ad The additional data to authenticate. This must be a |
Manuel Pégourié-Gonnard | 3ba84d5 | 2020-11-20 10:17:20 +0100 | [diff] [blame] | 882 | * readable buffer of at least \p ad_len Bytes, and may |
| 883 | * be \c NULL is \p ad_len is \c 0. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 884 | * \param ad_len The length of \p ad. |
| 885 | * \param input The buffer holding the input data. This must be a |
Manuel Pégourié-Gonnard | 3ba84d5 | 2020-11-20 10:17:20 +0100 | [diff] [blame] | 886 | * readable buffer of at least \p ilen Bytes, and may be |
| 887 | * \c NULL if \p ilen is \c 0. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 888 | * \param ilen The length of the input data. |
Manuel Pégourié-Gonnard | 3ba84d5 | 2020-11-20 10:17:20 +0100 | [diff] [blame] | 889 | * \param output The buffer for the output data. This must be a |
| 890 | * writable buffer of at least \p ilen Bytes, and must |
| 891 | * not be \c NULL. |
| 892 | * \param olen This will be filled with the actual number of Bytes |
| 893 | * written to the \p output buffer. This must point to a |
| 894 | * writable object of type \c size_t. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 895 | * \param tag The buffer for the authentication tag. This must be a |
Manuel Pégourié-Gonnard | 3ba84d5 | 2020-11-20 10:17:20 +0100 | [diff] [blame] | 896 | * writable buffer of at least \p tag_len Bytes. See note |
| 897 | * below regarding restrictions with PSA-based contexts. |
| 898 | * \param tag_len The desired length of the authentication tag. This |
| 899 | * must match the constraints imposed by the AEAD cipher |
Manuel Pégourié-Gonnard | f2ffbc4 | 2020-12-01 09:57:55 +0100 | [diff] [blame] | 900 | * used, and in particular must not be \c 0. |
Manuel Pégourié-Gonnard | 3ba84d5 | 2020-11-20 10:17:20 +0100 | [diff] [blame] | 901 | * |
| 902 | * \note If the context is based on PSA (that is, it was set up |
| 903 | * with mbedtls_cipher_setup_psa()), then it is required |
| 904 | * that \c tag == output + ilen. That is, the tag must be |
| 905 | * appended to the ciphertext as recommended by RFC 5116. |
Manuel Pégourié-Gonnard | 4562ffe | 2014-05-13 12:19:29 +0200 | [diff] [blame] | 906 | * |
Andrzej Kurek | 246cc86 | 2019-02-05 04:40:53 -0500 | [diff] [blame] | 907 | * \return \c 0 on success. |
| 908 | * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on |
| 909 | * parameter-verification failure. |
| 910 | * \return A cipher-specific error code on failure. |
Manuel Pégourié-Gonnard | 4562ffe | 2014-05-13 12:19:29 +0200 | [diff] [blame] | 911 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 912 | int mbedtls_cipher_auth_encrypt( mbedtls_cipher_context_t *ctx, |
Manuel Pégourié-Gonnard | 4562ffe | 2014-05-13 12:19:29 +0200 | [diff] [blame] | 913 | const unsigned char *iv, size_t iv_len, |
| 914 | const unsigned char *ad, size_t ad_len, |
| 915 | const unsigned char *input, size_t ilen, |
| 916 | unsigned char *output, size_t *olen, |
Manuel Pégourié-Gonnard | 513c243 | 2020-12-01 10:34:57 +0100 | [diff] [blame] | 917 | unsigned char *tag, size_t tag_len ) |
| 918 | MBEDTLS_DEPRECATED; |
Manuel Pégourié-Gonnard | 4562ffe | 2014-05-13 12:19:29 +0200 | [diff] [blame] | 919 | |
| 920 | /** |
Manuel Pégourié-Gonnard | f2ffbc4 | 2020-12-01 09:57:55 +0100 | [diff] [blame] | 921 | * \brief The generic authenticated decryption (AEAD) function. |
| 922 | * |
Manuel Pégourié-Gonnard | 513c243 | 2020-12-01 10:34:57 +0100 | [diff] [blame] | 923 | * \deprecated Superseded by mbedtls_cipher_auth_decrypt_ext(). |
| 924 | * |
Manuel Pégourié-Gonnard | f2ffbc4 | 2020-12-01 09:57:55 +0100 | [diff] [blame] | 925 | * \note This function only supports AEAD algorithms, not key |
| 926 | * wrapping algorithms such as NIST_KW; for this, see |
Manuel Pégourié-Gonnard | 513c243 | 2020-12-01 10:34:57 +0100 | [diff] [blame] | 927 | * mbedtls_cipher_auth_decrypt_ext(). |
Manuel Pégourié-Gonnard | 4562ffe | 2014-05-13 12:19:29 +0200 | [diff] [blame] | 928 | * |
Andrzej Kurek | 246cc86 | 2019-02-05 04:40:53 -0500 | [diff] [blame] | 929 | * \note If the data is not authentic, then the output buffer |
| 930 | * is zeroed out to prevent the unauthentic plaintext being |
| 931 | * used, making this interface safer. |
Rose Zadik | 02f73a6 | 2018-03-26 18:02:32 +0100 | [diff] [blame] | 932 | * |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 933 | * \param ctx The generic cipher context. This must be initialized and |
Manuel Pégourié-Gonnard | f2ffbc4 | 2020-12-01 09:57:55 +0100 | [diff] [blame] | 934 | * bound to a key associated with an AEAD algorithm. |
Manuel Pégourié-Gonnard | 3ba84d5 | 2020-11-20 10:17:20 +0100 | [diff] [blame] | 935 | * \param iv The nonce to use. This must be a readable buffer of |
| 936 | * at least \p iv_len Bytes and must not be \c NULL. |
| 937 | * \param iv_len The length of the nonce. This must satisfy the |
| 938 | * constraints imposed by the AEAD cipher used. |
| 939 | * \param ad The additional data to authenticate. This must be a |
| 940 | * readable buffer of at least \p ad_len Bytes, and may |
| 941 | * be \c NULL is \p ad_len is \c 0. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 942 | * \param ad_len The length of \p ad. |
| 943 | * \param input The buffer holding the input data. This must be a |
Manuel Pégourié-Gonnard | 3ba84d5 | 2020-11-20 10:17:20 +0100 | [diff] [blame] | 944 | * readable buffer of at least \p ilen Bytes, and may be |
| 945 | * \c NULL if \p ilen is \c 0. |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 946 | * \param ilen The length of the input data. |
Manuel Pégourié-Gonnard | 3ba84d5 | 2020-11-20 10:17:20 +0100 | [diff] [blame] | 947 | * \param output The buffer for the output data. This must be a |
| 948 | * writable buffer of at least \p ilen Bytes, and must |
| 949 | * not be \c NULL. |
| 950 | * \param olen This will be filled with the actual number of Bytes |
| 951 | * written to the \p output buffer. This must point to a |
| 952 | * writable object of type \c size_t. |
| 953 | * \param tag The buffer for the authentication tag. This must be a |
| 954 | * readable buffer of at least \p tag_len Bytes. See note |
| 955 | * below regarding restrictions with PSA-based contexts. |
| 956 | * \param tag_len The length of the authentication tag. This must match |
| 957 | * the constraints imposed by the AEAD cipher used, and in |
| 958 | * particular must not be \c 0. |
| 959 | * |
| 960 | * \note If the context is based on PSA (that is, it was set up |
| 961 | * with mbedtls_cipher_setup_psa()), then it is required |
| 962 | * that \c tag == input + len. That is, the tag must be |
| 963 | * appended to the ciphertext as recommended by RFC 5116. |
Manuel Pégourié-Gonnard | 4562ffe | 2014-05-13 12:19:29 +0200 | [diff] [blame] | 964 | * |
Andrzej Kurek | 246cc86 | 2019-02-05 04:40:53 -0500 | [diff] [blame] | 965 | * \return \c 0 on success. |
| 966 | * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on |
| 967 | * parameter-verification failure. |
| 968 | * \return #MBEDTLS_ERR_CIPHER_AUTH_FAILED if data is not authentic. |
| 969 | * \return A cipher-specific error code on failure. |
Manuel Pégourié-Gonnard | 4562ffe | 2014-05-13 12:19:29 +0200 | [diff] [blame] | 970 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 971 | int mbedtls_cipher_auth_decrypt( mbedtls_cipher_context_t *ctx, |
Manuel Pégourié-Gonnard | 4562ffe | 2014-05-13 12:19:29 +0200 | [diff] [blame] | 972 | const unsigned char *iv, size_t iv_len, |
| 973 | const unsigned char *ad, size_t ad_len, |
| 974 | const unsigned char *input, size_t ilen, |
| 975 | unsigned char *output, size_t *olen, |
Manuel Pégourié-Gonnard | 513c243 | 2020-12-01 10:34:57 +0100 | [diff] [blame] | 976 | const unsigned char *tag, size_t tag_len ) |
| 977 | MBEDTLS_DEPRECATED; |
| 978 | #undef MBEDTLS_DEPRECATED |
| 979 | #endif /* MBEDTLS_DEPRECATED_REMOVED */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 980 | #endif /* MBEDTLS_CIPHER_MODE_AEAD */ |
Manuel Pégourié-Gonnard | 4562ffe | 2014-05-13 12:19:29 +0200 | [diff] [blame] | 981 | |
Manuel Pégourié-Gonnard | 9cc079d | 2020-11-25 12:57:47 +0100 | [diff] [blame] | 982 | #if defined(MBEDTLS_CIPHER_MODE_AEAD) || defined(MBEDTLS_NIST_KW_C) |
| 983 | /** |
Manuel Pégourié-Gonnard | f2ffbc4 | 2020-12-01 09:57:55 +0100 | [diff] [blame] | 984 | * \brief The authenticated encryption (AEAD/NIST_KW) function. |
Manuel Pégourié-Gonnard | 9cc079d | 2020-11-25 12:57:47 +0100 | [diff] [blame] | 985 | * |
| 986 | * \note For AEAD modes, the tag will be appended to the |
| 987 | * ciphertext, as recommended by RFC 5116. |
| 988 | * (NIST_KW doesn't have a separate tag.) |
| 989 | * |
| 990 | * \param ctx The generic cipher context. This must be initialized and |
Manuel Pégourié-Gonnard | f2ffbc4 | 2020-12-01 09:57:55 +0100 | [diff] [blame] | 991 | * bound to a key, with an AEAD algorithm or NIST_KW. |
Manuel Pégourié-Gonnard | 9cc079d | 2020-11-25 12:57:47 +0100 | [diff] [blame] | 992 | * \param iv The nonce to use. This must be a readable buffer of |
| 993 | * at least \p iv_len Bytes and may be \c NULL if \p |
| 994 | * iv_len is \c 0. |
Manuel Pégourié-Gonnard | b23e31d | 2020-12-07 09:57:35 +0100 | [diff] [blame] | 995 | * \param iv_len The length of the nonce. For AEAD ciphers, this must |
| 996 | * satisfy the constraints imposed by the cipher used. |
| 997 | * For NIST_KW, this must be \c 0. |
Manuel Pégourié-Gonnard | 9cc079d | 2020-11-25 12:57:47 +0100 | [diff] [blame] | 998 | * \param ad The additional data to authenticate. This must be a |
| 999 | * readable buffer of at least \p ad_len Bytes, and may |
| 1000 | * be \c NULL is \p ad_len is \c 0. |
| 1001 | * \param ad_len The length of \p ad. For NIST_KW, this must be \c 0. |
| 1002 | * \param input The buffer holding the input data. This must be a |
| 1003 | * readable buffer of at least \p ilen Bytes, and may be |
| 1004 | * \c NULL if \p ilen is \c 0. |
| 1005 | * \param ilen The length of the input data. |
| 1006 | * \param output The buffer for the output data. This must be a |
| 1007 | * writable buffer of at least \p output_len Bytes, and |
| 1008 | * must not be \c NULL. |
| 1009 | * \param output_len The length of the \p output buffer in Bytes. For AEAD |
| 1010 | * ciphers, this must be at least \p ilen + \p tag_len. |
| 1011 | * For NIST_KW, this must be at least \p ilen + 8 |
| 1012 | * (rounded up to a multiple of 8 if KWP is used); |
| 1013 | * \p ilen + 15 is always a safe value. |
| 1014 | * \param olen This will be filled with the actual number of Bytes |
| 1015 | * written to the \p output buffer. This must point to a |
| 1016 | * writable object of type \c size_t. |
| 1017 | * \param tag_len The desired length of the authentication tag. For AEAD |
| 1018 | * ciphers, this must match the constraints imposed by |
Manuel Pégourié-Gonnard | f2ffbc4 | 2020-12-01 09:57:55 +0100 | [diff] [blame] | 1019 | * the cipher used, and in particular must not be \c 0. |
Manuel Pégourié-Gonnard | 9cc079d | 2020-11-25 12:57:47 +0100 | [diff] [blame] | 1020 | * For NIST_KW, this must be \c 0. |
| 1021 | * |
| 1022 | * \return \c 0 on success. |
| 1023 | * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on |
| 1024 | * parameter-verification failure. |
| 1025 | * \return A cipher-specific error code on failure. |
| 1026 | */ |
| 1027 | int mbedtls_cipher_auth_encrypt_ext( mbedtls_cipher_context_t *ctx, |
| 1028 | const unsigned char *iv, size_t iv_len, |
| 1029 | const unsigned char *ad, size_t ad_len, |
| 1030 | const unsigned char *input, size_t ilen, |
| 1031 | unsigned char *output, size_t output_len, |
| 1032 | size_t *olen, size_t tag_len ); |
| 1033 | |
| 1034 | /** |
Manuel Pégourié-Gonnard | f2ffbc4 | 2020-12-01 09:57:55 +0100 | [diff] [blame] | 1035 | * \brief The authenticated encryption (AEAD/NIST_KW) function. |
Manuel Pégourié-Gonnard | 9cc079d | 2020-11-25 12:57:47 +0100 | [diff] [blame] | 1036 | * |
| 1037 | * \note If the data is not authentic, then the output buffer |
| 1038 | * is zeroed out to prevent the unauthentic plaintext being |
| 1039 | * used, making this interface safer. |
| 1040 | * |
| 1041 | * \note For AEAD modes, the tag must be appended to the |
| 1042 | * ciphertext, as recommended by RFC 5116. |
| 1043 | * (NIST_KW doesn't have a separate tag.) |
| 1044 | * |
| 1045 | * \param ctx The generic cipher context. This must be initialized and |
Manuel Pégourié-Gonnard | f2ffbc4 | 2020-12-01 09:57:55 +0100 | [diff] [blame] | 1046 | * bound to a key, with an AEAD algorithm or NIST_KW. |
Manuel Pégourié-Gonnard | 9cc079d | 2020-11-25 12:57:47 +0100 | [diff] [blame] | 1047 | * \param iv The nonce to use. This must be a readable buffer of |
| 1048 | * at least \p iv_len Bytes and may be \c NULL if \p |
| 1049 | * iv_len is \c 0. |
Manuel Pégourié-Gonnard | b23e31d | 2020-12-07 09:57:35 +0100 | [diff] [blame] | 1050 | * \param iv_len The length of the nonce. For AEAD ciphers, this must |
| 1051 | * satisfy the constraints imposed by the cipher used. |
| 1052 | * For NIST_KW, this must be \c 0. |
Manuel Pégourié-Gonnard | 9cc079d | 2020-11-25 12:57:47 +0100 | [diff] [blame] | 1053 | * \param ad The additional data to authenticate. This must be a |
| 1054 | * readable buffer of at least \p ad_len Bytes, and may |
| 1055 | * be \c NULL is \p ad_len is \c 0. |
| 1056 | * \param ad_len The length of \p ad. For NIST_KW, this must be \c 0. |
| 1057 | * \param input The buffer holding the input data. This must be a |
| 1058 | * readable buffer of at least \p ilen Bytes, and may be |
| 1059 | * \c NULL if \p ilen is \c 0. |
| 1060 | * \param ilen The length of the input data. For AEAD ciphers this |
| 1061 | * must be at least \p tag_len. For NIST_KW this must be |
| 1062 | * at least \c 8. |
| 1063 | * \param output The buffer for the output data. This must be a |
| 1064 | * writable buffer of at least \p output_len Bytes, and |
| 1065 | * may be \c NULL if \p output_len is \c 0. |
| 1066 | * \param output_len The length of the \p output buffer in Bytes. For AEAD |
| 1067 | * ciphers, this must be at least \p ilen - \p tag_len. |
| 1068 | * For NIST_KW, this must be at least \p ilen - 8. |
| 1069 | * \param olen This will be filled with the actual number of Bytes |
| 1070 | * written to the \p output buffer. This must point to a |
| 1071 | * writable object of type \c size_t. |
| 1072 | * \param tag_len The actual length of the authentication tag. For AEAD |
| 1073 | * ciphers, this must match the constraints imposed by |
Manuel Pégourié-Gonnard | f2ffbc4 | 2020-12-01 09:57:55 +0100 | [diff] [blame] | 1074 | * the cipher used, and in particular must not be \c 0. |
Manuel Pégourié-Gonnard | 9cc079d | 2020-11-25 12:57:47 +0100 | [diff] [blame] | 1075 | * For NIST_KW, this must be \c 0. |
| 1076 | * |
| 1077 | * \return \c 0 on success. |
| 1078 | * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on |
| 1079 | * parameter-verification failure. |
| 1080 | * \return #MBEDTLS_ERR_CIPHER_AUTH_FAILED if data is not authentic. |
| 1081 | * \return A cipher-specific error code on failure. |
| 1082 | */ |
| 1083 | int mbedtls_cipher_auth_decrypt_ext( mbedtls_cipher_context_t *ctx, |
| 1084 | const unsigned char *iv, size_t iv_len, |
| 1085 | const unsigned char *ad, size_t ad_len, |
| 1086 | const unsigned char *input, size_t ilen, |
| 1087 | unsigned char *output, size_t output_len, |
| 1088 | size_t *olen, size_t tag_len ); |
| 1089 | #endif /* MBEDTLS_CIPHER_MODE_AEAD || MBEDTLS_NIST_KW_C */ |
Paul Bakker | 8123e9d | 2011-01-06 15:37:30 +0000 | [diff] [blame] | 1090 | #ifdef __cplusplus |
| 1091 | } |
| 1092 | #endif |
| 1093 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 1094 | #endif /* MBEDTLS_CIPHER_H */ |