Home | History | Annotate | Download | only in openssl 
      1 /* Copyright (C) 1995-1998 Eric Young (eay (at) cryptsoft.com)
      2  * All rights reserved.
      3  *
      4  * This package is an SSL implementation written
      5  * by Eric Young (eay (at) cryptsoft.com).
      6  * The implementation was written so as to conform with Netscapes SSL.
      7  *
      8  * This library is free for commercial and non-commercial use as long as
      9  * the following conditions are aheared to.  The following conditions
     10  * apply to all code found in this distribution, be it the RC4, RSA,
     11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
     12  * included with this distribution is covered by the same copyright terms
     13  * except that the holder is Tim Hudson (tjh (at) cryptsoft.com).
     14  *
     15  * Copyright remains Eric Young's, and as such any Copyright notices in
     16  * the code are not to be removed.
     17  * If this package is used in a product, Eric Young should be given attribution
     18  * as the author of the parts of the library used.
     19  * This can be in the form of a textual message at program startup or
     20  * in documentation (online or textual) provided with the package.
     21  *
     22  * Redistribution and use in source and binary forms, with or without
     23  * modification, are permitted provided that the following conditions
     24  * are met:
     25  * 1. Redistributions of source code must retain the copyright
     26  *    notice, this list of conditions and the following disclaimer.
     27  * 2. Redistributions in binary form must reproduce the above copyright
     28  *    notice, this list of conditions and the following disclaimer in the
     29  *    documentation and/or other materials provided with the distribution.
     30  * 3. All advertising materials mentioning features or use of this software
     31  *    must display the following acknowledgement:
     32  *    "This product includes cryptographic software written by
     33  *     Eric Young (eay (at) cryptsoft.com)"
     34  *    The word 'cryptographic' can be left out if the rouines from the library
     35  *    being used are not cryptographic related :-).
     36  * 4. If you include any Windows specific code (or a derivative thereof) from
     37  *    the apps directory (application code) you must include an acknowledgement:
     38  *    "This product includes software written by Tim Hudson (tjh (at) cryptsoft.com)"
     39  *
     40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
     41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     50  * SUCH DAMAGE.
     51  *
     52  * The licence and distribution terms for any publically available version or
     53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
     54  * copied and put under another distribution licence
     55  * [including the GNU Public Licence.] */
     56 
     57 #ifndef OPENSSL_HEADER_CIPHER_H
     58 #define OPENSSL_HEADER_CIPHER_H
     59 
     60 #include <openssl/base.h>
     61 
     62 #if defined(__cplusplus)
     63 extern "C" {
     64 #endif
     65 
     66 
     67 /* Ciphers. */
     68 
     69 
     70 /* Cipher primitives.
     71  *
     72  * The following functions return |EVP_CIPHER| objects that implement the named
     73  * cipher algorithm. */
     74 
     75 OPENSSL_EXPORT const EVP_CIPHER *EVP_rc4(void);
     76 
     77 OPENSSL_EXPORT const EVP_CIPHER *EVP_des_cbc(void);
     78 OPENSSL_EXPORT const EVP_CIPHER *EVP_des_ede3_cbc(void);
     79 
     80 OPENSSL_EXPORT const EVP_CIPHER *EVP_aes_128_ecb(void);
     81 OPENSSL_EXPORT const EVP_CIPHER *EVP_aes_128_cbc(void);
     82 OPENSSL_EXPORT const EVP_CIPHER *EVP_aes_128_ctr(void);
     83 OPENSSL_EXPORT const EVP_CIPHER *EVP_aes_128_gcm(void);
     84 
     85 OPENSSL_EXPORT const EVP_CIPHER *EVP_aes_256_ecb(void);
     86 OPENSSL_EXPORT const EVP_CIPHER *EVP_aes_256_cbc(void);
     87 OPENSSL_EXPORT const EVP_CIPHER *EVP_aes_256_ctr(void);
     88 OPENSSL_EXPORT const EVP_CIPHER *EVP_aes_256_gcm(void);
     89 
     90 /* EVP_enc_null returns a 'cipher' that passes plaintext through as
     91  * ciphertext. */
     92 OPENSSL_EXPORT const EVP_CIPHER *EVP_enc_null(void);
     93 
     94 /* EVP_rc2_40_cbc returns a cipher that implements 40-bit RC2 in CBC mode. This
     95  * is obviously very, very weak and is included only in order to read PKCS#12
     96  * files, which often encrypt the certificate chain using this cipher. It is
     97  * deliberately not exported. */
     98 const EVP_CIPHER *EVP_rc2_40_cbc(void);
     99 
    100 /* EVP_get_cipherbynid returns the cipher corresponding to the given NID, or
    101  * NULL if no such cipher is known. */
    102 OPENSSL_EXPORT const EVP_CIPHER *EVP_get_cipherbynid(int nid);
    103 
    104 
    105 /* Cipher context allocation.
    106  *
    107  * An |EVP_CIPHER_CTX| represents the state of an encryption or decryption in
    108  * progress. */
    109 
    110 /* EVP_CIPHER_CTX_init initialises an, already allocated, |EVP_CIPHER_CTX|. */
    111 OPENSSL_EXPORT void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx);
    112 
    113 /* EVP_CIPHER_CTX_new allocates a fresh |EVP_CIPHER_CTX|, calls
    114  * |EVP_CIPHER_CTX_init| and returns it, or NULL on allocation failure. */
    115 OPENSSL_EXPORT EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void);
    116 
    117 /* EVP_CIPHER_CTX_cleanup frees any memory referenced by |ctx|. It returns one
    118  * on success and zero otherwise. */
    119 OPENSSL_EXPORT int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *ctx);
    120 
    121 /* EVP_CIPHER_CTX_free calls |EVP_CIPHER_CTX_cleanup| on |ctx| and then frees
    122  * |ctx| itself. */
    123 OPENSSL_EXPORT void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx);
    124 
    125 /* EVP_CIPHER_CTX_copy sets |out| to be a duplicate of the current state of
    126  * |in|. The |out| argument must have been previously initialised. */
    127 OPENSSL_EXPORT int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out,
    128                                        const EVP_CIPHER_CTX *in);
    129 
    130 
    131 /* Cipher context configuration. */
    132 
    133 /* EVP_CipherInit_ex configures |ctx| for a fresh encryption (or decryption, if
    134  * |enc| is zero) operation using |cipher|. If |ctx| has been previously
    135  * configured with a cipher then |cipher|, |key| and |iv| may be |NULL| and
    136  * |enc| may be -1 to reuse the previous values. The operation will use |key|
    137  * as the key and |iv| as the IV (if any). These should have the correct
    138  * lengths given by |EVP_CIPHER_key_length| and |EVP_CIPHER_iv_length|. It
    139  * returns one on success and zero on error. */
    140 OPENSSL_EXPORT int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx,
    141                                      const EVP_CIPHER *cipher, ENGINE *engine,
    142                                      const uint8_t *key, const uint8_t *iv,
    143                                      int enc);
    144 
    145 /* EVP_EncryptInit_ex calls |EVP_CipherInit_ex| with |enc| equal to one. */
    146 OPENSSL_EXPORT int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx,
    147                                       const EVP_CIPHER *cipher, ENGINE *impl,
    148                                       const uint8_t *key, const uint8_t *iv);
    149 
    150 /* EVP_DecryptInit_ex calls |EVP_CipherInit_ex| with |enc| equal to zero. */
    151 OPENSSL_EXPORT int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx,
    152                                       const EVP_CIPHER *cipher, ENGINE *impl,
    153                                       const uint8_t *key, const uint8_t *iv);
    154 
    155 
    156 /* Cipher operations. */
    157 
    158 /* EVP_EncryptUpdate encrypts |in_len| bytes from |in| to |out|. The number
    159  * of output bytes may be up to |in_len| plus the block length minus one and
    160  * |out| must have sufficient space. The number of bytes actually output is
    161  * written to |*out_len|. It returns one on success and zero otherwise. */
    162 OPENSSL_EXPORT int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, uint8_t *out,
    163                                      int *out_len, const uint8_t *in,
    164                                      int in_len);
    165 
    166 /* EVP_EncryptFinal_ex writes at most a block of ciphertext to |out| and sets
    167  * |*out_len| to the number of bytes written. If padding is enabled (the
    168  * default) then standard padding is applied to create the final block. If
    169  * padding is disabled (with |EVP_CIPHER_CTX_set_padding|) then any partial
    170  * block remaining will cause an error. The function returns one on success and
    171  * zero otherwise. */
    172 OPENSSL_EXPORT int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, uint8_t *out,
    173                                        int *out_len);
    174 
    175 /* EVP_DecryptUpdate decrypts |in_len| bytes from |in| to |out|. The number of
    176  * output bytes may be up to |in_len| plus the block length minus one and |out|
    177  * must have sufficient space. The number of bytes actually output is written
    178  * to |*out_len|. It returns one on success and zero otherwise. */
    179 OPENSSL_EXPORT int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, uint8_t *out,
    180                                      int *out_len, const uint8_t *in,
    181                                      int in_len);
    182 
    183 /* EVP_DecryptFinal_ex writes at most a block of ciphertext to |out| and sets
    184  * |*out_len| to the number of bytes written. If padding is enabled (the
    185  * default) then padding is removed from the final block.
    186  *
    187  * WARNING: it is unsafe to call this function with unauthenticted
    188  * ciphertext if padding is enabled. */
    189 OPENSSL_EXPORT int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out,
    190                                        int *out_len);
    191 
    192 /* EVP_Cipher performs a one-shot encryption/decryption operation. No partial
    193  * blocks etc are maintained between calls. It returns the number of bytes
    194  * written or -1 on error.
    195  *
    196  * WARNING: this differs from the usual return value convention. */
    197 OPENSSL_EXPORT int EVP_Cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
    198                               const uint8_t *in, size_t in_len);
    199 
    200 /* EVP_CipherUpdate calls either |EVP_EncryptUpdate| or |EVP_DecryptUpdate|
    201  * depending on how |ctx| has been setup. */
    202 OPENSSL_EXPORT int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, uint8_t *out,
    203                                     int *out_len, const uint8_t *in,
    204                                     int in_len);
    205 
    206 /* EVP_CipherFinal_ex calls either |EVP_EncryptFinal_ex| or
    207  * |EVP_DecryptFinal_ex| depending on how |ctx| has been setup. */
    208 OPENSSL_EXPORT int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, uint8_t *out,
    209                                       int *out_len);
    210 
    211 
    212 /* Cipher context accessors. */
    213 
    214 /* EVP_CIPHER_CTX_cipher returns the |EVP_CIPHER| underlying |ctx|, or NULL if
    215  * none has been set. */
    216 OPENSSL_EXPORT const EVP_CIPHER *EVP_CIPHER_CTX_cipher(
    217     const EVP_CIPHER_CTX *ctx);
    218 
    219 /* EVP_CIPHER_CTX_nid returns a NID identifying the |EVP_CIPHER| underlying
    220  * |ctx| (e.g. |NID_rc4|). It will crash if no cipher has been configured. */
    221 OPENSSL_EXPORT int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx);
    222 
    223 /* EVP_CIPHER_CTX_block_size returns the block size, in bytes, of the cipher
    224  * underlying |ctx|, or one if the cipher is a stream cipher. It will crash if
    225  * no cipher has been configured. */
    226 OPENSSL_EXPORT unsigned EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx);
    227 
    228 /* EVP_CIPHER_CTX_key_length returns the key size, in bytes, of the cipher
    229  * underlying |ctx| or zero if no cipher has been configured. */
    230 OPENSSL_EXPORT unsigned EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx);
    231 
    232 /* EVP_CIPHER_CTX_iv_length returns the IV size, in bytes, of the cipher
    233  * underlying |ctx|. It will crash if no cipher has been configured. */
    234 OPENSSL_EXPORT unsigned EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx);
    235 
    236 /* EVP_CIPHER_CTX_get_app_data returns the opaque, application data pointer for
    237  * |ctx|, or NULL if none has been set. */
    238 OPENSSL_EXPORT void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx);
    239 
    240 /* EVP_CIPHER_CTX_set_app_data sets the opaque, application data pointer for
    241  * |ctx| to |data|. */
    242 OPENSSL_EXPORT void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx,
    243                                                 void *data);
    244 
    245 /* EVP_CIPHER_CTX_flags returns a value which is the OR of zero or more
    246  * |EVP_CIPH_*| flags. It will crash if no cipher has been configured. */
    247 OPENSSL_EXPORT uint32_t EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx);
    248 
    249 /* EVP_CIPHER_CTX_mode returns one of the |EVP_CIPH_*| cipher mode values
    250  * enumerated below. It will crash if no cipher has been configured. */
    251 OPENSSL_EXPORT uint32_t EVP_CIPHER_CTX_mode(const EVP_CIPHER_CTX *ctx);
    252 
    253 /* EVP_CIPHER_CTX_ctrl is an |ioctl| like function. The |command| argument
    254  * should be one of the |EVP_CTRL_*| values. The |arg| and |ptr| arguments are
    255  * specific to the command in question. */
    256 OPENSSL_EXPORT int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int command,
    257                                        int arg, void *ptr);
    258 
    259 /* EVP_CIPHER_CTX_set_padding sets whether padding is enabled for |ctx| and
    260  * returns one. Pass a non-zero |pad| to enable padding (the default) or zero
    261  * to disable. */
    262 OPENSSL_EXPORT int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *ctx, int pad);
    263 
    264 /* EVP_CIPHER_CTX_set_key_length sets the key length for |ctx|. This is only
    265  * valid for ciphers that can take a variable length key. It returns one on
    266  * success and zero on error. */
    267 OPENSSL_EXPORT int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *ctx, unsigned key_len);
    268 
    269 
    270 /* Cipher accessors. */
    271 
    272 /* EVP_CIPHER_nid returns a NID identifing |cipher|. (For example,
    273  * |NID_rc4|.) */
    274 OPENSSL_EXPORT int EVP_CIPHER_nid(const EVP_CIPHER *cipher);
    275 
    276 /* EVP_CIPHER_name returns the short name for |cipher| or NULL if no name is
    277  * known. */
    278 OPENSSL_EXPORT const char *EVP_CIPHER_name(const EVP_CIPHER *cipher);
    279 
    280 /* EVP_CIPHER_block_size returns the block size, in bytes, for |cipher|, or one
    281  * if |cipher| is a stream cipher. */
    282 OPENSSL_EXPORT unsigned EVP_CIPHER_block_size(const EVP_CIPHER *cipher);
    283 
    284 /* EVP_CIPHER_key_length returns the key size, in bytes, for |cipher|. If
    285  * |cipher| can take a variable key length then this function returns the
    286  * default key length and |EVP_CIPHER_flags| will return a value with
    287  * |EVP_CIPH_VARIABLE_LENGTH| set. */
    288 OPENSSL_EXPORT unsigned EVP_CIPHER_key_length(const EVP_CIPHER *cipher);
    289 
    290 /* EVP_CIPHER_iv_length returns the IV size, in bytes, of |cipher|, or zero if
    291  * |cipher| doesn't take an IV. */
    292 OPENSSL_EXPORT unsigned EVP_CIPHER_iv_length(const EVP_CIPHER *cipher);
    293 
    294 /* EVP_CIPHER_flags returns a value which is the OR of zero or more
    295  * |EVP_CIPH_*| flags. */
    296 OPENSSL_EXPORT uint32_t EVP_CIPHER_flags(const EVP_CIPHER *cipher);
    297 
    298 /* EVP_CIPHER_mode returns one of the cipher mode values enumerated below. */
    299 OPENSSL_EXPORT uint32_t EVP_CIPHER_mode(const EVP_CIPHER *cipher);
    300 
    301 
    302 /* Key derivation. */
    303 
    304 /* EVP_BytesToKey generates a key and IV for the cipher |type| by iterating
    305  * |md| |count| times using |data| and |salt|. On entry, the |key| and |iv|
    306  * buffers must have enough space to hold a key and IV for |type|. It returns
    307  * the length of the key on success or zero on error. */
    308 OPENSSL_EXPORT int EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md,
    309                                   const uint8_t *salt, const uint8_t *data,
    310                                   size_t data_len, unsigned count, uint8_t *key,
    311                                   uint8_t *iv);
    312 
    313 
    314 /* Cipher modes (for |EVP_CIPHER_mode|). */
    315 
    316 #define EVP_CIPH_STREAM_CIPHER 0x0
    317 #define EVP_CIPH_ECB_MODE 0x1
    318 #define EVP_CIPH_CBC_MODE 0x2
    319 #define EVP_CIPH_CFB_MODE 0x3
    320 #define EVP_CIPH_OFB_MODE 0x4
    321 #define EVP_CIPH_CTR_MODE 0x5
    322 #define EVP_CIPH_GCM_MODE 0x6
    323 
    324 
    325 /* Cipher flags (for |EVP_CIPHER_flags|). */
    326 
    327 /* EVP_CIPH_VARIABLE_LENGTH indicates that the cipher takes a variable length
    328  * key. */
    329 #define EVP_CIPH_VARIABLE_LENGTH 0x40
    330 
    331 /* EVP_CIPH_ALWAYS_CALL_INIT indicates that the |init| function for the cipher
    332  * should always be called when initialising a new operation, even if the key
    333  * is NULL to indicate that the same key is being used. */
    334 #define EVP_CIPH_ALWAYS_CALL_INIT 0x80
    335 
    336 /* EVP_CIPH_CUSTOM_IV indicates that the cipher manages the IV itself rather
    337  * than keeping it in the |iv| member of |EVP_CIPHER_CTX|. */
    338 #define EVP_CIPH_CUSTOM_IV 0x100
    339 
    340 /* EVP_CIPH_CTRL_INIT indicates that EVP_CTRL_INIT should be used when
    341  * initialising an |EVP_CIPHER_CTX|. */
    342 #define EVP_CIPH_CTRL_INIT 0x200
    343 
    344 /* EVP_CIPH_FLAG_CUSTOM_CIPHER indicates that the cipher manages blocking
    345  * itself. This causes EVP_(En|De)crypt_ex to be simple wrapper functions. */
    346 #define EVP_CIPH_FLAG_CUSTOM_CIPHER 0x400
    347 
    348 /* EVP_CIPH_FLAG_AEAD_CIPHER specifies that the cipher is an AEAD. This is an
    349  * older version of the proper AEAD interface. See aead.h for the current
    350  * one. */
    351 #define EVP_CIPH_FLAG_AEAD_CIPHER 0x800
    352 
    353 /* EVP_CIPH_CUSTOM_COPY indicates that the |ctrl| callback should be called
    354  * with |EVP_CTRL_COPY| at the end of normal |EVP_CIPHER_CTX_copy|
    355  * processing. */
    356 #define EVP_CIPH_CUSTOM_COPY 0x1000
    357 
    358 
    359 /* Private functions. */
    360 
    361 /* EVP_CIPH_NO_PADDING disables padding in block ciphers. */
    362 #define EVP_CIPH_NO_PADDING 0x800
    363 
    364 /* EVP_CIPHER_CTX_ctrl commands. */
    365 #define EVP_CTRL_INIT 0x0
    366 #define EVP_CTRL_SET_KEY_LENGTH 0x1
    367 #define EVP_CTRL_GET_RC2_KEY_BITS 0x2
    368 #define EVP_CTRL_SET_RC2_KEY_BITS 0x3
    369 #define EVP_CTRL_GET_RC5_ROUNDS 0x4
    370 #define EVP_CTRL_SET_RC5_ROUNDS 0x5
    371 #define EVP_CTRL_RAND_KEY 0x6
    372 #define EVP_CTRL_PBE_PRF_NID 0x7
    373 #define EVP_CTRL_COPY 0x8
    374 #define EVP_CTRL_GCM_SET_IVLEN 0x9
    375 #define EVP_CTRL_GCM_GET_TAG 0x10
    376 #define EVP_CTRL_GCM_SET_TAG 0x11
    377 #define EVP_CTRL_GCM_SET_IV_FIXED 0x12
    378 #define EVP_CTRL_GCM_IV_GEN 0x13
    379 #define EVP_CTRL_AEAD_SET_MAC_KEY 0x17
    380 /* Set the GCM invocation field, decrypt only */
    381 #define EVP_CTRL_GCM_SET_IV_INV 0x18
    382 
    383 /* GCM TLS constants */
    384 /* Length of fixed part of IV derived from PRF */
    385 #define EVP_GCM_TLS_FIXED_IV_LEN 4
    386 /* Length of explicit part of IV part of TLS records */
    387 #define EVP_GCM_TLS_EXPLICIT_IV_LEN 8
    388 /* Length of tag for TLS */
    389 #define EVP_GCM_TLS_TAG_LEN 16
    390 
    391 #define EVP_MAX_KEY_LENGTH 64
    392 #define EVP_MAX_IV_LENGTH 16
    393 #define EVP_MAX_BLOCK_LENGTH 32
    394 
    395 struct evp_cipher_ctx_st {
    396   /* cipher contains the underlying cipher for this context. */
    397   const EVP_CIPHER *cipher;
    398 
    399   /* app_data is a pointer to opaque, user data. */
    400   void *app_data;      /* application stuff */
    401 
    402   /* cipher_data points to the |cipher| specific state. */
    403   void *cipher_data;
    404 
    405   /* key_len contains the length of the key, which may differ from
    406    * |cipher->key_len| if the cipher can take a variable key length. */
    407   unsigned key_len;
    408 
    409   /* encrypt is one if encrypting and zero if decrypting. */
    410   int encrypt;
    411 
    412   /* flags contains the OR of zero or more |EVP_CIPH_*| flags, above. */
    413   uint32_t flags;
    414 
    415   /* oiv contains the original IV value. */
    416   uint8_t oiv[EVP_MAX_IV_LENGTH];
    417 
    418   /* iv contains the current IV value, which may have been updated. */
    419   uint8_t iv[EVP_MAX_IV_LENGTH];
    420 
    421   /* buf contains a partial block which is used by, for example, CTR mode to
    422    * store unused keystream bytes. */
    423   uint8_t buf[EVP_MAX_BLOCK_LENGTH];
    424 
    425   /* buf_len contains the number of bytes of a partial block contained in
    426    * |buf|. */
    427   int buf_len;
    428 
    429   /* num contains the number of bytes of |iv| which are valid for modes that
    430    * manage partial blocks themselves. */
    431   int num;
    432 
    433   /* final_used is non-zero if the |final| buffer contains plaintext. */
    434   int final_used;
    435 
    436   /* block_mask contains |cipher->block_size| minus one. (The block size
    437    * assumed to be a power of two.) */
    438   int block_mask;
    439 
    440   uint8_t final[EVP_MAX_BLOCK_LENGTH]; /* possible final block */
    441 } /* EVP_CIPHER_CTX */;
    442 
    443 typedef struct evp_cipher_info_st {
    444   const EVP_CIPHER *cipher;
    445   unsigned char iv[EVP_MAX_IV_LENGTH];
    446 } EVP_CIPHER_INFO;
    447 
    448 
    449 #if defined(__cplusplus)
    450 }  /* extern C */
    451 #endif
    452 
    453 #define CIPHER_F_EVP_CipherInit_ex 100
    454 #define CIPHER_F_EVP_EncryptFinal_ex 101
    455 #define CIPHER_F_EVP_DecryptFinal_ex 102
    456 #define CIPHER_F_EVP_CIPHER_CTX_ctrl 103
    457 #define CIPHER_F_aes_init_key 104
    458 #define CIPHER_F_aesni_init_key 105
    459 #define CIPHER_F_EVP_CIPHER_CTX_copy 106
    460 #define CIPHER_F_EVP_AEAD_CTX_open 107
    461 #define CIPHER_F_EVP_AEAD_CTX_init 108
    462 #define CIPHER_F_EVP_AEAD_CTX_seal 109
    463 #define CIPHER_F_aead_aes_gcm_seal 110
    464 #define CIPHER_F_aead_aes_gcm_open 111
    465 #define CIPHER_F_aead_aes_gcm_init 112
    466 #define CIPHER_F_aead_chacha20_poly1305_init 113
    467 #define CIPHER_F_aead_chacha20_poly1305_open 114
    468 #define CIPHER_F_aead_chacha20_poly1305_seal 115
    469 #define CIPHER_F_aead_rc4_md5_tls_init 116
    470 #define CIPHER_F_aead_rc4_md5_tls_seal 117
    471 #define CIPHER_F_aead_rc4_md5_tls_open 118
    472 #define CIPHER_F_aead_aes_key_wrap_seal 119
    473 #define CIPHER_F_aead_aes_key_wrap_init 120
    474 #define CIPHER_F_aead_aes_key_wrap_open 121
    475 #define CIPHER_F_EVP_CIPHER_CTX_set_key_length 122
    476 #define CIPHER_R_WRAP_MODE_NOT_ALLOWED 100
    477 #define CIPHER_R_AES_KEY_SETUP_FAILED 101
    478 #define CIPHER_R_INPUT_NOT_INITIALIZED 102
    479 #define CIPHER_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH 103
    480 #define CIPHER_R_INITIALIZATION_ERROR 104
    481 #define CIPHER_R_CTRL_NOT_IMPLEMENTED 105
    482 #define CIPHER_R_NO_CIPHER_SET 106
    483 #define CIPHER_R_BAD_DECRYPT 107
    484 #define CIPHER_R_WRONG_FINAL_BLOCK_LENGTH 108
    485 #define CIPHER_R_CTRL_OPERATION_NOT_IMPLEMENTED 109
    486 #define CIPHER_R_TAG_TOO_LARGE 110
    487 #define CIPHER_R_BAD_KEY_LENGTH 111
    488 #define CIPHER_R_BUFFER_TOO_SMALL 112
    489 #define CIPHER_R_OUTPUT_ALIASES_INPUT 113
    490 #define CIPHER_R_UNSUPPORTED_KEY_SIZE 114
    491 #define CIPHER_R_TOO_LARGE 115
    492 #define CIPHER_R_IV_TOO_LARGE 116
    493 #define CIPHER_R_INVALID_AD_SIZE 117
    494 #define CIPHER_R_INVALID_AD 118
    495 #define CIPHER_R_UNSUPPORTED_TAG_SIZE 119
    496 #define CIPHER_R_UNSUPPORTED_INPUT_SIZE 120
    497 #define CIPHER_R_UNSUPPORTED_AD_SIZE 121
    498 #define CIPHER_R_UNSUPPORTED_NONCE_SIZE 122
    499 #define CIPHER_R_INVALID_KEY_LENGTH 123
    500 
    501 #endif  /* OPENSSL_HEADER_CIPHER_H */
    502