crypto/evp/e_aes.c

   1 /*
   2  * Copyright 2001-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <openssl/opensslconf.h>
  11 #include <openssl/crypto.h>
  12 #include <openssl/evp.h>
  13 #include <openssl/err.h>
  14 #include <string.h>
  15 #include <assert.h>
  16 #include <openssl/aes.h>
  17 #include "internal/evp_int.h"
  18 #include "modes_lcl.h"
  19 #include <openssl/rand.h>
  20
  21 typedef struct {
  22     union {
  23         double align;
  24         AES_KEY ks;
  25     } ks;
  26     block128_f block;
  27     union {
  28         cbc128_f cbc;
  29         ctr128_f ctr;
  30     } stream;
  31 } EVP_AES_KEY;
  32
  33 typedef struct {
  34     union {
  35         double align;
  36         AES_KEY ks;
  37     } ks;                       /* AES key schedule to use */
  38     int key_set;                /* Set if key initialised */
  39     int iv_set;                 /* Set if an iv is set */
  40     GCM128_CONTEXT gcm;
  41     unsigned char *iv;          /* Temporary IV store */
  42     int ivlen;                  /* IV length */
  43     int taglen;
  44     int iv_gen;                 /* It is OK to generate IVs */
  45     int tls_aad_len;            /* TLS AAD length */
  46     ctr128_f ctr;
  47 } EVP_AES_GCM_CTX;
  48
  49 typedef struct {
  50     union {
  51         double align;
  52         AES_KEY ks;
  53     } ks1, ks2;                 /* AES key schedules to use */
  54     XTS128_CONTEXT xts;
  55     void (*stream) (const unsigned char *in,
  56                     unsigned char *out, size_t length,
  57                     const AES_KEY *key1, const AES_KEY *key2,
  58                     const unsigned char iv[16]);
  59 } EVP_AES_XTS_CTX;
  60
  61 typedef struct {
  62     union {
  63         double align;
  64         AES_KEY ks;
  65     } ks;                       /* AES key schedule to use */
  66     int key_set;                /* Set if key initialised */
  67     int iv_set;                 /* Set if an iv is set */
  68     int tag_set;                /* Set if tag is valid */
  69     int len_set;                /* Set if message length set */
  70     int L, M;                   /* L and M parameters from RFC3610 */
  71     int tls_aad_len;            /* TLS AAD length */
  72     CCM128_CONTEXT ccm;
  73     ccm128_f str;
  74 } EVP_AES_CCM_CTX;
  75
  76 #ifndef OPENSSL_NO_OCB
  77 typedef struct {
  78     union {
  79         double align;
  80         AES_KEY ks;
  81     } ksenc;                    /* AES key schedule to use for encryption */
  82     union {
  83         double align;
  84         AES_KEY ks;
  85     } ksdec;                    /* AES key schedule to use for decryption */
  86     int key_set;                /* Set if key initialised */
  87     int iv_set;                 /* Set if an iv is set */
  88     OCB128_CONTEXT ocb;
  89     unsigned char *iv;          /* Temporary IV store */
  90     unsigned char tag[16];
  91     unsigned char data_buf[16]; /* Store partial data blocks */
  92     unsigned char aad_buf[16];  /* Store partial AAD blocks */
  93     int data_buf_len;
  94     int aad_buf_len;
  95     int ivlen;                  /* IV length */
  96     int taglen;
  97 } EVP_AES_OCB_CTX;
  98 #endif
  99
 100 #define MAXBITCHUNK     ((size_t)1<<(sizeof(size_t)*8-4))
 101
 102 #ifdef VPAES_ASM
 103 int vpaes_set_encrypt_key(const unsigned char *userKey, int bits,
 104                           AES_KEY *key);
 105 int vpaes_set_decrypt_key(const unsigned char *userKey, int bits,
 106                           AES_KEY *key);
 107
 108 void vpaes_encrypt(const unsigned char *in, unsigned char *out,
 109                    const AES_KEY *key);
 110 void vpaes_decrypt(const unsigned char *in, unsigned char *out,
 111                    const AES_KEY *key);
 112
 113 void vpaes_cbc_encrypt(const unsigned char *in,
 114                        unsigned char *out,
 115                        size_t length,
 116                        const AES_KEY *key, unsigned char *ivec, int enc);
 117 #endif
 118 #ifdef BSAES_ASM
 119 void bsaes_cbc_encrypt(const unsigned char *in, unsigned char *out,
 120                        size_t length, const AES_KEY *key,
 121                        unsigned char ivec[16], int enc);
 122 void bsaes_ctr32_encrypt_blocks(const unsigned char *in, unsigned char *out,
 123                                 size_t len, const AES_KEY *key,
 124                                 const unsigned char ivec[16]);
 125 void bsaes_xts_encrypt(const unsigned char *inp, unsigned char *out,
 126                        size_t len, const AES_KEY *key1,
 127                        const AES_KEY *key2, const unsigned char iv[16]);
 128 void bsaes_xts_decrypt(const unsigned char *inp, unsigned char *out,
 129                        size_t len, const AES_KEY *key1,
 130                        const AES_KEY *key2, const unsigned char iv[16]);
 131 #endif
 132 #ifdef AES_CTR_ASM
 133 void AES_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 134                        size_t blocks, const AES_KEY *key,
 135                        const unsigned char ivec[AES_BLOCK_SIZE]);
 136 #endif
 137 #ifdef AES_XTS_ASM
 138 void AES_xts_encrypt(const char *inp, char *out, size_t len,
 139                      const AES_KEY *key1, const AES_KEY *key2,
 140                      const unsigned char iv[16]);
 141 void AES_xts_decrypt(const char *inp, char *out, size_t len,
 142                      const AES_KEY *key1, const AES_KEY *key2,
 143                      const unsigned char iv[16]);
 144 #endif
 145
 146 #if defined(OPENSSL_CPUID_OBJ) && (defined(__powerpc__) || defined(__ppc__) || defined(_ARCH_PPC))
 147 # include "ppc_arch.h"
 148 # ifdef VPAES_ASM
 149 #  define VPAES_CAPABLE (OPENSSL_ppccap_P & PPC_ALTIVEC)
 150 # endif
 151 # define HWAES_CAPABLE  (OPENSSL_ppccap_P & PPC_CRYPTO207)
 152 # define HWAES_set_encrypt_key aes_p8_set_encrypt_key
 153 # define HWAES_set_decrypt_key aes_p8_set_decrypt_key
 154 # define HWAES_encrypt aes_p8_encrypt
 155 # define HWAES_decrypt aes_p8_decrypt
 156 # define HWAES_cbc_encrypt aes_p8_cbc_encrypt
 157 # define HWAES_ctr32_encrypt_blocks aes_p8_ctr32_encrypt_blocks
 158 # define HWAES_xts_encrypt aes_p8_xts_encrypt
 159 # define HWAES_xts_decrypt aes_p8_xts_decrypt
 160 #endif
 161
 162 #if     defined(AES_ASM) && !defined(I386_ONLY) &&      (  \
 163         ((defined(__i386)       || defined(__i386__)    || \
 164           defined(_M_IX86)) && defined(OPENSSL_IA32_SSE2))|| \
 165         defined(__x86_64)       || defined(__x86_64__)  || \
 166         defined(_M_AMD64)       || defined(_M_X64)      )
 167
 168 extern unsigned int OPENSSL_ia32cap_P[];
 169
 170 # ifdef VPAES_ASM
 171 #  define VPAES_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(41-32)))
 172 # endif
 173 # ifdef BSAES_ASM
 174 #  define BSAES_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(41-32)))
 175 # endif
 176 /*
 177  * AES-NI section
 178  */
 179 # define AESNI_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(57-32)))
 180
 181 int aesni_set_encrypt_key(const unsigned char *userKey, int bits,
 182                           AES_KEY *key);
 183 int aesni_set_decrypt_key(const unsigned char *userKey, int bits,
 184                           AES_KEY *key);
 185
 186 void aesni_encrypt(const unsigned char *in, unsigned char *out,
 187                    const AES_KEY *key);
 188 void aesni_decrypt(const unsigned char *in, unsigned char *out,
 189                    const AES_KEY *key);
 190
 191 void aesni_ecb_encrypt(const unsigned char *in,
 192                        unsigned char *out,
 193                        size_t length, const AES_KEY *key, int enc);
 194 void aesni_cbc_encrypt(const unsigned char *in,
 195                        unsigned char *out,
 196                        size_t length,
 197                        const AES_KEY *key, unsigned char *ivec, int enc);
 198
 199 void aesni_ctr32_encrypt_blocks(const unsigned char *in,
 200                                 unsigned char *out,
 201                                 size_t blocks,
 202                                 const void *key, const unsigned char *ivec);
 203
 204 void aesni_xts_encrypt(const unsigned char *in,
 205                        unsigned char *out,
 206                        size_t length,
 207                        const AES_KEY *key1, const AES_KEY *key2,
 208                        const unsigned char iv[16]);
 209
 210 void aesni_xts_decrypt(const unsigned char *in,
 211                        unsigned char *out,
 212                        size_t length,
 213                        const AES_KEY *key1, const AES_KEY *key2,
 214                        const unsigned char iv[16]);
 215
 216 void aesni_ccm64_encrypt_blocks(const unsigned char *in,
 217                                 unsigned char *out,
 218                                 size_t blocks,
 219                                 const void *key,
 220                                 const unsigned char ivec[16],
 221                                 unsigned char cmac[16]);
 222
 223 void aesni_ccm64_decrypt_blocks(const unsigned char *in,
 224                                 unsigned char *out,
 225                                 size_t blocks,
 226                                 const void *key,
 227                                 const unsigned char ivec[16],
 228                                 unsigned char cmac[16]);
 229
 230 # if defined(__x86_64) || defined(__x86_64__) || defined(_M_AMD64) || defined(_M_X64)
 231 size_t aesni_gcm_encrypt(const unsigned char *in,
 232                          unsigned char *out,
 233                          size_t len,
 234                          const void *key, unsigned char ivec[16], u64 *Xi);
 235 #  define AES_gcm_encrypt aesni_gcm_encrypt
 236 size_t aesni_gcm_decrypt(const unsigned char *in,
 237                          unsigned char *out,
 238                          size_t len,
 239                          const void *key, unsigned char ivec[16], u64 *Xi);
 240 #  define AES_gcm_decrypt aesni_gcm_decrypt
 241 void gcm_ghash_avx(u64 Xi[2], const u128 Htable[16], const u8 *in,
 242                    size_t len);
 243 #  define AES_GCM_ASM(gctx)       (gctx->ctr==aesni_ctr32_encrypt_blocks && \
 244                                  gctx->gcm.ghash==gcm_ghash_avx)
 245 #  define AES_GCM_ASM2(gctx)      (gctx->gcm.block==(block128_f)aesni_encrypt && \
 246                                  gctx->gcm.ghash==gcm_ghash_avx)
 247 #  undef AES_GCM_ASM2          /* minor size optimization */
 248 # endif
 249
 250 static int aesni_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 251                           const unsigned char *iv, int enc)
 252 {
 253     int ret, mode;
 254     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
 255
 256     mode = EVP_CIPHER_CTX_mode(ctx);
 257     if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
 258         && !enc) {
 259         ret = aesni_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 260                                     &dat->ks.ks);
 261         dat->block = (block128_f) aesni_decrypt;
 262         dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 263             (cbc128_f) aesni_cbc_encrypt : NULL;
 264     } else {
 265         ret = aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 266                                     &dat->ks.ks);
 267         dat->block = (block128_f) aesni_encrypt;
 268         if (mode == EVP_CIPH_CBC_MODE)
 269             dat->stream.cbc = (cbc128_f) aesni_cbc_encrypt;
 270         else if (mode == EVP_CIPH_CTR_MODE)
 271             dat->stream.ctr = (ctr128_f) aesni_ctr32_encrypt_blocks;
 272         else
 273             dat->stream.cbc = NULL;
 274     }
 275
 276     if (ret < 0) {
 277         EVPerr(EVP_F_AESNI_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
 278         return 0;
 279     }
 280
 281     return 1;
 282 }
 283
 284 static int aesni_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 285                             const unsigned char *in, size_t len)
 286 {
 287     aesni_cbc_encrypt(in, out, len, &EVP_C_DATA(EVP_AES_KEY,ctx)->ks.ks,
 288                       EVP_CIPHER_CTX_iv_noconst(ctx),
 289                       EVP_CIPHER_CTX_encrypting(ctx));
 290
 291     return 1;
 292 }
 293
 294 static int aesni_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 295                             const unsigned char *in, size_t len)
 296 {
 297     size_t bl = EVP_CIPHER_CTX_block_size(ctx);
 298
 299     if (len < bl)
 300         return 1;
 301
 302     aesni_ecb_encrypt(in, out, len, &EVP_C_DATA(EVP_AES_KEY,ctx)->ks.ks,
 303                       EVP_CIPHER_CTX_encrypting(ctx));
 304
 305     return 1;
 306 }
 307
 308 # define aesni_ofb_cipher aes_ofb_cipher
 309 static int aesni_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 310                             const unsigned char *in, size_t len);
 311
 312 # define aesni_cfb_cipher aes_cfb_cipher
 313 static int aesni_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 314                             const unsigned char *in, size_t len);
 315
 316 # define aesni_cfb8_cipher aes_cfb8_cipher
 317 static int aesni_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 318                              const unsigned char *in, size_t len);
 319
 320 # define aesni_cfb1_cipher aes_cfb1_cipher
 321 static int aesni_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 322                              const unsigned char *in, size_t len);
 323
 324 # define aesni_ctr_cipher aes_ctr_cipher
 325 static int aesni_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 326                             const unsigned char *in, size_t len);
 327
 328 static int aesni_gcm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 329                               const unsigned char *iv, int enc)
 330 {
 331     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,ctx);
 332     if (!iv && !key)
 333         return 1;
 334     if (key) {
 335         aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 336                               &gctx->ks.ks);
 337         CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks, (block128_f) aesni_encrypt);
 338         gctx->ctr = (ctr128_f) aesni_ctr32_encrypt_blocks;
 339         /*
 340          * If we have an iv can set it directly, otherwise use saved IV.
 341          */
 342         if (iv == NULL && gctx->iv_set)
 343             iv = gctx->iv;
 344         if (iv) {
 345             CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 346             gctx->iv_set = 1;
 347         }
 348         gctx->key_set = 1;
 349     } else {
 350         /* If key set use IV, otherwise copy */
 351         if (gctx->key_set)
 352             CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 353         else
 354             memcpy(gctx->iv, iv, gctx->ivlen);
 355         gctx->iv_set = 1;
 356         gctx->iv_gen = 0;
 357     }
 358     return 1;
 359 }
 360
 361 # define aesni_gcm_cipher aes_gcm_cipher
 362 static int aesni_gcm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 363                             const unsigned char *in, size_t len);
 364
 365 static int aesni_xts_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 366                               const unsigned char *iv, int enc)
 367 {
 368     EVP_AES_XTS_CTX *xctx = EVP_C_DATA(EVP_AES_XTS_CTX,ctx);
 369     if (!iv && !key)
 370         return 1;
 371
 372     if (key) {
 373         /* key_len is two AES keys */
 374         if (enc) {
 375             aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 4,
 376                                   &xctx->ks1.ks);
 377             xctx->xts.block1 = (block128_f) aesni_encrypt;
 378             xctx->stream = aesni_xts_encrypt;
 379         } else {
 380             aesni_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 4,
 381                                   &xctx->ks1.ks);
 382             xctx->xts.block1 = (block128_f) aesni_decrypt;
 383             xctx->stream = aesni_xts_decrypt;
 384         }
 385
 386         aesni_set_encrypt_key(key + EVP_CIPHER_CTX_key_length(ctx) / 2,
 387                               EVP_CIPHER_CTX_key_length(ctx) * 4,
 388                               &xctx->ks2.ks);
 389         xctx->xts.block2 = (block128_f) aesni_encrypt;
 390
 391         xctx->xts.key1 = &xctx->ks1;
 392     }
 393
 394     if (iv) {
 395         xctx->xts.key2 = &xctx->ks2;
 396         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 16);
 397     }
 398
 399     return 1;
 400 }
 401
 402 # define aesni_xts_cipher aes_xts_cipher
 403 static int aesni_xts_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 404                             const unsigned char *in, size_t len);
 405
 406 static int aesni_ccm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 407                               const unsigned char *iv, int enc)
 408 {
 409     EVP_AES_CCM_CTX *cctx = EVP_C_DATA(EVP_AES_CCM_CTX,ctx);
 410     if (!iv && !key)
 411         return 1;
 412     if (key) {
 413         aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 414                               &cctx->ks.ks);
 415         CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
 416                            &cctx->ks, (block128_f) aesni_encrypt);
 417         cctx->str = enc ? (ccm128_f) aesni_ccm64_encrypt_blocks :
 418             (ccm128_f) aesni_ccm64_decrypt_blocks;
 419         cctx->key_set = 1;
 420     }
 421     if (iv) {
 422         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 15 - cctx->L);
 423         cctx->iv_set = 1;
 424     }
 425     return 1;
 426 }
 427
 428 # define aesni_ccm_cipher aes_ccm_cipher
 429 static int aesni_ccm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 430                             const unsigned char *in, size_t len);
 431
 432 # ifndef OPENSSL_NO_OCB
 433 void aesni_ocb_encrypt(const unsigned char *in, unsigned char *out,
 434                        size_t blocks, const void *key,
 435                        size_t start_block_num,
 436                        unsigned char offset_i[16],
 437                        const unsigned char L_[][16],
 438                        unsigned char checksum[16]);
 439 void aesni_ocb_decrypt(const unsigned char *in, unsigned char *out,
 440                        size_t blocks, const void *key,
 441                        size_t start_block_num,
 442                        unsigned char offset_i[16],
 443                        const unsigned char L_[][16],
 444                        unsigned char checksum[16]);
 445
 446 static int aesni_ocb_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 447                               const unsigned char *iv, int enc)
 448 {
 449     EVP_AES_OCB_CTX *octx = EVP_C_DATA(EVP_AES_OCB_CTX,ctx);
 450     if (!iv && !key)
 451         return 1;
 452     if (key) {
 453         do {
 454             /*
 455              * We set both the encrypt and decrypt key here because decrypt
 456              * needs both. We could possibly optimise to remove setting the
 457              * decrypt for an encryption operation.
 458              */
 459             aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 460                                   &octx->ksenc.ks);
 461             aesni_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 462                                   &octx->ksdec.ks);
 463             if (!CRYPTO_ocb128_init(&octx->ocb,
 464                                     &octx->ksenc.ks, &octx->ksdec.ks,
 465                                     (block128_f) aesni_encrypt,
 466                                     (block128_f) aesni_decrypt,
 467                                     enc ? aesni_ocb_encrypt
 468                                         : aesni_ocb_decrypt))
 469                 return 0;
 470         }
 471         while (0);
 472
 473         /*
 474          * If we have an iv we can set it directly, otherwise use saved IV.
 475          */
 476         if (iv == NULL && octx->iv_set)
 477             iv = octx->iv;
 478         if (iv) {
 479             if (CRYPTO_ocb128_setiv(&octx->ocb, iv, octx->ivlen, octx->taglen)
 480                 != 1)
 481                 return 0;
 482             octx->iv_set = 1;
 483         }
 484         octx->key_set = 1;
 485     } else {
 486         /* If key set use IV, otherwise copy */
 487         if (octx->key_set)
 488             CRYPTO_ocb128_setiv(&octx->ocb, iv, octx->ivlen, octx->taglen);
 489         else
 490             memcpy(octx->iv, iv, octx->ivlen);
 491         octx->iv_set = 1;
 492     }
 493     return 1;
 494 }
 495
 496 #  define aesni_ocb_cipher aes_ocb_cipher
 497 static int aesni_ocb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 498                             const unsigned char *in, size_t len);
 499 # endif                        /* OPENSSL_NO_OCB */
 500
 501 # define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \
 502 static const EVP_CIPHER aesni_##keylen##_##mode = { \
 503         nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \
 504         flags|EVP_CIPH_##MODE##_MODE,   \
 505         aesni_init_key,                 \
 506         aesni_##mode##_cipher,          \
 507         NULL,                           \
 508         sizeof(EVP_AES_KEY),            \
 509         NULL,NULL,NULL,NULL }; \
 510 static const EVP_CIPHER aes_##keylen##_##mode = { \
 511         nid##_##keylen##_##nmode,blocksize,     \
 512         keylen/8,ivlen, \
 513         flags|EVP_CIPH_##MODE##_MODE,   \
 514         aes_init_key,                   \
 515         aes_##mode##_cipher,            \
 516         NULL,                           \
 517         sizeof(EVP_AES_KEY),            \
 518         NULL,NULL,NULL,NULL }; \
 519 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 520 { return AESNI_CAPABLE?&aesni_##keylen##_##mode:&aes_##keylen##_##mode; }
 521
 522 # define BLOCK_CIPHER_custom(nid,keylen,blocksize,ivlen,mode,MODE,flags) \
 523 static const EVP_CIPHER aesni_##keylen##_##mode = { \
 524         nid##_##keylen##_##mode,blocksize, \
 525         (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE?2:1)*keylen/8, ivlen, \
 526         flags|EVP_CIPH_##MODE##_MODE,   \
 527         aesni_##mode##_init_key,        \
 528         aesni_##mode##_cipher,          \
 529         aes_##mode##_cleanup,           \
 530         sizeof(EVP_AES_##MODE##_CTX),   \
 531         NULL,NULL,aes_##mode##_ctrl,NULL }; \
 532 static const EVP_CIPHER aes_##keylen##_##mode = { \
 533         nid##_##keylen##_##mode,blocksize, \
 534         (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE?2:1)*keylen/8, ivlen, \
 535         flags|EVP_CIPH_##MODE##_MODE,   \
 536         aes_##mode##_init_key,          \
 537         aes_##mode##_cipher,            \
 538         aes_##mode##_cleanup,           \
 539         sizeof(EVP_AES_##MODE##_CTX),   \
 540         NULL,NULL,aes_##mode##_ctrl,NULL }; \
 541 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 542 { return AESNI_CAPABLE?&aesni_##keylen##_##mode:&aes_##keylen##_##mode; }
 543
 544 #elif   defined(AES_ASM) && (defined(__sparc) || defined(__sparc__))
 545
 546 # include "sparc_arch.h"
 547
 548 extern unsigned int OPENSSL_sparcv9cap_P[];
 549
 550 /*
 551  * Initial Fujitsu SPARC64 X support
 552  */
 553 # define HWAES_CAPABLE           (OPENSSL_sparcv9cap_P[0] & SPARCV9_FJAESX)
 554 # define HWAES_set_encrypt_key aes_fx_set_encrypt_key
 555 # define HWAES_set_decrypt_key aes_fx_set_decrypt_key
 556 # define HWAES_encrypt aes_fx_encrypt
 557 # define HWAES_decrypt aes_fx_decrypt
 558
 559 # define SPARC_AES_CAPABLE       (OPENSSL_sparcv9cap_P[1] & CFR_AES)
 560
 561 void aes_t4_set_encrypt_key(const unsigned char *key, int bits, AES_KEY *ks);
 562 void aes_t4_set_decrypt_key(const unsigned char *key, int bits, AES_KEY *ks);
 563 void aes_t4_encrypt(const unsigned char *in, unsigned char *out,
 564                     const AES_KEY *key);
 565 void aes_t4_decrypt(const unsigned char *in, unsigned char *out,
 566                     const AES_KEY *key);
 567 /*
 568  * Key-length specific subroutines were chosen for following reason.
 569  * Each SPARC T4 core can execute up to 8 threads which share core's
 570  * resources. Loading as much key material to registers allows to
 571  * minimize references to shared memory interface, as well as amount
 572  * of instructions in inner loops [much needed on T4]. But then having
 573  * non-key-length specific routines would require conditional branches
 574  * either in inner loops or on subroutines' entries. Former is hardly
 575  * acceptable, while latter means code size increase to size occupied
 576  * by multiple key-length specific subroutines, so why fight?
 577  */
 578 void aes128_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
 579                            size_t len, const AES_KEY *key,
 580                            unsigned char *ivec);
 581 void aes128_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
 582                            size_t len, const AES_KEY *key,
 583                            unsigned char *ivec);
 584 void aes192_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
 585                            size_t len, const AES_KEY *key,
 586                            unsigned char *ivec);
 587 void aes192_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
 588                            size_t len, const AES_KEY *key,
 589                            unsigned char *ivec);
 590 void aes256_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
 591                            size_t len, const AES_KEY *key,
 592                            unsigned char *ivec);
 593 void aes256_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
 594                            size_t len, const AES_KEY *key,
 595                            unsigned char *ivec);
 596 void aes128_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 597                              size_t blocks, const AES_KEY *key,
 598                              unsigned char *ivec);
 599 void aes192_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 600                              size_t blocks, const AES_KEY *key,
 601                              unsigned char *ivec);
 602 void aes256_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 603                              size_t blocks, const AES_KEY *key,
 604                              unsigned char *ivec);
 605 void aes128_t4_xts_encrypt(const unsigned char *in, unsigned char *out,
 606                            size_t blocks, const AES_KEY *key1,
 607                            const AES_KEY *key2, const unsigned char *ivec);
 608 void aes128_t4_xts_decrypt(const unsigned char *in, unsigned char *out,
 609                            size_t blocks, const AES_KEY *key1,
 610                            const AES_KEY *key2, const unsigned char *ivec);
 611 void aes256_t4_xts_encrypt(const unsigned char *in, unsigned char *out,
 612                            size_t blocks, const AES_KEY *key1,
 613                            const AES_KEY *key2, const unsigned char *ivec);
 614 void aes256_t4_xts_decrypt(const unsigned char *in, unsigned char *out,
 615                            size_t blocks, const AES_KEY *key1,
 616                            const AES_KEY *key2, const unsigned char *ivec);
 617
 618 static int aes_t4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 619                            const unsigned char *iv, int enc)
 620 {
 621     int ret, mode, bits;
 622     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
 623
 624     mode = EVP_CIPHER_CTX_mode(ctx);
 625     bits = EVP_CIPHER_CTX_key_length(ctx) * 8;
 626     if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
 627         && !enc) {
 628         ret = 0;
 629         aes_t4_set_decrypt_key(key, bits, &dat->ks.ks);
 630         dat->block = (block128_f) aes_t4_decrypt;
 631         switch (bits) {
 632         case 128:
 633             dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 634                 (cbc128_f) aes128_t4_cbc_decrypt : NULL;
 635             break;
 636         case 192:
 637             dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 638                 (cbc128_f) aes192_t4_cbc_decrypt : NULL;
 639             break;
 640         case 256:
 641             dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 642                 (cbc128_f) aes256_t4_cbc_decrypt : NULL;
 643             break;
 644         default:
 645             ret = -1;
 646         }
 647     } else {
 648         ret = 0;
 649         aes_t4_set_encrypt_key(key, bits, &dat->ks.ks);
 650         dat->block = (block128_f) aes_t4_encrypt;
 651         switch (bits) {
 652         case 128:
 653             if (mode == EVP_CIPH_CBC_MODE)
 654                 dat->stream.cbc = (cbc128_f) aes128_t4_cbc_encrypt;
 655             else if (mode == EVP_CIPH_CTR_MODE)
 656                 dat->stream.ctr = (ctr128_f) aes128_t4_ctr32_encrypt;
 657             else
 658                 dat->stream.cbc = NULL;
 659             break;
 660         case 192:
 661             if (mode == EVP_CIPH_CBC_MODE)
 662                 dat->stream.cbc = (cbc128_f) aes192_t4_cbc_encrypt;
 663             else if (mode == EVP_CIPH_CTR_MODE)
 664                 dat->stream.ctr = (ctr128_f) aes192_t4_ctr32_encrypt;
 665             else
 666                 dat->stream.cbc = NULL;
 667             break;
 668         case 256:
 669             if (mode == EVP_CIPH_CBC_MODE)
 670                 dat->stream.cbc = (cbc128_f) aes256_t4_cbc_encrypt;
 671             else if (mode == EVP_CIPH_CTR_MODE)
 672                 dat->stream.ctr = (ctr128_f) aes256_t4_ctr32_encrypt;
 673             else
 674                 dat->stream.cbc = NULL;
 675             break;
 676         default:
 677             ret = -1;
 678         }
 679     }
 680
 681     if (ret < 0) {
 682         EVPerr(EVP_F_AES_T4_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
 683         return 0;
 684     }
 685
 686     return 1;
 687 }
 688
 689 # define aes_t4_cbc_cipher aes_cbc_cipher
 690 static int aes_t4_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 691                              const unsigned char *in, size_t len);
 692
 693 # define aes_t4_ecb_cipher aes_ecb_cipher
 694 static int aes_t4_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 695                              const unsigned char *in, size_t len);
 696
 697 # define aes_t4_ofb_cipher aes_ofb_cipher
 698 static int aes_t4_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 699                              const unsigned char *in, size_t len);
 700
 701 # define aes_t4_cfb_cipher aes_cfb_cipher
 702 static int aes_t4_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 703                              const unsigned char *in, size_t len);
 704
 705 # define aes_t4_cfb8_cipher aes_cfb8_cipher
 706 static int aes_t4_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 707                               const unsigned char *in, size_t len);
 708
 709 # define aes_t4_cfb1_cipher aes_cfb1_cipher
 710 static int aes_t4_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 711                               const unsigned char *in, size_t len);
 712
 713 # define aes_t4_ctr_cipher aes_ctr_cipher
 714 static int aes_t4_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 715                              const unsigned char *in, size_t len);
 716
 717 static int aes_t4_gcm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 718                                const unsigned char *iv, int enc)
 719 {
 720     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,ctx);
 721     if (!iv && !key)
 722         return 1;
 723     if (key) {
 724         int bits = EVP_CIPHER_CTX_key_length(ctx) * 8;
 725         aes_t4_set_encrypt_key(key, bits, &gctx->ks.ks);
 726         CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
 727                            (block128_f) aes_t4_encrypt);
 728         switch (bits) {
 729         case 128:
 730             gctx->ctr = (ctr128_f) aes128_t4_ctr32_encrypt;
 731             break;
 732         case 192:
 733             gctx->ctr = (ctr128_f) aes192_t4_ctr32_encrypt;
 734             break;
 735         case 256:
 736             gctx->ctr = (ctr128_f) aes256_t4_ctr32_encrypt;
 737             break;
 738         default:
 739             return 0;
 740         }
 741         /*
 742          * If we have an iv can set it directly, otherwise use saved IV.
 743          */
 744         if (iv == NULL && gctx->iv_set)
 745             iv = gctx->iv;
 746         if (iv) {
 747             CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 748             gctx->iv_set = 1;
 749         }
 750         gctx->key_set = 1;
 751     } else {
 752         /* If key set use IV, otherwise copy */
 753         if (gctx->key_set)
 754             CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 755         else
 756             memcpy(gctx->iv, iv, gctx->ivlen);
 757         gctx->iv_set = 1;
 758         gctx->iv_gen = 0;
 759     }
 760     return 1;
 761 }
 762
 763 # define aes_t4_gcm_cipher aes_gcm_cipher
 764 static int aes_t4_gcm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 765                              const unsigned char *in, size_t len);
 766
 767 static int aes_t4_xts_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 768                                const unsigned char *iv, int enc)
 769 {
 770     EVP_AES_XTS_CTX *xctx = EVP_C_DATA(EVP_AES_XTS_CTX,ctx);
 771     if (!iv && !key)
 772         return 1;
 773
 774     if (key) {
 775         int bits = EVP_CIPHER_CTX_key_length(ctx) * 4;
 776         xctx->stream = NULL;
 777         /* key_len is two AES keys */
 778         if (enc) {
 779             aes_t4_set_encrypt_key(key, bits, &xctx->ks1.ks);
 780             xctx->xts.block1 = (block128_f) aes_t4_encrypt;
 781             switch (bits) {
 782             case 128:
 783                 xctx->stream = aes128_t4_xts_encrypt;
 784                 break;
 785             case 256:
 786                 xctx->stream = aes256_t4_xts_encrypt;
 787                 break;
 788             default:
 789                 return 0;
 790             }
 791         } else {
 792             aes_t4_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 4,
 793                                    &xctx->ks1.ks);
 794             xctx->xts.block1 = (block128_f) aes_t4_decrypt;
 795             switch (bits) {
 796             case 128:
 797                 xctx->stream = aes128_t4_xts_decrypt;
 798                 break;
 799             case 256:
 800                 xctx->stream = aes256_t4_xts_decrypt;
 801                 break;
 802             default:
 803                 return 0;
 804             }
 805         }
 806
 807         aes_t4_set_encrypt_key(key + EVP_CIPHER_CTX_key_length(ctx) / 2,
 808                                EVP_CIPHER_CTX_key_length(ctx) * 4,
 809                                &xctx->ks2.ks);
 810         xctx->xts.block2 = (block128_f) aes_t4_encrypt;
 811
 812         xctx->xts.key1 = &xctx->ks1;
 813     }
 814
 815     if (iv) {
 816         xctx->xts.key2 = &xctx->ks2;
 817         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 16);
 818     }
 819
 820     return 1;
 821 }
 822
 823 # define aes_t4_xts_cipher aes_xts_cipher
 824 static int aes_t4_xts_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 825                              const unsigned char *in, size_t len);
 826
 827 static int aes_t4_ccm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 828                                const unsigned char *iv, int enc)
 829 {
 830     EVP_AES_CCM_CTX *cctx = EVP_C_DATA(EVP_AES_CCM_CTX,ctx);
 831     if (!iv && !key)
 832         return 1;
 833     if (key) {
 834         int bits = EVP_CIPHER_CTX_key_length(ctx) * 8;
 835         aes_t4_set_encrypt_key(key, bits, &cctx->ks.ks);
 836         CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
 837                            &cctx->ks, (block128_f) aes_t4_encrypt);
 838         cctx->str = NULL;
 839         cctx->key_set = 1;
 840     }
 841     if (iv) {
 842         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 15 - cctx->L);
 843         cctx->iv_set = 1;
 844     }
 845     return 1;
 846 }
 847
 848 # define aes_t4_ccm_cipher aes_ccm_cipher
 849 static int aes_t4_ccm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 850                              const unsigned char *in, size_t len);
 851
 852 # ifndef OPENSSL_NO_OCB
 853 static int aes_t4_ocb_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 854                                const unsigned char *iv, int enc)
 855 {
 856     EVP_AES_OCB_CTX *octx = EVP_C_DATA(EVP_AES_OCB_CTX,ctx);
 857     if (!iv && !key)
 858         return 1;
 859     if (key) {
 860         do {
 861             /*
 862              * We set both the encrypt and decrypt key here because decrypt
 863              * needs both. We could possibly optimise to remove setting the
 864              * decrypt for an encryption operation.
 865              */
 866             aes_t4_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 867                                    &octx->ksenc.ks);
 868             aes_t4_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 869                                    &octx->ksdec.ks);
 870             if (!CRYPTO_ocb128_init(&octx->ocb,
 871                                     &octx->ksenc.ks, &octx->ksdec.ks,
 872                                     (block128_f) aes_t4_encrypt,
 873                                     (block128_f) aes_t4_decrypt,
 874                                     NULL))
 875                 return 0;
 876         }
 877         while (0);
 878
 879         /*
 880          * If we have an iv we can set it directly, otherwise use saved IV.
 881          */
 882         if (iv == NULL && octx->iv_set)
 883             iv = octx->iv;
 884         if (iv) {
 885             if (CRYPTO_ocb128_setiv(&octx->ocb, iv, octx->ivlen, octx->taglen)
 886                 != 1)
 887                 return 0;
 888             octx->iv_set = 1;
 889         }
 890         octx->key_set = 1;
 891     } else {
 892         /* If key set use IV, otherwise copy */
 893         if (octx->key_set)
 894             CRYPTO_ocb128_setiv(&octx->ocb, iv, octx->ivlen, octx->taglen);
 895         else
 896             memcpy(octx->iv, iv, octx->ivlen);
 897         octx->iv_set = 1;
 898     }
 899     return 1;
 900 }
 901
 902 #  define aes_t4_ocb_cipher aes_ocb_cipher
 903 static int aes_t4_ocb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 904                              const unsigned char *in, size_t len);
 905 # endif                        /* OPENSSL_NO_OCB */
 906
 907 # define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \
 908 static const EVP_CIPHER aes_t4_##keylen##_##mode = { \
 909         nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \
 910         flags|EVP_CIPH_##MODE##_MODE,   \
 911         aes_t4_init_key,                \
 912         aes_t4_##mode##_cipher,         \
 913         NULL,                           \
 914         sizeof(EVP_AES_KEY),            \
 915         NULL,NULL,NULL,NULL }; \
 916 static const EVP_CIPHER aes_##keylen##_##mode = { \
 917         nid##_##keylen##_##nmode,blocksize,     \
 918         keylen/8,ivlen, \
 919         flags|EVP_CIPH_##MODE##_MODE,   \
 920         aes_init_key,                   \
 921         aes_##mode##_cipher,            \
 922         NULL,                           \
 923         sizeof(EVP_AES_KEY),            \
 924         NULL,NULL,NULL,NULL }; \
 925 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 926 { return SPARC_AES_CAPABLE?&aes_t4_##keylen##_##mode:&aes_##keylen##_##mode; }
 927
 928 # define BLOCK_CIPHER_custom(nid,keylen,blocksize,ivlen,mode,MODE,flags) \
 929 static const EVP_CIPHER aes_t4_##keylen##_##mode = { \
 930         nid##_##keylen##_##mode,blocksize, \
 931         (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE?2:1)*keylen/8, ivlen, \
 932         flags|EVP_CIPH_##MODE##_MODE,   \
 933         aes_t4_##mode##_init_key,       \
 934         aes_t4_##mode##_cipher,         \
 935         aes_##mode##_cleanup,           \
 936         sizeof(EVP_AES_##MODE##_CTX),   \
 937         NULL,NULL,aes_##mode##_ctrl,NULL }; \
 938 static const EVP_CIPHER aes_##keylen##_##mode = { \
 939         nid##_##keylen##_##mode,blocksize, \
 940         (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE?2:1)*keylen/8, ivlen, \
 941         flags|EVP_CIPH_##MODE##_MODE,   \
 942         aes_##mode##_init_key,          \
 943         aes_##mode##_cipher,            \
 944         aes_##mode##_cleanup,           \
 945         sizeof(EVP_AES_##MODE##_CTX),   \
 946         NULL,NULL,aes_##mode##_ctrl,NULL }; \
 947 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 948 { return SPARC_AES_CAPABLE?&aes_t4_##keylen##_##mode:&aes_##keylen##_##mode; }
 949
 950 #else
 951
 952 # define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \
 953 static const EVP_CIPHER aes_##keylen##_##mode = { \
 954         nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \
 955         flags|EVP_CIPH_##MODE##_MODE,   \
 956         aes_init_key,                   \
 957         aes_##mode##_cipher,            \
 958         NULL,                           \
 959         sizeof(EVP_AES_KEY),            \
 960         NULL,NULL,NULL,NULL }; \
 961 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 962 { return &aes_##keylen##_##mode; }
 963
 964 # define BLOCK_CIPHER_custom(nid,keylen,blocksize,ivlen,mode,MODE,flags) \
 965 static const EVP_CIPHER aes_##keylen##_##mode = { \
 966         nid##_##keylen##_##mode,blocksize, \
 967         (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE?2:1)*keylen/8, ivlen, \
 968         flags|EVP_CIPH_##MODE##_MODE,   \
 969         aes_##mode##_init_key,          \
 970         aes_##mode##_cipher,            \
 971         aes_##mode##_cleanup,           \
 972         sizeof(EVP_AES_##MODE##_CTX),   \
 973         NULL,NULL,aes_##mode##_ctrl,NULL }; \
 974 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 975 { return &aes_##keylen##_##mode; }
 976
 977 #endif
 978
 979 #if defined(OPENSSL_CPUID_OBJ) && (defined(__arm__) || defined(__arm) || defined(__aarch64__))
 980 # include "arm_arch.h"
 981 # if __ARM_MAX_ARCH__>=7
 982 #  if defined(BSAES_ASM)
 983 #   define BSAES_CAPABLE (OPENSSL_armcap_P & ARMV7_NEON)
 984 #  endif
 985 #  if defined(VPAES_ASM)
 986 #   define VPAES_CAPABLE (OPENSSL_armcap_P & ARMV7_NEON)
 987 #  endif
 988 #  define HWAES_CAPABLE (OPENSSL_armcap_P & ARMV8_AES)
 989 #  define HWAES_set_encrypt_key aes_v8_set_encrypt_key
 990 #  define HWAES_set_decrypt_key aes_v8_set_decrypt_key
 991 #  define HWAES_encrypt aes_v8_encrypt
 992 #  define HWAES_decrypt aes_v8_decrypt
 993 #  define HWAES_cbc_encrypt aes_v8_cbc_encrypt
 994 #  define HWAES_ctr32_encrypt_blocks aes_v8_ctr32_encrypt_blocks
 995 # endif
 996 #endif
 997
 998 #if defined(HWAES_CAPABLE)
 999 int HWAES_set_encrypt_key(const unsigned char *userKey, const int bits,
1000                           AES_KEY *key);
1001 int HWAES_set_decrypt_key(const unsigned char *userKey, const int bits,
1002                           AES_KEY *key);
1003 void HWAES_encrypt(const unsigned char *in, unsigned char *out,
1004                    const AES_KEY *key);
1005 void HWAES_decrypt(const unsigned char *in, unsigned char *out,
1006                    const AES_KEY *key);
1007 void HWAES_cbc_encrypt(const unsigned char *in, unsigned char *out,
1008                        size_t length, const AES_KEY *key,
1009                        unsigned char *ivec, const int enc);
1010 void HWAES_ctr32_encrypt_blocks(const unsigned char *in, unsigned char *out,
1011                                 size_t len, const AES_KEY *key,
1012                                 const unsigned char ivec[16]);
1013 void HWAES_xts_encrypt(const unsigned char *inp, unsigned char *out,
1014                        size_t len, const AES_KEY *key1,
1015                        const AES_KEY *key2, const unsigned char iv[16]);
1016 void HWAES_xts_decrypt(const unsigned char *inp, unsigned char *out,
1017                        size_t len, const AES_KEY *key1,
1018                        const AES_KEY *key2, const unsigned char iv[16]);
1019 #endif
1020
1021 #define BLOCK_CIPHER_generic_pack(nid,keylen,flags)             \
1022         BLOCK_CIPHER_generic(nid,keylen,16,16,cbc,cbc,CBC,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)     \
1023         BLOCK_CIPHER_generic(nid,keylen,16,0,ecb,ecb,ECB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)      \
1024         BLOCK_CIPHER_generic(nid,keylen,1,16,ofb128,ofb,OFB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)   \
1025         BLOCK_CIPHER_generic(nid,keylen,1,16,cfb128,cfb,CFB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)   \
1026         BLOCK_CIPHER_generic(nid,keylen,1,16,cfb1,cfb1,CFB,flags)       \
1027         BLOCK_CIPHER_generic(nid,keylen,1,16,cfb8,cfb8,CFB,flags)       \
1028         BLOCK_CIPHER_generic(nid,keylen,1,16,ctr,ctr,CTR,flags)
1029
1030 static int aes_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
1031                         const unsigned char *iv, int enc)
1032 {
1033     int ret, mode;
1034     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
1035
1036     mode = EVP_CIPHER_CTX_mode(ctx);
1037     if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
1038         && !enc) {
1039 #ifdef HWAES_CAPABLE
1040         if (HWAES_CAPABLE) {
1041             ret = HWAES_set_decrypt_key(key,
1042                                         EVP_CIPHER_CTX_key_length(ctx) * 8,
1043                                         &dat->ks.ks);
1044             dat->block = (block128_f) HWAES_decrypt;
1045             dat->stream.cbc = NULL;
1046 # ifdef HWAES_cbc_encrypt
1047             if (mode == EVP_CIPH_CBC_MODE)
1048                 dat->stream.cbc = (cbc128_f) HWAES_cbc_encrypt;
1049 # endif
1050         } else
1051 #endif
1052 #ifdef BSAES_CAPABLE
1053         if (BSAES_CAPABLE && mode == EVP_CIPH_CBC_MODE) {
1054             ret = AES_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
1055                                       &dat->ks.ks);
1056             dat->block = (block128_f) AES_decrypt;
1057             dat->stream.cbc = (cbc128_f) bsaes_cbc_encrypt;
1058         } else
1059 #endif
1060 #ifdef VPAES_CAPABLE
1061         if (VPAES_CAPABLE) {
1062             ret = vpaes_set_decrypt_key(key,
1063                                         EVP_CIPHER_CTX_key_length(ctx) * 8,
1064                                         &dat->ks.ks);
1065             dat->block = (block128_f) vpaes_decrypt;
1066             dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
1067                 (cbc128_f) vpaes_cbc_encrypt : NULL;
1068         } else
1069 #endif
1070         {
1071             ret = AES_set_decrypt_key(key,
1072                                       EVP_CIPHER_CTX_key_length(ctx) * 8,
1073                                       &dat->ks.ks);
1074             dat->block = (block128_f) AES_decrypt;
1075             dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
1076                 (cbc128_f) AES_cbc_encrypt : NULL;
1077         }
1078     } else
1079 #ifdef HWAES_CAPABLE
1080     if (HWAES_CAPABLE) {
1081         ret = HWAES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
1082                                     &dat->ks.ks);
1083         dat->block = (block128_f) HWAES_encrypt;
1084         dat->stream.cbc = NULL;
1085 # ifdef HWAES_cbc_encrypt
1086         if (mode == EVP_CIPH_CBC_MODE)
1087             dat->stream.cbc = (cbc128_f) HWAES_cbc_encrypt;
1088         else
1089 # endif
1090 # ifdef HWAES_ctr32_encrypt_blocks
1091         if (mode == EVP_CIPH_CTR_MODE)
1092             dat->stream.ctr = (ctr128_f) HWAES_ctr32_encrypt_blocks;
1093         else
1094 # endif
1095             (void)0;            /* terminate potentially open 'else' */
1096     } else
1097 #endif
1098 #ifdef BSAES_CAPABLE
1099     if (BSAES_CAPABLE && mode == EVP_CIPH_CTR_MODE) {
1100         ret = AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
1101                                   &dat->ks.ks);
1102         dat->block = (block128_f) AES_encrypt;
1103         dat->stream.ctr = (ctr128_f) bsaes_ctr32_encrypt_blocks;
1104     } else
1105 #endif
1106 #ifdef VPAES_CAPABLE
1107     if (VPAES_CAPABLE) {
1108         ret = vpaes_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
1109                                     &dat->ks.ks);
1110         dat->block = (block128_f) vpaes_encrypt;
1111         dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
1112             (cbc128_f) vpaes_cbc_encrypt : NULL;
1113     } else
1114 #endif
1115     {
1116         ret = AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
1117                                   &dat->ks.ks);
1118         dat->block = (block128_f) AES_encrypt;
1119         dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
1120             (cbc128_f) AES_cbc_encrypt : NULL;
1121 #ifdef AES_CTR_ASM
1122         if (mode == EVP_CIPH_CTR_MODE)
1123             dat->stream.ctr = (ctr128_f) AES_ctr32_encrypt;
1124 #endif
1125     }
1126
1127     if (ret < 0) {
1128         EVPerr(EVP_F_AES_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
1129         return 0;
1130     }
1131
1132     return 1;
1133 }
1134
1135 static int aes_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1136                           const unsigned char *in, size_t len)
1137 {
1138     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
1139
1140     if (dat->stream.cbc)
1141         (*dat->stream.cbc) (in, out, len, &dat->ks,
1142                             EVP_CIPHER_CTX_iv_noconst(ctx),
1143                             EVP_CIPHER_CTX_encrypting(ctx));
1144     else if (EVP_CIPHER_CTX_encrypting(ctx))
1145         CRYPTO_cbc128_encrypt(in, out, len, &dat->ks,
1146                               EVP_CIPHER_CTX_iv_noconst(ctx), dat->block);
1147     else
1148         CRYPTO_cbc128_decrypt(in, out, len, &dat->ks,
1149                               EVP_CIPHER_CTX_iv_noconst(ctx), dat->block);
1150
1151     return 1;
1152 }
1153
1154 static int aes_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1155                           const unsigned char *in, size_t len)
1156 {
1157     size_t bl = EVP_CIPHER_CTX_block_size(ctx);
1158     size_t i;
1159     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
1160
1161     if (len < bl)
1162         return 1;
1163
1164     for (i = 0, len -= bl; i <= len; i += bl)
1165         (*dat->block) (in + i, out + i, &dat->ks);
1166
1167     return 1;
1168 }
1169
1170 static int aes_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1171                           const unsigned char *in, size_t len)
1172 {
1173     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
1174
1175     int num = EVP_CIPHER_CTX_num(ctx);
1176     CRYPTO_ofb128_encrypt(in, out, len, &dat->ks,
1177                           EVP_CIPHER_CTX_iv_noconst(ctx), &num, dat->block);
1178     EVP_CIPHER_CTX_set_num(ctx, num);
1179     return 1;
1180 }
1181
1182 static int aes_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1183                           const unsigned char *in, size_t len)
1184 {
1185     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
1186
1187     int num = EVP_CIPHER_CTX_num(ctx);
1188     CRYPTO_cfb128_encrypt(in, out, len, &dat->ks,
1189                           EVP_CIPHER_CTX_iv_noconst(ctx), &num,
1190                           EVP_CIPHER_CTX_encrypting(ctx), dat->block);
1191     EVP_CIPHER_CTX_set_num(ctx, num);
1192     return 1;
1193 }
1194
1195 static int aes_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1196                            const unsigned char *in, size_t len)
1197 {
1198     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
1199
1200     int num = EVP_CIPHER_CTX_num(ctx);
1201     CRYPTO_cfb128_8_encrypt(in, out, len, &dat->ks,
1202                             EVP_CIPHER_CTX_iv_noconst(ctx), &num,
1203                             EVP_CIPHER_CTX_encrypting(ctx), dat->block);
1204     EVP_CIPHER_CTX_set_num(ctx, num);
1205     return 1;
1206 }
1207
1208 static int aes_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1209                            const unsigned char *in, size_t len)
1210 {
1211     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
1212
1213     if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS)) {
1214         int num = EVP_CIPHER_CTX_num(ctx);
1215         CRYPTO_cfb128_1_encrypt(in, out, len, &dat->ks,
1216                                 EVP_CIPHER_CTX_iv_noconst(ctx), &num,
1217                                 EVP_CIPHER_CTX_encrypting(ctx), dat->block);
1218         EVP_CIPHER_CTX_set_num(ctx, num);
1219         return 1;
1220     }
1221
1222     while (len >= MAXBITCHUNK) {
1223         int num = EVP_CIPHER_CTX_num(ctx);
1224         CRYPTO_cfb128_1_encrypt(in, out, MAXBITCHUNK * 8, &dat->ks,
1225                                 EVP_CIPHER_CTX_iv_noconst(ctx), &num,
1226                                 EVP_CIPHER_CTX_encrypting(ctx), dat->block);
1227         EVP_CIPHER_CTX_set_num(ctx, num);
1228         len -= MAXBITCHUNK;
1229     }
1230     if (len) {
1231         int num = EVP_CIPHER_CTX_num(ctx);
1232         CRYPTO_cfb128_1_encrypt(in, out, len * 8, &dat->ks,
1233                                 EVP_CIPHER_CTX_iv_noconst(ctx), &num,
1234                                 EVP_CIPHER_CTX_encrypting(ctx), dat->block);
1235         EVP_CIPHER_CTX_set_num(ctx, num);
1236     }
1237
1238     return 1;
1239 }
1240
1241 static int aes_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1242                           const unsigned char *in, size_t len)
1243 {
1244     unsigned int num = EVP_CIPHER_CTX_num(ctx);
1245     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
1246
1247     if (dat->stream.ctr)
1248         CRYPTO_ctr128_encrypt_ctr32(in, out, len, &dat->ks,
1249                                     EVP_CIPHER_CTX_iv_noconst(ctx),
1250                                     EVP_CIPHER_CTX_buf_noconst(ctx),
1251                                     &num, dat->stream.ctr);
1252     else
1253         CRYPTO_ctr128_encrypt(in, out, len, &dat->ks,
1254                               EVP_CIPHER_CTX_iv_noconst(ctx),
1255                               EVP_CIPHER_CTX_buf_noconst(ctx), &num,
1256                               dat->block);
1257     EVP_CIPHER_CTX_set_num(ctx, num);
1258     return 1;
1259 }
1260
1261 BLOCK_CIPHER_generic_pack(NID_aes, 128, 0)
1262     BLOCK_CIPHER_generic_pack(NID_aes, 192, 0)
1263     BLOCK_CIPHER_generic_pack(NID_aes, 256, 0)
1264
1265 static int aes_gcm_cleanup(EVP_CIPHER_CTX *c)
1266 {
1267     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,c);
1268     OPENSSL_cleanse(&gctx->gcm, sizeof(gctx->gcm));
1269     if (gctx->iv != EVP_CIPHER_CTX_iv_noconst(c))
1270         OPENSSL_free(gctx->iv);
1271     return 1;
1272 }
1273
1274 /* increment counter (64-bit int) by 1 */
1275 static void ctr64_inc(unsigned char *counter)
1276 {
1277     int n = 8;
1278     unsigned char c;
1279
1280     do {
1281         --n;
1282         c = counter[n];
1283         ++c;
1284         counter[n] = c;
1285         if (c)
1286             return;
1287     } while (n);
1288 }
1289
1290 static int aes_gcm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
1291 {
1292     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,c);
1293     switch (type) {
1294     case EVP_CTRL_INIT:
1295         gctx->key_set = 0;
1296         gctx->iv_set = 0;
1297         gctx->ivlen = EVP_CIPHER_CTX_iv_length(c);
1298         gctx->iv = EVP_CIPHER_CTX_iv_noconst(c);
1299         gctx->taglen = -1;
1300         gctx->iv_gen = 0;
1301         gctx->tls_aad_len = -1;
1302         return 1;
1303
1304     case EVP_CTRL_AEAD_SET_IVLEN:
1305         if (arg <= 0)
1306             return 0;
1307         /* Allocate memory for IV if needed */
1308         if ((arg > EVP_MAX_IV_LENGTH) && (arg > gctx->ivlen)) {
1309             if (gctx->iv != EVP_CIPHER_CTX_iv_noconst(c))
1310                 OPENSSL_free(gctx->iv);
1311             gctx->iv = OPENSSL_malloc(arg);
1312             if (gctx->iv == NULL)
1313                 return 0;
1314         }
1315         gctx->ivlen = arg;
1316         return 1;
1317
1318     case EVP_CTRL_AEAD_SET_TAG:
1319         if (arg <= 0 || arg > 16 || EVP_CIPHER_CTX_encrypting(c))
1320             return 0;
1321         memcpy(EVP_CIPHER_CTX_buf_noconst(c), ptr, arg);
1322         gctx->taglen = arg;
1323         return 1;
1324
1325     case EVP_CTRL_AEAD_GET_TAG:
1326         if (arg <= 0 || arg > 16 || !EVP_CIPHER_CTX_encrypting(c)
1327             || gctx->taglen < 0)
1328             return 0;
1329         memcpy(ptr, EVP_CIPHER_CTX_buf_noconst(c), arg);
1330         return 1;
1331
1332     case EVP_CTRL_GCM_SET_IV_FIXED:
1333         /* Special case: -1 length restores whole IV */
1334         if (arg == -1) {
1335             memcpy(gctx->iv, ptr, gctx->ivlen);
1336             gctx->iv_gen = 1;
1337             return 1;
1338         }
1339         /*
1340          * Fixed field must be at least 4 bytes and invocation field at least
1341          * 8.
1342          */
1343         if ((arg < 4) || (gctx->ivlen - arg) < 8)
1344             return 0;
1345         if (arg)
1346             memcpy(gctx->iv, ptr, arg);
1347         if (EVP_CIPHER_CTX_encrypting(c)
1348             && RAND_bytes(gctx->iv + arg, gctx->ivlen - arg) <= 0)
1349             return 0;
1350         gctx->iv_gen = 1;
1351         return 1;
1352
1353     case EVP_CTRL_GCM_IV_GEN:
1354         if (gctx->iv_gen == 0 || gctx->key_set == 0)
1355             return 0;
1356         CRYPTO_gcm128_setiv(&gctx->gcm, gctx->iv, gctx->ivlen);
1357         if (arg <= 0 || arg > gctx->ivlen)
1358             arg = gctx->ivlen;
1359         memcpy(ptr, gctx->iv + gctx->ivlen - arg, arg);
1360         /*
1361          * Invocation field will be at least 8 bytes in size and so no need
1362          * to check wrap around or increment more than last 8 bytes.
1363          */
1364         ctr64_inc(gctx->iv + gctx->ivlen - 8);
1365         gctx->iv_set = 1;
1366         return 1;
1367
1368     case EVP_CTRL_GCM_SET_IV_INV:
1369         if (gctx->iv_gen == 0 || gctx->key_set == 0
1370             || EVP_CIPHER_CTX_encrypting(c))
1371             return 0;
1372         memcpy(gctx->iv + gctx->ivlen - arg, ptr, arg);
1373         CRYPTO_gcm128_setiv(&gctx->gcm, gctx->iv, gctx->ivlen);
1374         gctx->iv_set = 1;
1375         return 1;
1376
1377     case EVP_CTRL_AEAD_TLS1_AAD:
1378         /* Save the AAD for later use */
1379         if (arg != EVP_AEAD_TLS1_AAD_LEN)
1380             return 0;
1381         memcpy(EVP_CIPHER_CTX_buf_noconst(c), ptr, arg);
1382         gctx->tls_aad_len = arg;
1383         {
1384             unsigned int len =
1385                 EVP_CIPHER_CTX_buf_noconst(c)[arg - 2] << 8
1386                 | EVP_CIPHER_CTX_buf_noconst(c)[arg - 1];
1387             /* Correct length for explicit IV */
1388             len -= EVP_GCM_TLS_EXPLICIT_IV_LEN;
1389             /* If decrypting correct for tag too */
1390             if (!EVP_CIPHER_CTX_encrypting(c))
1391                 len -= EVP_GCM_TLS_TAG_LEN;
1392             EVP_CIPHER_CTX_buf_noconst(c)[arg - 2] = len >> 8;
1393             EVP_CIPHER_CTX_buf_noconst(c)[arg - 1] = len & 0xff;
1394         }
1395         /* Extra padding: tag appended to record */
1396         return EVP_GCM_TLS_TAG_LEN;
1397
1398     case EVP_CTRL_COPY:
1399         {
1400             EVP_CIPHER_CTX *out = ptr;
1401             EVP_AES_GCM_CTX *gctx_out = EVP_C_DATA(EVP_AES_GCM_CTX,out);
1402             if (gctx->gcm.key) {
1403                 if (gctx->gcm.key != &gctx->ks)
1404                     return 0;
1405                 gctx_out->gcm.key = &gctx_out->ks;
1406             }
1407             if (gctx->iv == EVP_CIPHER_CTX_iv_noconst(c))
1408                 gctx_out->iv = EVP_CIPHER_CTX_iv_noconst(out);
1409             else {
1410                 gctx_out->iv = OPENSSL_malloc(gctx->ivlen);
1411                 if (gctx_out->iv == NULL)
1412                     return 0;
1413                 memcpy(gctx_out->iv, gctx->iv, gctx->ivlen);
1414             }
1415             return 1;
1416         }
1417
1418     default:
1419         return -1;
1420
1421     }
1422 }
1423
1424 static int aes_gcm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
1425                             const unsigned char *iv, int enc)
1426 {
1427     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,ctx);
1428     if (!iv && !key)
1429         return 1;
1430     if (key) {
1431         do {
1432 #ifdef HWAES_CAPABLE
1433             if (HWAES_CAPABLE) {
1434                 HWAES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
1435                                       &gctx->ks.ks);
1436                 CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
1437                                    (block128_f) HWAES_encrypt);
1438 # ifdef HWAES_ctr32_encrypt_blocks
1439                 gctx->ctr = (ctr128_f) HWAES_ctr32_encrypt_blocks;
1440 # else
1441                 gctx->ctr = NULL;
1442 # endif
1443                 break;
1444             } else
1445 #endif
1446 #ifdef BSAES_CAPABLE
1447             if (BSAES_CAPABLE) {
1448                 AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
1449                                     &gctx->ks.ks);
1450                 CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
1451                                    (block128_f) AES_encrypt);
1452                 gctx->ctr = (ctr128_f) bsaes_ctr32_encrypt_blocks;
1453                 break;
1454             } else
1455 #endif
1456 #ifdef VPAES_CAPABLE
1457             if (VPAES_CAPABLE) {
1458                 vpaes_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
1459                                       &gctx->ks.ks);
1460                 CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
1461                                    (block128_f) vpaes_encrypt);
1462                 gctx->ctr = NULL;
1463                 break;
1464             } else
1465 #endif
1466                 (void)0;        /* terminate potentially open 'else' */
1467
1468             AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
1469                                 &gctx->ks.ks);
1470             CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
1471                                (block128_f) AES_encrypt);
1472 #ifdef AES_CTR_ASM
1473             gctx->ctr = (ctr128_f) AES_ctr32_encrypt;
1474 #else
1475             gctx->ctr = NULL;
1476 #endif
1477         } while (0);
1478
1479         /*
1480          * If we have an iv can set it directly, otherwise use saved IV.
1481          */
1482         if (iv == NULL && gctx->iv_set)
1483             iv = gctx->iv;
1484         if (iv) {
1485             CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
1486             gctx->iv_set = 1;
1487         }
1488         gctx->key_set = 1;
1489     } else {
1490         /* If key set use IV, otherwise copy */
1491         if (gctx->key_set)
1492             CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
1493         else
1494             memcpy(gctx->iv, iv, gctx->ivlen);
1495         gctx->iv_set = 1;
1496         gctx->iv_gen = 0;
1497     }
1498     return 1;
1499 }
1500
1501 /*
1502  * Handle TLS GCM packet format. This consists of the last portion of the IV
1503  * followed by the payload and finally the tag. On encrypt generate IV,
1504  * encrypt payload and write the tag. On verify retrieve IV, decrypt payload
1505  * and verify tag.
1506  */
1507
1508 static int aes_gcm_tls_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1509                               const unsigned char *in, size_t len)
1510 {
1511     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,ctx);
1512     int rv = -1;
1513     /* Encrypt/decrypt must be performed in place */
1514     if (out != in
1515         || len < (EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN))
1516         return -1;
1517     /*
1518      * Set IV from start of buffer or generate IV and write to start of
1519      * buffer.
1520      */
1521     if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CIPHER_CTX_encrypting(ctx) ?
1522                             EVP_CTRL_GCM_IV_GEN : EVP_CTRL_GCM_SET_IV_INV,
1523                             EVP_GCM_TLS_EXPLICIT_IV_LEN, out) <= 0)
1524         goto err;
1525     /* Use saved AAD */
1526     if (CRYPTO_gcm128_aad(&gctx->gcm, EVP_CIPHER_CTX_buf_noconst(ctx),
1527                           gctx->tls_aad_len))
1528         goto err;
1529     /* Fix buffer and length to point to payload */
1530     in += EVP_GCM_TLS_EXPLICIT_IV_LEN;
1531     out += EVP_GCM_TLS_EXPLICIT_IV_LEN;
1532     len -= EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
1533     if (EVP_CIPHER_CTX_encrypting(ctx)) {
1534         /* Encrypt payload */
1535         if (gctx->ctr) {
1536             size_t bulk = 0;
1537 #if defined(AES_GCM_ASM)
1538             if (len >= 32 && AES_GCM_ASM(gctx)) {
1539                 if (CRYPTO_gcm128_encrypt(&gctx->gcm, NULL, NULL, 0))
1540                     return -1;
1541
1542                 bulk = AES_gcm_encrypt(in, out, len,
1543                                        gctx->gcm.key,
1544                                        gctx->gcm.Yi.c, gctx->gcm.Xi.u);
1545                 gctx->gcm.len.u[1] += bulk;
1546             }
1547 #endif
1548             if (CRYPTO_gcm128_encrypt_ctr32(&gctx->gcm,
1549                                             in + bulk,
1550                                             out + bulk,
1551                                             len - bulk, gctx->ctr))
1552                 goto err;
1553         } else {
1554             size_t bulk = 0;
1555 #if defined(AES_GCM_ASM2)
1556             if (len >= 32 && AES_GCM_ASM2(gctx)) {
1557                 if (CRYPTO_gcm128_encrypt(&gctx->gcm, NULL, NULL, 0))
1558                     return -1;
1559
1560                 bulk = AES_gcm_encrypt(in, out, len,
1561                                        gctx->gcm.key,
1562                                        gctx->gcm.Yi.c, gctx->gcm.Xi.u);
1563                 gctx->gcm.len.u[1] += bulk;
1564             }
1565 #endif
1566             if (CRYPTO_gcm128_encrypt(&gctx->gcm,
1567                                       in + bulk, out + bulk, len - bulk))
1568                 goto err;
1569         }
1570         out += len;
1571         /* Finally write tag */
1572         CRYPTO_gcm128_tag(&gctx->gcm, out, EVP_GCM_TLS_TAG_LEN);
1573         rv = len + EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
1574     } else {
1575         /* Decrypt */
1576         if (gctx->ctr) {
1577             size_t bulk = 0;
1578 #if defined(AES_GCM_ASM)
1579             if (len >= 16 && AES_GCM_ASM(gctx)) {
1580                 if (CRYPTO_gcm128_decrypt(&gctx->gcm, NULL, NULL, 0))
1581                     return -1;
1582
1583                 bulk = AES_gcm_decrypt(in, out, len,
1584                                        gctx->gcm.key,
1585                                        gctx->gcm.Yi.c, gctx->gcm.Xi.u);
1586                 gctx->gcm.len.u[1] += bulk;
1587             }
1588 #endif
1589             if (CRYPTO_gcm128_decrypt_ctr32(&gctx->gcm,
1590                                             in + bulk,
1591                                             out + bulk,
1592                                             len - bulk, gctx->ctr))
1593                 goto err;
1594         } else {
1595             size_t bulk = 0;
1596 #if defined(AES_GCM_ASM2)
1597             if (len >= 16 && AES_GCM_ASM2(gctx)) {
1598                 if (CRYPTO_gcm128_decrypt(&gctx->gcm, NULL, NULL, 0))
1599                     return -1;
1600
1601                 bulk = AES_gcm_decrypt(in, out, len,
1602                                        gctx->gcm.key,
1603                                        gctx->gcm.Yi.c, gctx->gcm.Xi.u);
1604                 gctx->gcm.len.u[1] += bulk;
1605             }
1606 #endif
1607             if (CRYPTO_gcm128_decrypt(&gctx->gcm,
1608                                       in + bulk, out + bulk, len - bulk))
1609                 goto err;
1610         }
1611         /* Retrieve tag */
1612         CRYPTO_gcm128_tag(&gctx->gcm, EVP_CIPHER_CTX_buf_noconst(ctx),
1613                           EVP_GCM_TLS_TAG_LEN);
1614         /* If tag mismatch wipe buffer */
1615         if (CRYPTO_memcmp(EVP_CIPHER_CTX_buf_noconst(ctx), in + len,
1616                           EVP_GCM_TLS_TAG_LEN)) {
1617             OPENSSL_cleanse(out, len);
1618             goto err;
1619         }
1620         rv = len;
1621     }
1622
1623  err:
1624     gctx->iv_set = 0;
1625     gctx->tls_aad_len = -1;
1626     return rv;
1627 }
1628
1629 static int aes_gcm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1630                           const unsigned char *in, size_t len)
1631 {
1632     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,ctx);
1633     /* If not set up, return error */
1634     if (!gctx->key_set)
1635         return -1;
1636
1637     if (gctx->tls_aad_len >= 0)
1638         return aes_gcm_tls_cipher(ctx, out, in, len);
1639
1640     if (!gctx->iv_set)
1641         return -1;
1642     if (in) {
1643         if (out == NULL) {
1644             if (CRYPTO_gcm128_aad(&gctx->gcm, in, len))
1645                 return -1;
1646         } else if (EVP_CIPHER_CTX_encrypting(ctx)) {
1647             if (gctx->ctr) {
1648                 size_t bulk = 0;
1649 #if defined(AES_GCM_ASM)
1650                 if (len >= 32 && AES_GCM_ASM(gctx)) {
1651                     size_t res = (16 - gctx->gcm.mres) % 16;
1652
1653                     if (CRYPTO_gcm128_encrypt(&gctx->gcm, in, out, res))
1654                         return -1;
1655
1656                     bulk = AES_gcm_encrypt(in + res,
1657                                            out + res, len - res,
1658                                            gctx->gcm.key, gctx->gcm.Yi.c,
1659                                            gctx->gcm.Xi.u);
1660                     gctx->gcm.len.u[1] += bulk;
1661                     bulk += res;
1662                 }
1663 #endif
1664                 if (CRYPTO_gcm128_encrypt_ctr32(&gctx->gcm,
1665                                                 in + bulk,
1666                                                 out + bulk,
1667                                                 len - bulk, gctx->ctr))
1668                     return -1;
1669             } else {
1670                 size_t bulk = 0;
1671 #if defined(AES_GCM_ASM2)
1672                 if (len >= 32 && AES_GCM_ASM2(gctx)) {
1673                     size_t res = (16 - gctx->gcm.mres) % 16;
1674
1675                     if (CRYPTO_gcm128_encrypt(&gctx->gcm, in, out, res))
1676                         return -1;
1677
1678                     bulk = AES_gcm_encrypt(in + res,
1679                                            out + res, len - res,
1680                                            gctx->gcm.key, gctx->gcm.Yi.c,
1681                                            gctx->gcm.Xi.u);
1682                     gctx->gcm.len.u[1] += bulk;
1683                     bulk += res;
1684                 }
1685 #endif
1686                 if (CRYPTO_gcm128_encrypt(&gctx->gcm,
1687                                           in + bulk, out + bulk, len - bulk))
1688                     return -1;
1689             }
1690         } else {
1691             if (gctx->ctr) {
1692                 size_t bulk = 0;
1693 #if defined(AES_GCM_ASM)
1694                 if (len >= 16 && AES_GCM_ASM(gctx)) {
1695                     size_t res = (16 - gctx->gcm.mres) % 16;
1696
1697                     if (CRYPTO_gcm128_decrypt(&gctx->gcm, in, out, res))
1698                         return -1;
1699
1700                     bulk = AES_gcm_decrypt(in + res,
1701                                            out + res, len - res,
1702                                            gctx->gcm.key,
1703                                            gctx->gcm.Yi.c, gctx->gcm.Xi.u);
1704                     gctx->gcm.len.u[1] += bulk;
1705                     bulk += res;
1706                 }
1707 #endif
1708                 if (CRYPTO_gcm128_decrypt_ctr32(&gctx->gcm,
1709                                                 in + bulk,
1710                                                 out + bulk,
1711                                                 len - bulk, gctx->ctr))
1712                     return -1;
1713             } else {
1714                 size_t bulk = 0;
1715 #if defined(AES_GCM_ASM2)
1716                 if (len >= 16 && AES_GCM_ASM2(gctx)) {
1717                     size_t res = (16 - gctx->gcm.mres) % 16;
1718
1719                     if (CRYPTO_gcm128_decrypt(&gctx->gcm, in, out, res))
1720                         return -1;
1721
1722                     bulk = AES_gcm_decrypt(in + res,
1723                                            out + res, len - res,
1724                                            gctx->gcm.key,
1725                                            gctx->gcm.Yi.c, gctx->gcm.Xi.u);
1726                     gctx->gcm.len.u[1] += bulk;
1727                     bulk += res;
1728                 }
1729 #endif
1730                 if (CRYPTO_gcm128_decrypt(&gctx->gcm,
1731                                           in + bulk, out + bulk, len - bulk))
1732                     return -1;
1733             }
1734         }
1735         return len;
1736     } else {
1737         if (!EVP_CIPHER_CTX_encrypting(ctx)) {
1738             if (gctx->taglen < 0)
1739                 return -1;
1740             if (CRYPTO_gcm128_finish(&gctx->gcm,
1741                                      EVP_CIPHER_CTX_buf_noconst(ctx),
1742                                      gctx->taglen) != 0)
1743                 return -1;
1744             gctx->iv_set = 0;
1745             return 0;
1746         }
1747         CRYPTO_gcm128_tag(&gctx->gcm, EVP_CIPHER_CTX_buf_noconst(ctx), 16);
1748         gctx->taglen = 16;
1749         /* Don't reuse the IV */
1750         gctx->iv_set = 0;
1751         return 0;
1752     }
1753
1754 }
1755
1756 #define CUSTOM_FLAGS    (EVP_CIPH_FLAG_DEFAULT_ASN1 \
1757                 | EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER \
1758                 | EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT \
1759                 | EVP_CIPH_CUSTOM_COPY)
1760
1761 BLOCK_CIPHER_custom(NID_aes, 128, 1, 12, gcm, GCM,
1762                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
1763     BLOCK_CIPHER_custom(NID_aes, 192, 1, 12, gcm, GCM,
1764                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
1765     BLOCK_CIPHER_custom(NID_aes, 256, 1, 12, gcm, GCM,
1766                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
1767
1768 static int aes_xts_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
1769 {
1770     EVP_AES_XTS_CTX *xctx = EVP_C_DATA(EVP_AES_XTS_CTX,c);
1771     if (type == EVP_CTRL_COPY) {
1772         EVP_CIPHER_CTX *out = ptr;
1773         EVP_AES_XTS_CTX *xctx_out = EVP_C_DATA(EVP_AES_XTS_CTX,out);
1774         if (xctx->xts.key1) {
1775             if (xctx->xts.key1 != &xctx->ks1)
1776                 return 0;
1777             xctx_out->xts.key1 = &xctx_out->ks1;
1778         }
1779         if (xctx->xts.key2) {
1780             if (xctx->xts.key2 != &xctx->ks2)
1781                 return 0;
1782             xctx_out->xts.key2 = &xctx_out->ks2;
1783         }
1784         return 1;
1785     } else if (type != EVP_CTRL_INIT)
1786         return -1;
1787     /* key1 and key2 are used as an indicator both key and IV are set */
1788     xctx->xts.key1 = NULL;
1789     xctx->xts.key2 = NULL;
1790     return 1;
1791 }
1792
1793 static int aes_xts_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
1794                             const unsigned char *iv, int enc)
1795 {
1796     EVP_AES_XTS_CTX *xctx = EVP_C_DATA(EVP_AES_XTS_CTX,ctx);
1797     if (!iv && !key)
1798         return 1;
1799
1800     if (key)
1801         do {
1802 #ifdef AES_XTS_ASM
1803             xctx->stream = enc ? AES_xts_encrypt : AES_xts_decrypt;
1804 #else
1805             xctx->stream = NULL;
1806 #endif
1807             /* key_len is two AES keys */
1808 #ifdef HWAES_CAPABLE
1809             if (HWAES_CAPABLE) {
1810                 if (enc) {
1811                     HWAES_set_encrypt_key(key,
1812                                           EVP_CIPHER_CTX_key_length(ctx) * 4,
1813                                           &xctx->ks1.ks);
1814                     xctx->xts.block1 = (block128_f) HWAES_encrypt;
1815 # ifdef HWAES_xts_encrypt
1816                     xctx->stream = HWAES_xts_encrypt;
1817 # endif
1818                 } else {
1819                     HWAES_set_decrypt_key(key,
1820                                           EVP_CIPHER_CTX_key_length(ctx) * 4,
1821                                           &xctx->ks1.ks);
1822                     xctx->xts.block1 = (block128_f) HWAES_decrypt;
1823 # ifdef HWAES_xts_decrypt
1824                     xctx->stream = HWAES_xts_decrypt;
1825 #endif
1826                 }
1827
1828                 HWAES_set_encrypt_key(key + EVP_CIPHER_CTX_key_length(ctx) / 2,
1829                                       EVP_CIPHER_CTX_key_length(ctx) * 4,
1830                                       &xctx->ks2.ks);
1831                 xctx->xts.block2 = (block128_f) HWAES_encrypt;
1832
1833                 xctx->xts.key1 = &xctx->ks1;
1834                 break;
1835             } else
1836 #endif
1837 #ifdef BSAES_CAPABLE
1838             if (BSAES_CAPABLE)
1839                 xctx->stream = enc ? bsaes_xts_encrypt : bsaes_xts_decrypt;
1840             else
1841 #endif
1842 #ifdef VPAES_CAPABLE
1843             if (VPAES_CAPABLE) {
1844                 if (enc) {
1845                     vpaes_set_encrypt_key(key,
1846                                           EVP_CIPHER_CTX_key_length(ctx) * 4,
1847                                           &xctx->ks1.ks);
1848                     xctx->xts.block1 = (block128_f) vpaes_encrypt;
1849                 } else {
1850                     vpaes_set_decrypt_key(key,
1851                                           EVP_CIPHER_CTX_key_length(ctx) * 4,
1852                                           &xctx->ks1.ks);
1853                     xctx->xts.block1 = (block128_f) vpaes_decrypt;
1854                 }
1855
1856                 vpaes_set_encrypt_key(key + EVP_CIPHER_CTX_key_length(ctx) / 2,
1857                                       EVP_CIPHER_CTX_key_length(ctx) * 4,
1858                                       &xctx->ks2.ks);
1859                 xctx->xts.block2 = (block128_f) vpaes_encrypt;
1860
1861                 xctx->xts.key1 = &xctx->ks1;
1862                 break;
1863             } else
1864 #endif
1865                 (void)0;        /* terminate potentially open 'else' */
1866
1867             if (enc) {
1868                 AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 4,
1869                                     &xctx->ks1.ks);
1870                 xctx->xts.block1 = (block128_f) AES_encrypt;
1871             } else {
1872                 AES_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 4,
1873                                     &xctx->ks1.ks);
1874                 xctx->xts.block1 = (block128_f) AES_decrypt;
1875             }
1876
1877             AES_set_encrypt_key(key + EVP_CIPHER_CTX_key_length(ctx) / 2,
1878                                 EVP_CIPHER_CTX_key_length(ctx) * 4,
1879                                 &xctx->ks2.ks);
1880             xctx->xts.block2 = (block128_f) AES_encrypt;
1881
1882             xctx->xts.key1 = &xctx->ks1;
1883         } while (0);
1884
1885     if (iv) {
1886         xctx->xts.key2 = &xctx->ks2;
1887         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 16);
1888     }
1889
1890     return 1;
1891 }
1892
1893 static int aes_xts_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1894                           const unsigned char *in, size_t len)
1895 {
1896     EVP_AES_XTS_CTX *xctx = EVP_C_DATA(EVP_AES_XTS_CTX,ctx);
1897     if (!xctx->xts.key1 || !xctx->xts.key2)
1898         return 0;
1899     if (!out || !in || len < AES_BLOCK_SIZE)
1900         return 0;
1901     if (xctx->stream)
1902         (*xctx->stream) (in, out, len,
1903                          xctx->xts.key1, xctx->xts.key2,
1904                          EVP_CIPHER_CTX_iv_noconst(ctx));
1905     else if (CRYPTO_xts128_encrypt(&xctx->xts, EVP_CIPHER_CTX_iv_noconst(ctx),
1906                                    in, out, len,
1907                                    EVP_CIPHER_CTX_encrypting(ctx)))
1908         return 0;
1909     return 1;
1910 }
1911
1912 #define aes_xts_cleanup NULL
1913
1914 #define XTS_FLAGS       (EVP_CIPH_FLAG_DEFAULT_ASN1 | EVP_CIPH_CUSTOM_IV \
1915                          | EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT \
1916                          | EVP_CIPH_CUSTOM_COPY)
1917
1918 BLOCK_CIPHER_custom(NID_aes, 128, 1, 16, xts, XTS, XTS_FLAGS)
1919     BLOCK_CIPHER_custom(NID_aes, 256, 1, 16, xts, XTS, XTS_FLAGS)
1920
1921 static int aes_ccm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
1922 {
1923     EVP_AES_CCM_CTX *cctx = EVP_C_DATA(EVP_AES_CCM_CTX,c);
1924     switch (type) {
1925     case EVP_CTRL_INIT:
1926         cctx->key_set = 0;
1927         cctx->iv_set = 0;
1928         cctx->L = 8;
1929         cctx->M = 12;
1930         cctx->tag_set = 0;
1931         cctx->len_set = 0;
1932         cctx->tls_aad_len = -1;
1933         return 1;
1934
1935     case EVP_CTRL_AEAD_TLS1_AAD:
1936         /* Save the AAD for later use */
1937         if (arg != EVP_AEAD_TLS1_AAD_LEN)
1938             return 0;
1939         memcpy(EVP_CIPHER_CTX_buf_noconst(c), ptr, arg);
1940         cctx->tls_aad_len = arg;
1941         {
1942             uint16_t len =
1943                 EVP_CIPHER_CTX_buf_noconst(c)[arg - 2] << 8
1944                 | EVP_CIPHER_CTX_buf_noconst(c)[arg - 1];
1945             /* Correct length for explicit IV */
1946             len -= EVP_CCM_TLS_EXPLICIT_IV_LEN;
1947             /* If decrypting correct for tag too */
1948             if (!EVP_CIPHER_CTX_encrypting(c))
1949                 len -= cctx->M;
1950             EVP_CIPHER_CTX_buf_noconst(c)[arg - 2] = len >> 8;
1951             EVP_CIPHER_CTX_buf_noconst(c)[arg - 1] = len & 0xff;
1952         }
1953         /* Extra padding: tag appended to record */
1954         return cctx->M;
1955
1956     case EVP_CTRL_CCM_SET_IV_FIXED:
1957         /* Sanity check length */
1958         if (arg != EVP_CCM_TLS_FIXED_IV_LEN)
1959             return 0;
1960         /* Just copy to first part of IV */
1961         memcpy(EVP_CIPHER_CTX_iv_noconst(c), ptr, arg);
1962         return 1;
1963
1964     case EVP_CTRL_AEAD_SET_IVLEN:
1965         arg = 15 - arg;
1966     case EVP_CTRL_CCM_SET_L:
1967         if (arg < 2 || arg > 8)
1968             return 0;
1969         cctx->L = arg;
1970         return 1;
1971
1972     case EVP_CTRL_AEAD_SET_TAG:
1973         if ((arg & 1) || arg < 4 || arg > 16)
1974             return 0;
1975         if (EVP_CIPHER_CTX_encrypting(c) && ptr)
1976             return 0;
1977         if (ptr) {
1978             cctx->tag_set = 1;
1979             memcpy(EVP_CIPHER_CTX_buf_noconst(c), ptr, arg);
1980         }
1981         cctx->M = arg;
1982         return 1;
1983
1984     case EVP_CTRL_AEAD_GET_TAG:
1985         if (!EVP_CIPHER_CTX_encrypting(c) || !cctx->tag_set)
1986             return 0;
1987         if (!CRYPTO_ccm128_tag(&cctx->ccm, ptr, (size_t)arg))
1988             return 0;
1989         cctx->tag_set = 0;
1990         cctx->iv_set = 0;
1991         cctx->len_set = 0;
1992         return 1;
1993
1994     case EVP_CTRL_COPY:
1995         {
1996             EVP_CIPHER_CTX *out = ptr;
1997             EVP_AES_CCM_CTX *cctx_out = EVP_C_DATA(EVP_AES_CCM_CTX,out);
1998             if (cctx->ccm.key) {
1999                 if (cctx->ccm.key != &cctx->ks)
2000                     return 0;
2001                 cctx_out->ccm.key = &cctx_out->ks;
2002             }
2003             return 1;
2004         }
2005
2006     default:
2007         return -1;
2008
2009     }
2010 }
2011
2012 static int aes_ccm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
2013                             const unsigned char *iv, int enc)
2014 {
2015     EVP_AES_CCM_CTX *cctx = EVP_C_DATA(EVP_AES_CCM_CTX,ctx);
2016     if (!iv && !key)
2017         return 1;
2018     if (key)
2019         do {
2020 #ifdef HWAES_CAPABLE
2021             if (HWAES_CAPABLE) {
2022                 HWAES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2023                                       &cctx->ks.ks);
2024
2025                 CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
2026                                    &cctx->ks, (block128_f) HWAES_encrypt);
2027                 cctx->str = NULL;
2028                 cctx->key_set = 1;
2029                 break;
2030             } else
2031 #endif
2032 #ifdef VPAES_CAPABLE
2033             if (VPAES_CAPABLE) {
2034                 vpaes_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2035                                       &cctx->ks.ks);
2036                 CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
2037                                    &cctx->ks, (block128_f) vpaes_encrypt);
2038                 cctx->str = NULL;
2039                 cctx->key_set = 1;
2040                 break;
2041             }
2042 #endif
2043             AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2044                                 &cctx->ks.ks);
2045             CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
2046                                &cctx->ks, (block128_f) AES_encrypt);
2047             cctx->str = NULL;
2048             cctx->key_set = 1;
2049         } while (0);
2050     if (iv) {
2051         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 15 - cctx->L);
2052         cctx->iv_set = 1;
2053     }
2054     return 1;
2055 }
2056
2057 static int aes_ccm_tls_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2058                               const unsigned char *in, size_t len)
2059 {
2060     EVP_AES_CCM_CTX *cctx = EVP_C_DATA(EVP_AES_CCM_CTX,ctx);
2061     CCM128_CONTEXT *ccm = &cctx->ccm;
2062     /* Encrypt/decrypt must be performed in place */
2063     if (out != in || len < (EVP_CCM_TLS_EXPLICIT_IV_LEN + (size_t)cctx->M))
2064         return -1;
2065     /* If encrypting set explicit IV from sequence number (start of AAD) */
2066     if (EVP_CIPHER_CTX_encrypting(ctx))
2067         memcpy(out, EVP_CIPHER_CTX_buf_noconst(ctx),
2068                EVP_CCM_TLS_EXPLICIT_IV_LEN);
2069     /* Get rest of IV from explicit IV */
2070     memcpy(EVP_CIPHER_CTX_iv_noconst(ctx) + EVP_CCM_TLS_FIXED_IV_LEN, in,
2071            EVP_CCM_TLS_EXPLICIT_IV_LEN);
2072     /* Correct length value */
2073     len -= EVP_CCM_TLS_EXPLICIT_IV_LEN + cctx->M;
2074     if (CRYPTO_ccm128_setiv(ccm, EVP_CIPHER_CTX_iv_noconst(ctx), 15 - cctx->L,
2075                             len))
2076             return -1;
2077     /* Use saved AAD */
2078     CRYPTO_ccm128_aad(ccm, EVP_CIPHER_CTX_buf_noconst(ctx), cctx->tls_aad_len);
2079     /* Fix buffer to point to payload */
2080     in += EVP_CCM_TLS_EXPLICIT_IV_LEN;
2081     out += EVP_CCM_TLS_EXPLICIT_IV_LEN;
2082     if (EVP_CIPHER_CTX_encrypting(ctx)) {
2083         if (cctx->str ? CRYPTO_ccm128_encrypt_ccm64(ccm, in, out, len,
2084                                                     cctx->str) :
2085             CRYPTO_ccm128_encrypt(ccm, in, out, len))
2086             return -1;
2087         if (!CRYPTO_ccm128_tag(ccm, out + len, cctx->M))
2088             return -1;
2089         return len + EVP_CCM_TLS_EXPLICIT_IV_LEN + cctx->M;
2090     } else {
2091         if (cctx->str ? !CRYPTO_ccm128_decrypt_ccm64(ccm, in, out, len,
2092                                                      cctx->str) :
2093             !CRYPTO_ccm128_decrypt(ccm, in, out, len)) {
2094             unsigned char tag[16];
2095             if (CRYPTO_ccm128_tag(ccm, tag, cctx->M)) {
2096                 if (!CRYPTO_memcmp(tag, in + len, cctx->M))
2097                     return len;
2098             }
2099         }
2100         OPENSSL_cleanse(out, len);
2101         return -1;
2102     }
2103 }
2104
2105 static int aes_ccm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2106                           const unsigned char *in, size_t len)
2107 {
2108     EVP_AES_CCM_CTX *cctx = EVP_C_DATA(EVP_AES_CCM_CTX,ctx);
2109     CCM128_CONTEXT *ccm = &cctx->ccm;
2110     /* If not set up, return error */
2111     if (!cctx->key_set)
2112         return -1;
2113
2114     if (cctx->tls_aad_len >= 0)
2115         return aes_ccm_tls_cipher(ctx, out, in, len);
2116
2117     if (!cctx->iv_set)
2118         return -1;
2119
2120     if (!EVP_CIPHER_CTX_encrypting(ctx) && !cctx->tag_set)
2121         return -1;
2122     if (!out) {
2123         if (!in) {
2124             if (CRYPTO_ccm128_setiv(ccm, EVP_CIPHER_CTX_iv_noconst(ctx),
2125                                     15 - cctx->L, len))
2126                 return -1;
2127             cctx->len_set = 1;
2128             return len;
2129         }
2130         /* If have AAD need message length */
2131         if (!cctx->len_set && len)
2132             return -1;
2133         CRYPTO_ccm128_aad(ccm, in, len);
2134         return len;
2135     }
2136     /* EVP_*Final() doesn't return any data */
2137     if (!in)
2138         return 0;
2139     /* If not set length yet do it */
2140     if (!cctx->len_set) {
2141         if (CRYPTO_ccm128_setiv(ccm, EVP_CIPHER_CTX_iv_noconst(ctx),
2142                                 15 - cctx->L, len))
2143             return -1;
2144         cctx->len_set = 1;
2145     }
2146     if (EVP_CIPHER_CTX_encrypting(ctx)) {
2147         if (cctx->str ? CRYPTO_ccm128_encrypt_ccm64(ccm, in, out, len,
2148                                                     cctx->str) :
2149             CRYPTO_ccm128_encrypt(ccm, in, out, len))
2150             return -1;
2151         cctx->tag_set = 1;
2152         return len;
2153     } else {
2154         int rv = -1;
2155         if (cctx->str ? !CRYPTO_ccm128_decrypt_ccm64(ccm, in, out, len,
2156                                                      cctx->str) :
2157             !CRYPTO_ccm128_decrypt(ccm, in, out, len)) {
2158             unsigned char tag[16];
2159             if (CRYPTO_ccm128_tag(ccm, tag, cctx->M)) {
2160                 if (!CRYPTO_memcmp(tag, EVP_CIPHER_CTX_buf_noconst(ctx),
2161                                    cctx->M))
2162                     rv = len;
2163             }
2164         }
2165         if (rv == -1)
2166             OPENSSL_cleanse(out, len);
2167         cctx->iv_set = 0;
2168         cctx->tag_set = 0;
2169         cctx->len_set = 0;
2170         return rv;
2171     }
2172 }
2173
2174 #define aes_ccm_cleanup NULL
2175
2176 BLOCK_CIPHER_custom(NID_aes, 128, 1, 12, ccm, CCM,
2177                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
2178     BLOCK_CIPHER_custom(NID_aes, 192, 1, 12, ccm, CCM,
2179                         EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
2180     BLOCK_CIPHER_custom(NID_aes, 256, 1, 12, ccm, CCM,
2181                         EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
2182
2183 typedef struct {
2184     union {
2185         double align;
2186         AES_KEY ks;
2187     } ks;
2188     /* Indicates if IV has been set */
2189     unsigned char *iv;
2190 } EVP_AES_WRAP_CTX;
2191
2192 static int aes_wrap_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
2193                              const unsigned char *iv, int enc)
2194 {
2195     EVP_AES_WRAP_CTX *wctx = EVP_C_DATA(EVP_AES_WRAP_CTX,ctx);
2196     if (!iv && !key)
2197         return 1;
2198     if (key) {
2199         if (EVP_CIPHER_CTX_encrypting(ctx))
2200             AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2201                                 &wctx->ks.ks);
2202         else
2203             AES_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2204                                 &wctx->ks.ks);
2205         if (!iv)
2206             wctx->iv = NULL;
2207     }
2208     if (iv) {
2209         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, EVP_CIPHER_CTX_iv_length(ctx));
2210         wctx->iv = EVP_CIPHER_CTX_iv_noconst(ctx);
2211     }
2212     return 1;
2213 }
2214
2215 static int aes_wrap_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2216                            const unsigned char *in, size_t inlen)
2217 {
2218     EVP_AES_WRAP_CTX *wctx = EVP_C_DATA(EVP_AES_WRAP_CTX,ctx);
2219     size_t rv;
2220     /* AES wrap with padding has IV length of 4, without padding 8 */
2221     int pad = EVP_CIPHER_CTX_iv_length(ctx) == 4;
2222     /* No final operation so always return zero length */
2223     if (!in)
2224         return 0;
2225     /* Input length must always be non-zero */
2226     if (!inlen)
2227         return -1;
2228     /* If decrypting need at least 16 bytes and multiple of 8 */
2229     if (!EVP_CIPHER_CTX_encrypting(ctx) && (inlen < 16 || inlen & 0x7))
2230         return -1;
2231     /* If not padding input must be multiple of 8 */
2232     if (!pad && inlen & 0x7)
2233         return -1;
2234     if (!out) {
2235         if (EVP_CIPHER_CTX_encrypting(ctx)) {
2236             /* If padding round up to multiple of 8 */
2237             if (pad)
2238                 inlen = (inlen + 7) / 8 * 8;
2239             /* 8 byte prefix */
2240             return inlen + 8;
2241         } else {
2242             /*
2243              * If not padding output will be exactly 8 bytes smaller than
2244              * input. If padding it will be at least 8 bytes smaller but we
2245              * don't know how much.
2246              */
2247             return inlen - 8;
2248         }
2249     }
2250     if (pad) {
2251         if (EVP_CIPHER_CTX_encrypting(ctx))
2252             rv = CRYPTO_128_wrap_pad(&wctx->ks.ks, wctx->iv,
2253                                      out, in, inlen,
2254                                      (block128_f) AES_encrypt);
2255         else
2256             rv = CRYPTO_128_unwrap_pad(&wctx->ks.ks, wctx->iv,
2257                                        out, in, inlen,
2258                                        (block128_f) AES_decrypt);
2259     } else {
2260         if (EVP_CIPHER_CTX_encrypting(ctx))
2261             rv = CRYPTO_128_wrap(&wctx->ks.ks, wctx->iv,
2262                                  out, in, inlen, (block128_f) AES_encrypt);
2263         else
2264             rv = CRYPTO_128_unwrap(&wctx->ks.ks, wctx->iv,
2265                                    out, in, inlen, (block128_f) AES_decrypt);
2266     }
2267     return rv ? (int)rv : -1;
2268 }
2269
2270 #define WRAP_FLAGS      (EVP_CIPH_WRAP_MODE \
2271                 | EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER \
2272                 | EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_FLAG_DEFAULT_ASN1)
2273
2274 static const EVP_CIPHER aes_128_wrap = {
2275     NID_id_aes128_wrap,
2276     8, 16, 8, WRAP_FLAGS,
2277     aes_wrap_init_key, aes_wrap_cipher,
2278     NULL,
2279     sizeof(EVP_AES_WRAP_CTX),
2280     NULL, NULL, NULL, NULL
2281 };
2282
2283 const EVP_CIPHER *EVP_aes_128_wrap(void)
2284 {
2285     return &aes_128_wrap;
2286 }
2287
2288 static const EVP_CIPHER aes_192_wrap = {
2289     NID_id_aes192_wrap,
2290     8, 24, 8, WRAP_FLAGS,
2291     aes_wrap_init_key, aes_wrap_cipher,
2292     NULL,
2293     sizeof(EVP_AES_WRAP_CTX),
2294     NULL, NULL, NULL, NULL
2295 };
2296
2297 const EVP_CIPHER *EVP_aes_192_wrap(void)
2298 {
2299     return &aes_192_wrap;
2300 }
2301
2302 static const EVP_CIPHER aes_256_wrap = {
2303     NID_id_aes256_wrap,
2304     8, 32, 8, WRAP_FLAGS,
2305     aes_wrap_init_key, aes_wrap_cipher,
2306     NULL,
2307     sizeof(EVP_AES_WRAP_CTX),
2308     NULL, NULL, NULL, NULL
2309 };
2310
2311 const EVP_CIPHER *EVP_aes_256_wrap(void)
2312 {
2313     return &aes_256_wrap;
2314 }
2315
2316 static const EVP_CIPHER aes_128_wrap_pad = {
2317     NID_id_aes128_wrap_pad,
2318     8, 16, 4, WRAP_FLAGS,
2319     aes_wrap_init_key, aes_wrap_cipher,
2320     NULL,
2321     sizeof(EVP_AES_WRAP_CTX),
2322     NULL, NULL, NULL, NULL
2323 };
2324
2325 const EVP_CIPHER *EVP_aes_128_wrap_pad(void)
2326 {
2327     return &aes_128_wrap_pad;
2328 }
2329
2330 static const EVP_CIPHER aes_192_wrap_pad = {
2331     NID_id_aes192_wrap_pad,
2332     8, 24, 4, WRAP_FLAGS,
2333     aes_wrap_init_key, aes_wrap_cipher,
2334     NULL,
2335     sizeof(EVP_AES_WRAP_CTX),
2336     NULL, NULL, NULL, NULL
2337 };
2338
2339 const EVP_CIPHER *EVP_aes_192_wrap_pad(void)
2340 {
2341     return &aes_192_wrap_pad;
2342 }
2343
2344 static const EVP_CIPHER aes_256_wrap_pad = {
2345     NID_id_aes256_wrap_pad,
2346     8, 32, 4, WRAP_FLAGS,
2347     aes_wrap_init_key, aes_wrap_cipher,
2348     NULL,
2349     sizeof(EVP_AES_WRAP_CTX),
2350     NULL, NULL, NULL, NULL
2351 };
2352
2353 const EVP_CIPHER *EVP_aes_256_wrap_pad(void)
2354 {
2355     return &aes_256_wrap_pad;
2356 }
2357
2358 #ifndef OPENSSL_NO_OCB
2359 static int aes_ocb_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
2360 {
2361     EVP_AES_OCB_CTX *octx = EVP_C_DATA(EVP_AES_OCB_CTX,c);
2362     EVP_CIPHER_CTX *newc;
2363     EVP_AES_OCB_CTX *new_octx;
2364
2365     switch (type) {
2366     case EVP_CTRL_INIT:
2367         octx->key_set = 0;
2368         octx->iv_set = 0;
2369         octx->ivlen = EVP_CIPHER_CTX_iv_length(c);
2370         octx->iv = EVP_CIPHER_CTX_iv_noconst(c);
2371         octx->taglen = 16;
2372         octx->data_buf_len = 0;
2373         octx->aad_buf_len = 0;
2374         return 1;
2375
2376     case EVP_CTRL_AEAD_SET_IVLEN:
2377         /* IV len must be 1 to 15 */
2378         if (arg <= 0 || arg > 15)
2379             return 0;
2380
2381         octx->ivlen = arg;
2382         return 1;
2383
2384     case EVP_CTRL_AEAD_SET_TAG:
2385         if (!ptr) {
2386             /* Tag len must be 0 to 16 */
2387             if (arg < 0 || arg > 16)
2388                 return 0;
2389
2390             octx->taglen = arg;
2391             return 1;
2392         }
2393         if (arg != octx->taglen || EVP_CIPHER_CTX_encrypting(c))
2394             return 0;
2395         memcpy(octx->tag, ptr, arg);
2396         return 1;
2397
2398     case EVP_CTRL_AEAD_GET_TAG:
2399         if (arg != octx->taglen || !EVP_CIPHER_CTX_encrypting(c))
2400             return 0;
2401
2402         memcpy(ptr, octx->tag, arg);
2403         return 1;
2404
2405     case EVP_CTRL_COPY:
2406         newc = (EVP_CIPHER_CTX *)ptr;
2407         new_octx = EVP_C_DATA(EVP_AES_OCB_CTX,newc);
2408         return CRYPTO_ocb128_copy_ctx(&new_octx->ocb, &octx->ocb,
2409                                       &new_octx->ksenc.ks,
2410                                       &new_octx->ksdec.ks);
2411
2412     default:
2413         return -1;
2414
2415     }
2416 }
2417
2418 # ifdef HWAES_CAPABLE
2419 #  ifdef HWAES_ocb_encrypt
2420 void HWAES_ocb_encrypt(const unsigned char *in, unsigned char *out,
2421                        size_t blocks, const void *key,
2422                        size_t start_block_num,
2423                        unsigned char offset_i[16],
2424                        const unsigned char L_[][16],
2425                        unsigned char checksum[16]);
2426 #  else
2427 #    define HWAES_ocb_encrypt NULL
2428 #  endif
2429 #  ifdef HWAES_ocb_decrypt
2430 void HWAES_ocb_decrypt(const unsigned char *in, unsigned char *out,
2431                        size_t blocks, const void *key,
2432                        size_t start_block_num,
2433                        unsigned char offset_i[16],
2434                        const unsigned char L_[][16],
2435                        unsigned char checksum[16]);
2436 #  else
2437 #    define HWAES_ocb_decrypt NULL
2438 #  endif
2439 # endif
2440
2441 static int aes_ocb_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
2442                             const unsigned char *iv, int enc)
2443 {
2444     EVP_AES_OCB_CTX *octx = EVP_C_DATA(EVP_AES_OCB_CTX,ctx);
2445     if (!iv && !key)
2446         return 1;
2447     if (key) {
2448         do {
2449             /*
2450              * We set both the encrypt and decrypt key here because decrypt
2451              * needs both. We could possibly optimise to remove setting the
2452              * decrypt for an encryption operation.
2453              */
2454 # ifdef HWAES_CAPABLE
2455             if (HWAES_CAPABLE) {
2456                 HWAES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2457                                       &octx->ksenc.ks);
2458                 HWAES_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2459                                       &octx->ksdec.ks);
2460                 if (!CRYPTO_ocb128_init(&octx->ocb,
2461                                         &octx->ksenc.ks, &octx->ksdec.ks,
2462                                         (block128_f) HWAES_encrypt,
2463                                         (block128_f) HWAES_decrypt,
2464                                         enc ? HWAES_ocb_encrypt
2465                                             : HWAES_ocb_decrypt))
2466                     return 0;
2467                 break;
2468             }
2469 # endif
2470 # ifdef VPAES_CAPABLE
2471             if (VPAES_CAPABLE) {
2472                 vpaes_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2473                                       &octx->ksenc.ks);
2474                 vpaes_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2475                                       &octx->ksdec.ks);
2476                 if (!CRYPTO_ocb128_init(&octx->ocb,
2477                                         &octx->ksenc.ks, &octx->ksdec.ks,
2478                                         (block128_f) vpaes_encrypt,
2479                                         (block128_f) vpaes_decrypt,
2480                                         NULL))
2481                     return 0;
2482                 break;
2483             }
2484 # endif
2485             AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2486                                 &octx->ksenc.ks);
2487             AES_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2488                                 &octx->ksdec.ks);
2489             if (!CRYPTO_ocb128_init(&octx->ocb,
2490                                     &octx->ksenc.ks, &octx->ksdec.ks,
2491                                     (block128_f) AES_encrypt,
2492                                     (block128_f) AES_decrypt,
2493                                     NULL))
2494                 return 0;
2495         }
2496         while (0);
2497
2498         /*
2499          * If we have an iv we can set it directly, otherwise use saved IV.
2500          */
2501         if (iv == NULL && octx->iv_set)
2502             iv = octx->iv;
2503         if (iv) {
2504             if (CRYPTO_ocb128_setiv(&octx->ocb, iv, octx->ivlen, octx->taglen)
2505                 != 1)
2506                 return 0;
2507             octx->iv_set = 1;
2508         }
2509         octx->key_set = 1;
2510     } else {
2511         /* If key set use IV, otherwise copy */
2512         if (octx->key_set)
2513             CRYPTO_ocb128_setiv(&octx->ocb, iv, octx->ivlen, octx->taglen);
2514         else
2515             memcpy(octx->iv, iv, octx->ivlen);
2516         octx->iv_set = 1;
2517     }
2518     return 1;
2519 }
2520
2521 static int aes_ocb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2522                           const unsigned char *in, size_t len)
2523 {
2524     unsigned char *buf;
2525     int *buf_len;
2526     int written_len = 0;
2527     size_t trailing_len;
2528     EVP_AES_OCB_CTX *octx = EVP_C_DATA(EVP_AES_OCB_CTX,ctx);
2529
2530     /* If IV or Key not set then return error */
2531     if (!octx->iv_set)
2532         return -1;
2533
2534     if (!octx->key_set)
2535         return -1;
2536
2537     if (in) {
2538         /*
2539          * Need to ensure we are only passing full blocks to low level OCB
2540          * routines. We do it here rather than in EVP_EncryptUpdate/
2541          * EVP_DecryptUpdate because we need to pass full blocks of AAD too
2542          * and those routines don't support that
2543          */
2544
2545         /* Are we dealing with AAD or normal data here? */
2546         if (out == NULL) {
2547             buf = octx->aad_buf;
2548             buf_len = &(octx->aad_buf_len);
2549         } else {
2550             buf = octx->data_buf;
2551             buf_len = &(octx->data_buf_len);
2552         }
2553
2554         /*
2555          * If we've got a partially filled buffer from a previous call then
2556          * use that data first
2557          */
2558         if (*buf_len) {
2559             unsigned int remaining;
2560
2561             remaining = 16 - (*buf_len);
2562             if (remaining > len) {
2563                 memcpy(buf + (*buf_len), in, len);
2564                 *(buf_len) += len;
2565                 return 0;
2566             }
2567             memcpy(buf + (*buf_len), in, remaining);
2568
2569             /*
2570              * If we get here we've filled the buffer, so process it
2571              */
2572             len -= remaining;
2573             in += remaining;
2574             if (out == NULL) {
2575                 if (!CRYPTO_ocb128_aad(&octx->ocb, buf, 16))
2576                     return -1;
2577             } else if (EVP_CIPHER_CTX_encrypting(ctx)) {
2578                 if (!CRYPTO_ocb128_encrypt(&octx->ocb, buf, out, 16))
2579                     return -1;
2580             } else {
2581                 if (!CRYPTO_ocb128_decrypt(&octx->ocb, buf, out, 16))
2582                     return -1;
2583             }
2584             written_len = 16;
2585             *buf_len = 0;
2586         }
2587
2588         /* Do we have a partial block to handle at the end? */
2589         trailing_len = len % 16;
2590
2591         /*
2592          * If we've got some full blocks to handle, then process these first
2593          */
2594         if (len != trailing_len) {
2595             if (out == NULL) {
2596                 if (!CRYPTO_ocb128_aad(&octx->ocb, in, len - trailing_len))
2597                     return -1;
2598             } else if (EVP_CIPHER_CTX_encrypting(ctx)) {
2599                 if (!CRYPTO_ocb128_encrypt
2600                     (&octx->ocb, in, out, len - trailing_len))
2601                     return -1;
2602             } else {
2603                 if (!CRYPTO_ocb128_decrypt
2604                     (&octx->ocb, in, out, len - trailing_len))
2605                     return -1;
2606             }
2607             written_len += len - trailing_len;
2608             in += len - trailing_len;
2609         }
2610
2611         /* Handle any trailing partial block */
2612         if (trailing_len) {
2613             memcpy(buf, in, trailing_len);
2614             *buf_len = trailing_len;
2615         }
2616
2617         return written_len;
2618     } else {
2619         /*
2620          * First of all empty the buffer of any partial block that we might
2621          * have been provided - both for data and AAD
2622          */
2623         if (octx->data_buf_len) {
2624             if (EVP_CIPHER_CTX_encrypting(ctx)) {
2625                 if (!CRYPTO_ocb128_encrypt(&octx->ocb, octx->data_buf, out,
2626                                            octx->data_buf_len))
2627                     return -1;
2628             } else {
2629                 if (!CRYPTO_ocb128_decrypt(&octx->ocb, octx->data_buf, out,
2630                                            octx->data_buf_len))
2631                     return -1;
2632             }
2633             written_len = octx->data_buf_len;
2634             octx->data_buf_len = 0;
2635         }
2636         if (octx->aad_buf_len) {
2637             if (!CRYPTO_ocb128_aad
2638                 (&octx->ocb, octx->aad_buf, octx->aad_buf_len))
2639                 return -1;
2640             octx->aad_buf_len = 0;
2641         }
2642         /* If decrypting then verify */
2643         if (!EVP_CIPHER_CTX_encrypting(ctx)) {
2644             if (octx->taglen < 0)
2645                 return -1;
2646             if (CRYPTO_ocb128_finish(&octx->ocb,
2647                                      octx->tag, octx->taglen) != 0)
2648                 return -1;
2649             octx->iv_set = 0;
2650             return written_len;
2651         }
2652         /* If encrypting then just get the tag */
2653         if (CRYPTO_ocb128_tag(&octx->ocb, octx->tag, 16) != 1)
2654             return -1;
2655         /* Don't reuse the IV */
2656         octx->iv_set = 0;
2657         return written_len;
2658     }
2659 }
2660
2661 static int aes_ocb_cleanup(EVP_CIPHER_CTX *c)
2662 {
2663     EVP_AES_OCB_CTX *octx = EVP_C_DATA(EVP_AES_OCB_CTX,c);
2664     CRYPTO_ocb128_cleanup(&octx->ocb);
2665     return 1;
2666 }
2667
2668 BLOCK_CIPHER_custom(NID_aes, 128, 16, 12, ocb, OCB,
2669                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
2670 BLOCK_CIPHER_custom(NID_aes, 192, 16, 12, ocb, OCB,
2671                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
2672 BLOCK_CIPHER_custom(NID_aes, 256, 16, 12, ocb, OCB,
2673                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
2674 #endif                         /* OPENSSL_NO_OCB */