crypto/evp/e_aes.c

   1 /*
   2  * Copyright 2001-2019 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (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 "internal/cryptlib.h"
  19 #include "modes_lcl.h"
  20 #include <openssl/rand.h>
  21 #include <openssl/cmac.h>
  22 #include "evp_locl.h"
  23
  24 typedef struct {
  25     union {
  26         OSSL_UNION_ALIGN;
  27         AES_KEY ks;
  28     } ks;
  29     block128_f block;
  30     union {
  31         cbc128_f cbc;
  32         ctr128_f ctr;
  33     } stream;
  34 } EVP_AES_KEY;
  35
  36 typedef struct {
  37     union {
  38         OSSL_UNION_ALIGN;
  39         AES_KEY ks;
  40     } ks;                       /* AES key schedule to use */
  41     int key_set;                /* Set if key initialised */
  42     int iv_set;                 /* Set if an iv is set */
  43     GCM128_CONTEXT gcm;
  44     unsigned char *iv;          /* Temporary IV store */
  45     int ivlen;                  /* IV length */
  46     int taglen;
  47     int iv_gen;                 /* It is OK to generate IVs */
  48     int iv_gen_rand;            /* No IV was specified, so generate a rand IV */
  49     int tls_aad_len;            /* TLS AAD length */
  50     uint64_t tls_enc_records;   /* Number of TLS records encrypted */
  51     ctr128_f ctr;
  52 } EVP_AES_GCM_CTX;
  53
  54 typedef struct {
  55     union {
  56         OSSL_UNION_ALIGN;
  57         AES_KEY ks;
  58     } ks1, ks2;                 /* AES key schedules to use */
  59     XTS128_CONTEXT xts;
  60     void (*stream) (const unsigned char *in,
  61                     unsigned char *out, size_t length,
  62                     const AES_KEY *key1, const AES_KEY *key2,
  63                     const unsigned char iv[16]);
  64 } EVP_AES_XTS_CTX;
  65
  66 typedef struct {
  67     union {
  68         OSSL_UNION_ALIGN;
  69         AES_KEY ks;
  70     } ks;                       /* AES key schedule to use */
  71     int key_set;                /* Set if key initialised */
  72     int iv_set;                 /* Set if an iv is set */
  73     int tag_set;                /* Set if tag is valid */
  74     int len_set;                /* Set if message length set */
  75     int L, M;                   /* L and M parameters from RFC3610 */
  76     int tls_aad_len;            /* TLS AAD length */
  77     CCM128_CONTEXT ccm;
  78     ccm128_f str;
  79 } EVP_AES_CCM_CTX;
  80
  81 #ifndef OPENSSL_NO_OCB
  82 typedef struct {
  83     union {
  84         OSSL_UNION_ALIGN;
  85         AES_KEY ks;
  86     } ksenc;                    /* AES key schedule to use for encryption */
  87     union {
  88         OSSL_UNION_ALIGN;
  89         AES_KEY ks;
  90     } ksdec;                    /* AES key schedule to use for decryption */
  91     int key_set;                /* Set if key initialised */
  92     int iv_set;                 /* Set if an iv is set */
  93     OCB128_CONTEXT ocb;
  94     unsigned char *iv;          /* Temporary IV store */
  95     unsigned char tag[16];
  96     unsigned char data_buf[16]; /* Store partial data blocks */
  97     unsigned char aad_buf[16];  /* Store partial AAD blocks */
  98     int data_buf_len;
  99     int aad_buf_len;
 100     int ivlen;                  /* IV length */
 101     int taglen;
 102 } EVP_AES_OCB_CTX;
 103 #endif
 104
 105 #define MAXBITCHUNK     ((size_t)1<<(sizeof(size_t)*8-4))
 106
 107 #ifdef VPAES_ASM
 108 int vpaes_set_encrypt_key(const unsigned char *userKey, int bits,
 109                           AES_KEY *key);
 110 int vpaes_set_decrypt_key(const unsigned char *userKey, int bits,
 111                           AES_KEY *key);
 112
 113 void vpaes_encrypt(const unsigned char *in, unsigned char *out,
 114                    const AES_KEY *key);
 115 void vpaes_decrypt(const unsigned char *in, unsigned char *out,
 116                    const AES_KEY *key);
 117
 118 void vpaes_cbc_encrypt(const unsigned char *in,
 119                        unsigned char *out,
 120                        size_t length,
 121                        const AES_KEY *key, unsigned char *ivec, int enc);
 122 #endif
 123 #ifdef BSAES_ASM
 124 void bsaes_cbc_encrypt(const unsigned char *in, unsigned char *out,
 125                        size_t length, const AES_KEY *key,
 126                        unsigned char ivec[16], int enc);
 127 void bsaes_ctr32_encrypt_blocks(const unsigned char *in, unsigned char *out,
 128                                 size_t len, const AES_KEY *key,
 129                                 const unsigned char ivec[16]);
 130 void bsaes_xts_encrypt(const unsigned char *inp, unsigned char *out,
 131                        size_t len, const AES_KEY *key1,
 132                        const AES_KEY *key2, const unsigned char iv[16]);
 133 void bsaes_xts_decrypt(const unsigned char *inp, unsigned char *out,
 134                        size_t len, const AES_KEY *key1,
 135                        const AES_KEY *key2, const unsigned char iv[16]);
 136 #endif
 137 #ifdef AES_CTR_ASM
 138 void AES_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 139                        size_t blocks, const AES_KEY *key,
 140                        const unsigned char ivec[AES_BLOCK_SIZE]);
 141 #endif
 142 #ifdef AES_XTS_ASM
 143 void AES_xts_encrypt(const unsigned char *inp, unsigned char *out, size_t len,
 144                      const AES_KEY *key1, const AES_KEY *key2,
 145                      const unsigned char iv[16]);
 146 void AES_xts_decrypt(const unsigned char *inp, unsigned char *out, size_t len,
 147                      const AES_KEY *key1, const AES_KEY *key2,
 148                      const unsigned char iv[16]);
 149 #endif
 150
 151 /* increment counter (64-bit int) by 1 */
 152 static void ctr64_inc(unsigned char *counter)
 153 {
 154     int n = 8;
 155     unsigned char c;
 156
 157     do {
 158         --n;
 159         c = counter[n];
 160         ++c;
 161         counter[n] = c;
 162         if (c)
 163             return;
 164     } while (n);
 165 }
 166
 167 #if defined(OPENSSL_CPUID_OBJ) && (defined(__powerpc__) || defined(__ppc__) || defined(_ARCH_PPC))
 168 # include "ppc_arch.h"
 169 # ifdef VPAES_ASM
 170 #  define VPAES_CAPABLE (OPENSSL_ppccap_P & PPC_ALTIVEC)
 171 # endif
 172 # define HWAES_CAPABLE  (OPENSSL_ppccap_P & PPC_CRYPTO207)
 173 # define HWAES_set_encrypt_key aes_p8_set_encrypt_key
 174 # define HWAES_set_decrypt_key aes_p8_set_decrypt_key
 175 # define HWAES_encrypt aes_p8_encrypt
 176 # define HWAES_decrypt aes_p8_decrypt
 177 # define HWAES_cbc_encrypt aes_p8_cbc_encrypt
 178 # define HWAES_ctr32_encrypt_blocks aes_p8_ctr32_encrypt_blocks
 179 # define HWAES_xts_encrypt aes_p8_xts_encrypt
 180 # define HWAES_xts_decrypt aes_p8_xts_decrypt
 181 #endif
 182
 183 #if     defined(AES_ASM) && !defined(I386_ONLY) &&      (  \
 184         ((defined(__i386)       || defined(__i386__)    || \
 185           defined(_M_IX86)) && defined(OPENSSL_IA32_SSE2))|| \
 186         defined(__x86_64)       || defined(__x86_64__)  || \
 187         defined(_M_AMD64)       || defined(_M_X64)      )
 188
 189 extern unsigned int OPENSSL_ia32cap_P[];
 190
 191 # ifdef VPAES_ASM
 192 #  define VPAES_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(41-32)))
 193 # endif
 194 # ifdef BSAES_ASM
 195 #  define BSAES_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(41-32)))
 196 # endif
 197 /*
 198  * AES-NI section
 199  */
 200 # define AESNI_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(57-32)))
 201
 202 int aesni_set_encrypt_key(const unsigned char *userKey, int bits,
 203                           AES_KEY *key);
 204 int aesni_set_decrypt_key(const unsigned char *userKey, int bits,
 205                           AES_KEY *key);
 206
 207 void aesni_encrypt(const unsigned char *in, unsigned char *out,
 208                    const AES_KEY *key);
 209 void aesni_decrypt(const unsigned char *in, unsigned char *out,
 210                    const AES_KEY *key);
 211
 212 void aesni_ecb_encrypt(const unsigned char *in,
 213                        unsigned char *out,
 214                        size_t length, const AES_KEY *key, int enc);
 215 void aesni_cbc_encrypt(const unsigned char *in,
 216                        unsigned char *out,
 217                        size_t length,
 218                        const AES_KEY *key, unsigned char *ivec, int enc);
 219
 220 void aesni_ctr32_encrypt_blocks(const unsigned char *in,
 221                                 unsigned char *out,
 222                                 size_t blocks,
 223                                 const void *key, const unsigned char *ivec);
 224
 225 void aesni_xts_encrypt(const unsigned char *in,
 226                        unsigned char *out,
 227                        size_t length,
 228                        const AES_KEY *key1, const AES_KEY *key2,
 229                        const unsigned char iv[16]);
 230
 231 void aesni_xts_decrypt(const unsigned char *in,
 232                        unsigned char *out,
 233                        size_t length,
 234                        const AES_KEY *key1, const AES_KEY *key2,
 235                        const unsigned char iv[16]);
 236
 237 void aesni_ccm64_encrypt_blocks(const unsigned char *in,
 238                                 unsigned char *out,
 239                                 size_t blocks,
 240                                 const void *key,
 241                                 const unsigned char ivec[16],
 242                                 unsigned char cmac[16]);
 243
 244 void aesni_ccm64_decrypt_blocks(const unsigned char *in,
 245                                 unsigned char *out,
 246                                 size_t blocks,
 247                                 const void *key,
 248                                 const unsigned char ivec[16],
 249                                 unsigned char cmac[16]);
 250
 251 # if defined(__x86_64) || defined(__x86_64__) || defined(_M_AMD64) || defined(_M_X64)
 252 size_t aesni_gcm_encrypt(const unsigned char *in,
 253                          unsigned char *out,
 254                          size_t len,
 255                          const void *key, unsigned char ivec[16], u64 *Xi);
 256 #  define AES_gcm_encrypt aesni_gcm_encrypt
 257 size_t aesni_gcm_decrypt(const unsigned char *in,
 258                          unsigned char *out,
 259                          size_t len,
 260                          const void *key, unsigned char ivec[16], u64 *Xi);
 261 #  define AES_gcm_decrypt aesni_gcm_decrypt
 262 void gcm_ghash_avx(u64 Xi[2], const u128 Htable[16], const u8 *in,
 263                    size_t len);
 264 #  define AES_GCM_ASM(gctx)       (gctx->ctr==aesni_ctr32_encrypt_blocks && \
 265                                  gctx->gcm.ghash==gcm_ghash_avx)
 266 #  define AES_GCM_ASM2(gctx)      (gctx->gcm.block==(block128_f)aesni_encrypt && \
 267                                  gctx->gcm.ghash==gcm_ghash_avx)
 268 #  undef AES_GCM_ASM2          /* minor size optimization */
 269 # endif
 270
 271 static int aesni_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 272                           const unsigned char *iv, int enc)
 273 {
 274     int ret, mode;
 275     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
 276
 277     mode = EVP_CIPHER_CTX_mode(ctx);
 278     if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
 279         && !enc) {
 280         ret = aesni_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 281                                     &dat->ks.ks);
 282         dat->block = (block128_f) aesni_decrypt;
 283         dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 284             (cbc128_f) aesni_cbc_encrypt : NULL;
 285     } else {
 286         ret = aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 287                                     &dat->ks.ks);
 288         dat->block = (block128_f) aesni_encrypt;
 289         if (mode == EVP_CIPH_CBC_MODE)
 290             dat->stream.cbc = (cbc128_f) aesni_cbc_encrypt;
 291         else if (mode == EVP_CIPH_CTR_MODE)
 292             dat->stream.ctr = (ctr128_f) aesni_ctr32_encrypt_blocks;
 293         else
 294             dat->stream.cbc = NULL;
 295     }
 296
 297     if (ret < 0) {
 298         EVPerr(EVP_F_AESNI_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
 299         return 0;
 300     }
 301
 302     return 1;
 303 }
 304
 305 static int aesni_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 306                             const unsigned char *in, size_t len)
 307 {
 308     aesni_cbc_encrypt(in, out, len, &EVP_C_DATA(EVP_AES_KEY,ctx)->ks.ks,
 309                       EVP_CIPHER_CTX_iv_noconst(ctx),
 310                       EVP_CIPHER_CTX_encrypting(ctx));
 311
 312     return 1;
 313 }
 314
 315 static int aesni_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 316                             const unsigned char *in, size_t len)
 317 {
 318     size_t bl = EVP_CIPHER_CTX_block_size(ctx);
 319
 320     if (len < bl)
 321         return 1;
 322
 323     aesni_ecb_encrypt(in, out, len, &EVP_C_DATA(EVP_AES_KEY,ctx)->ks.ks,
 324                       EVP_CIPHER_CTX_encrypting(ctx));
 325
 326     return 1;
 327 }
 328
 329 # define aesni_ofb_cipher aes_ofb_cipher
 330 static int aesni_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 331                             const unsigned char *in, size_t len);
 332
 333 # define aesni_cfb_cipher aes_cfb_cipher
 334 static int aesni_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 335                             const unsigned char *in, size_t len);
 336
 337 # define aesni_cfb8_cipher aes_cfb8_cipher
 338 static int aesni_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 339                              const unsigned char *in, size_t len);
 340
 341 # define aesni_cfb1_cipher aes_cfb1_cipher
 342 static int aesni_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 343                              const unsigned char *in, size_t len);
 344
 345 # define aesni_ctr_cipher aes_ctr_cipher
 346 static int aesni_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 347                             const unsigned char *in, size_t len);
 348
 349 static int aesni_gcm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 350                               const unsigned char *iv, int enc)
 351 {
 352     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,ctx);
 353     if (!iv && !key)
 354         return 1;
 355     if (key) {
 356         aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 357                               &gctx->ks.ks);
 358         CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks, (block128_f) aesni_encrypt);
 359         gctx->ctr = (ctr128_f) aesni_ctr32_encrypt_blocks;
 360         /*
 361          * If we have an iv can set it directly, otherwise use saved IV.
 362          */
 363         if (iv == NULL && gctx->iv_set)
 364             iv = gctx->iv;
 365         if (iv) {
 366             CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 367             gctx->iv_set = 1;
 368         }
 369         gctx->key_set = 1;
 370     } else {
 371         /* If key set use IV, otherwise copy */
 372         if (gctx->key_set)
 373             CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 374         else
 375             memcpy(gctx->iv, iv, gctx->ivlen);
 376         gctx->iv_set = 1;
 377         gctx->iv_gen = 0;
 378     }
 379     return 1;
 380 }
 381
 382 # define aesni_gcm_cipher aes_gcm_cipher
 383 static int aesni_gcm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 384                             const unsigned char *in, size_t len);
 385
 386 static int aesni_xts_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 387                               const unsigned char *iv, int enc)
 388 {
 389     EVP_AES_XTS_CTX *xctx = EVP_C_DATA(EVP_AES_XTS_CTX,ctx);
 390     if (!iv && !key)
 391         return 1;
 392
 393     if (key) {
 394         /* The key is two half length keys in reality */
 395         const int bytes = EVP_CIPHER_CTX_key_length(ctx) / 2;
 396         const int bits = bytes * 8;
 397
 398         /*
 399          * Verify that the two keys are different.
 400          *
 401          * This addresses Rogaway's vulnerability.
 402          * See comment in aes_xts_init_key() below.
 403          */
 404         if (memcmp(key, key + bytes, bytes) == 0) {
 405             EVPerr(EVP_F_AESNI_XTS_INIT_KEY, EVP_R_XTS_DUPLICATED_KEYS);
 406             return 0;
 407         }
 408
 409         /* key_len is two AES keys */
 410         if (enc) {
 411             aesni_set_encrypt_key(key, bits, &xctx->ks1.ks);
 412             xctx->xts.block1 = (block128_f) aesni_encrypt;
 413             xctx->stream = aesni_xts_encrypt;
 414         } else {
 415             aesni_set_decrypt_key(key, bits, &xctx->ks1.ks);
 416             xctx->xts.block1 = (block128_f) aesni_decrypt;
 417             xctx->stream = aesni_xts_decrypt;
 418         }
 419
 420         aesni_set_encrypt_key(key + bytes, bits, &xctx->ks2.ks);
 421         xctx->xts.block2 = (block128_f) aesni_encrypt;
 422
 423         xctx->xts.key1 = &xctx->ks1;
 424     }
 425
 426     if (iv) {
 427         xctx->xts.key2 = &xctx->ks2;
 428         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 16);
 429     }
 430
 431     return 1;
 432 }
 433
 434 # define aesni_xts_cipher aes_xts_cipher
 435 static int aesni_xts_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 436                             const unsigned char *in, size_t len);
 437
 438 static int aesni_ccm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 439                               const unsigned char *iv, int enc)
 440 {
 441     EVP_AES_CCM_CTX *cctx = EVP_C_DATA(EVP_AES_CCM_CTX,ctx);
 442     if (!iv && !key)
 443         return 1;
 444     if (key) {
 445         aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 446                               &cctx->ks.ks);
 447         CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
 448                            &cctx->ks, (block128_f) aesni_encrypt);
 449         cctx->str = enc ? (ccm128_f) aesni_ccm64_encrypt_blocks :
 450             (ccm128_f) aesni_ccm64_decrypt_blocks;
 451         cctx->key_set = 1;
 452     }
 453     if (iv) {
 454         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 15 - cctx->L);
 455         cctx->iv_set = 1;
 456     }
 457     return 1;
 458 }
 459
 460 # define aesni_ccm_cipher aes_ccm_cipher
 461 static int aesni_ccm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 462                             const unsigned char *in, size_t len);
 463
 464 # ifndef OPENSSL_NO_OCB
 465 void aesni_ocb_encrypt(const unsigned char *in, unsigned char *out,
 466                        size_t blocks, const void *key,
 467                        size_t start_block_num,
 468                        unsigned char offset_i[16],
 469                        const unsigned char L_[][16],
 470                        unsigned char checksum[16]);
 471 void aesni_ocb_decrypt(const unsigned char *in, unsigned char *out,
 472                        size_t blocks, const void *key,
 473                        size_t start_block_num,
 474                        unsigned char offset_i[16],
 475                        const unsigned char L_[][16],
 476                        unsigned char checksum[16]);
 477
 478 static int aesni_ocb_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 479                               const unsigned char *iv, int enc)
 480 {
 481     EVP_AES_OCB_CTX *octx = EVP_C_DATA(EVP_AES_OCB_CTX,ctx);
 482     if (!iv && !key)
 483         return 1;
 484     if (key) {
 485         do {
 486             /*
 487              * We set both the encrypt and decrypt key here because decrypt
 488              * needs both. We could possibly optimise to remove setting the
 489              * decrypt for an encryption operation.
 490              */
 491             aesni_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 492                                   &octx->ksenc.ks);
 493             aesni_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 494                                   &octx->ksdec.ks);
 495             if (!CRYPTO_ocb128_init(&octx->ocb,
 496                                     &octx->ksenc.ks, &octx->ksdec.ks,
 497                                     (block128_f) aesni_encrypt,
 498                                     (block128_f) aesni_decrypt,
 499                                     enc ? aesni_ocb_encrypt
 500                                         : aesni_ocb_decrypt))
 501                 return 0;
 502         }
 503         while (0);
 504
 505         /*
 506          * If we have an iv we can set it directly, otherwise use saved IV.
 507          */
 508         if (iv == NULL && octx->iv_set)
 509             iv = octx->iv;
 510         if (iv) {
 511             if (CRYPTO_ocb128_setiv(&octx->ocb, iv, octx->ivlen, octx->taglen)
 512                 != 1)
 513                 return 0;
 514             octx->iv_set = 1;
 515         }
 516         octx->key_set = 1;
 517     } else {
 518         /* If key set use IV, otherwise copy */
 519         if (octx->key_set)
 520             CRYPTO_ocb128_setiv(&octx->ocb, iv, octx->ivlen, octx->taglen);
 521         else
 522             memcpy(octx->iv, iv, octx->ivlen);
 523         octx->iv_set = 1;
 524     }
 525     return 1;
 526 }
 527
 528 #  define aesni_ocb_cipher aes_ocb_cipher
 529 static int aesni_ocb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 530                             const unsigned char *in, size_t len);
 531 # endif                        /* OPENSSL_NO_OCB */
 532
 533 # define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \
 534 static const EVP_CIPHER aesni_##keylen##_##mode = { \
 535         nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \
 536         flags|EVP_CIPH_##MODE##_MODE,   \
 537         aesni_init_key,                 \
 538         aesni_##mode##_cipher,          \
 539         NULL,                           \
 540         sizeof(EVP_AES_KEY),            \
 541         NULL,NULL,NULL,NULL }; \
 542 static const EVP_CIPHER aes_##keylen##_##mode = { \
 543         nid##_##keylen##_##nmode,blocksize,     \
 544         keylen/8,ivlen, \
 545         flags|EVP_CIPH_##MODE##_MODE,   \
 546         aes_init_key,                   \
 547         aes_##mode##_cipher,            \
 548         NULL,                           \
 549         sizeof(EVP_AES_KEY),            \
 550         NULL,NULL,NULL,NULL }; \
 551 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 552 { return AESNI_CAPABLE?&aesni_##keylen##_##mode:&aes_##keylen##_##mode; }
 553
 554 # define BLOCK_CIPHER_custom(nid,keylen,blocksize,ivlen,mode,MODE,flags) \
 555 static const EVP_CIPHER aesni_##keylen##_##mode = { \
 556         nid##_##keylen##_##mode,blocksize, \
 557         (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE||EVP_CIPH_##MODE##_MODE==EVP_CIPH_SIV_MODE?2:1)*keylen/8, \
 558         ivlen,                          \
 559         flags|EVP_CIPH_##MODE##_MODE,   \
 560         aesni_##mode##_init_key,        \
 561         aesni_##mode##_cipher,          \
 562         aes_##mode##_cleanup,           \
 563         sizeof(EVP_AES_##MODE##_CTX),   \
 564         NULL,NULL,aes_##mode##_ctrl,NULL }; \
 565 static const EVP_CIPHER aes_##keylen##_##mode = { \
 566         nid##_##keylen##_##mode,blocksize, \
 567         (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE||EVP_CIPH_##MODE##_MODE==EVP_CIPH_SIV_MODE?2:1)*keylen/8, \
 568         ivlen,                          \
 569         flags|EVP_CIPH_##MODE##_MODE,   \
 570         aes_##mode##_init_key,          \
 571         aes_##mode##_cipher,            \
 572         aes_##mode##_cleanup,           \
 573         sizeof(EVP_AES_##MODE##_CTX),   \
 574         NULL,NULL,aes_##mode##_ctrl,NULL }; \
 575 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 576 { return AESNI_CAPABLE?&aesni_##keylen##_##mode:&aes_##keylen##_##mode; }
 577
 578 #elif   defined(AES_ASM) && (defined(__sparc) || defined(__sparc__))
 579
 580 # include "sparc_arch.h"
 581
 582 extern unsigned int OPENSSL_sparcv9cap_P[];
 583
 584 /*
 585  * Initial Fujitsu SPARC64 X support
 586  */
 587 # define HWAES_CAPABLE           (OPENSSL_sparcv9cap_P[0] & SPARCV9_FJAESX)
 588 # define HWAES_set_encrypt_key aes_fx_set_encrypt_key
 589 # define HWAES_set_decrypt_key aes_fx_set_decrypt_key
 590 # define HWAES_encrypt aes_fx_encrypt
 591 # define HWAES_decrypt aes_fx_decrypt
 592 # define HWAES_cbc_encrypt aes_fx_cbc_encrypt
 593 # define HWAES_ctr32_encrypt_blocks aes_fx_ctr32_encrypt_blocks
 594
 595 # define SPARC_AES_CAPABLE       (OPENSSL_sparcv9cap_P[1] & CFR_AES)
 596
 597 void aes_t4_set_encrypt_key(const unsigned char *key, int bits, AES_KEY *ks);
 598 void aes_t4_set_decrypt_key(const unsigned char *key, int bits, AES_KEY *ks);
 599 void aes_t4_encrypt(const unsigned char *in, unsigned char *out,
 600                     const AES_KEY *key);
 601 void aes_t4_decrypt(const unsigned char *in, unsigned char *out,
 602                     const AES_KEY *key);
 603 /*
 604  * Key-length specific subroutines were chosen for following reason.
 605  * Each SPARC T4 core can execute up to 8 threads which share core's
 606  * resources. Loading as much key material to registers allows to
 607  * minimize references to shared memory interface, as well as amount
 608  * of instructions in inner loops [much needed on T4]. But then having
 609  * non-key-length specific routines would require conditional branches
 610  * either in inner loops or on subroutines' entries. Former is hardly
 611  * acceptable, while latter means code size increase to size occupied
 612  * by multiple key-length specific subroutines, so why fight?
 613  */
 614 void aes128_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
 615                            size_t len, const AES_KEY *key,
 616                            unsigned char *ivec);
 617 void aes128_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
 618                            size_t len, const AES_KEY *key,
 619                            unsigned char *ivec);
 620 void aes192_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
 621                            size_t len, const AES_KEY *key,
 622                            unsigned char *ivec);
 623 void aes192_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
 624                            size_t len, const AES_KEY *key,
 625                            unsigned char *ivec);
 626 void aes256_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
 627                            size_t len, const AES_KEY *key,
 628                            unsigned char *ivec);
 629 void aes256_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
 630                            size_t len, const AES_KEY *key,
 631                            unsigned char *ivec);
 632 void aes128_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 633                              size_t blocks, const AES_KEY *key,
 634                              unsigned char *ivec);
 635 void aes192_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 636                              size_t blocks, const AES_KEY *key,
 637                              unsigned char *ivec);
 638 void aes256_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 639                              size_t blocks, const AES_KEY *key,
 640                              unsigned char *ivec);
 641 void aes128_t4_xts_encrypt(const unsigned char *in, unsigned char *out,
 642                            size_t blocks, const AES_KEY *key1,
 643                            const AES_KEY *key2, const unsigned char *ivec);
 644 void aes128_t4_xts_decrypt(const unsigned char *in, unsigned char *out,
 645                            size_t blocks, const AES_KEY *key1,
 646                            const AES_KEY *key2, const unsigned char *ivec);
 647 void aes256_t4_xts_encrypt(const unsigned char *in, unsigned char *out,
 648                            size_t blocks, const AES_KEY *key1,
 649                            const AES_KEY *key2, const unsigned char *ivec);
 650 void aes256_t4_xts_decrypt(const unsigned char *in, unsigned char *out,
 651                            size_t blocks, const AES_KEY *key1,
 652                            const AES_KEY *key2, const unsigned char *ivec);
 653
 654 static int aes_t4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 655                            const unsigned char *iv, int enc)
 656 {
 657     int ret, mode, bits;
 658     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
 659
 660     mode = EVP_CIPHER_CTX_mode(ctx);
 661     bits = EVP_CIPHER_CTX_key_length(ctx) * 8;
 662     if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
 663         && !enc) {
 664         ret = 0;
 665         aes_t4_set_decrypt_key(key, bits, &dat->ks.ks);
 666         dat->block = (block128_f) aes_t4_decrypt;
 667         switch (bits) {
 668         case 128:
 669             dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 670                 (cbc128_f) aes128_t4_cbc_decrypt : NULL;
 671             break;
 672         case 192:
 673             dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 674                 (cbc128_f) aes192_t4_cbc_decrypt : NULL;
 675             break;
 676         case 256:
 677             dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 678                 (cbc128_f) aes256_t4_cbc_decrypt : NULL;
 679             break;
 680         default:
 681             ret = -1;
 682         }
 683     } else {
 684         ret = 0;
 685         aes_t4_set_encrypt_key(key, bits, &dat->ks.ks);
 686         dat->block = (block128_f) aes_t4_encrypt;
 687         switch (bits) {
 688         case 128:
 689             if (mode == EVP_CIPH_CBC_MODE)
 690                 dat->stream.cbc = (cbc128_f) aes128_t4_cbc_encrypt;
 691             else if (mode == EVP_CIPH_CTR_MODE)
 692                 dat->stream.ctr = (ctr128_f) aes128_t4_ctr32_encrypt;
 693             else
 694                 dat->stream.cbc = NULL;
 695             break;
 696         case 192:
 697             if (mode == EVP_CIPH_CBC_MODE)
 698                 dat->stream.cbc = (cbc128_f) aes192_t4_cbc_encrypt;
 699             else if (mode == EVP_CIPH_CTR_MODE)
 700                 dat->stream.ctr = (ctr128_f) aes192_t4_ctr32_encrypt;
 701             else
 702                 dat->stream.cbc = NULL;
 703             break;
 704         case 256:
 705             if (mode == EVP_CIPH_CBC_MODE)
 706                 dat->stream.cbc = (cbc128_f) aes256_t4_cbc_encrypt;
 707             else if (mode == EVP_CIPH_CTR_MODE)
 708                 dat->stream.ctr = (ctr128_f) aes256_t4_ctr32_encrypt;
 709             else
 710                 dat->stream.cbc = NULL;
 711             break;
 712         default:
 713             ret = -1;
 714         }
 715     }
 716
 717     if (ret < 0) {
 718         EVPerr(EVP_F_AES_T4_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
 719         return 0;
 720     }
 721
 722     return 1;
 723 }
 724
 725 # define aes_t4_cbc_cipher aes_cbc_cipher
 726 static int aes_t4_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 727                              const unsigned char *in, size_t len);
 728
 729 # define aes_t4_ecb_cipher aes_ecb_cipher
 730 static int aes_t4_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 731                              const unsigned char *in, size_t len);
 732
 733 # define aes_t4_ofb_cipher aes_ofb_cipher
 734 static int aes_t4_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 735                              const unsigned char *in, size_t len);
 736
 737 # define aes_t4_cfb_cipher aes_cfb_cipher
 738 static int aes_t4_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 739                              const unsigned char *in, size_t len);
 740
 741 # define aes_t4_cfb8_cipher aes_cfb8_cipher
 742 static int aes_t4_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 743                               const unsigned char *in, size_t len);
 744
 745 # define aes_t4_cfb1_cipher aes_cfb1_cipher
 746 static int aes_t4_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 747                               const unsigned char *in, size_t len);
 748
 749 # define aes_t4_ctr_cipher aes_ctr_cipher
 750 static int aes_t4_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 751                              const unsigned char *in, size_t len);
 752
 753 static int aes_t4_gcm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 754                                const unsigned char *iv, int enc)
 755 {
 756     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,ctx);
 757     if (!iv && !key)
 758         return 1;
 759     if (key) {
 760         int bits = EVP_CIPHER_CTX_key_length(ctx) * 8;
 761         aes_t4_set_encrypt_key(key, bits, &gctx->ks.ks);
 762         CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
 763                            (block128_f) aes_t4_encrypt);
 764         switch (bits) {
 765         case 128:
 766             gctx->ctr = (ctr128_f) aes128_t4_ctr32_encrypt;
 767             break;
 768         case 192:
 769             gctx->ctr = (ctr128_f) aes192_t4_ctr32_encrypt;
 770             break;
 771         case 256:
 772             gctx->ctr = (ctr128_f) aes256_t4_ctr32_encrypt;
 773             break;
 774         default:
 775             return 0;
 776         }
 777         /*
 778          * If we have an iv can set it directly, otherwise use saved IV.
 779          */
 780         if (iv == NULL && gctx->iv_set)
 781             iv = gctx->iv;
 782         if (iv) {
 783             CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 784             gctx->iv_set = 1;
 785         }
 786         gctx->key_set = 1;
 787     } else {
 788         /* If key set use IV, otherwise copy */
 789         if (gctx->key_set)
 790             CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 791         else
 792             memcpy(gctx->iv, iv, gctx->ivlen);
 793         gctx->iv_set = 1;
 794         gctx->iv_gen = 0;
 795     }
 796     return 1;
 797 }
 798
 799 # define aes_t4_gcm_cipher aes_gcm_cipher
 800 static int aes_t4_gcm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 801                              const unsigned char *in, size_t len);
 802
 803 static int aes_t4_xts_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 804                                const unsigned char *iv, int enc)
 805 {
 806     EVP_AES_XTS_CTX *xctx = EVP_C_DATA(EVP_AES_XTS_CTX,ctx);
 807     if (!iv && !key)
 808         return 1;
 809
 810     if (key) {
 811         /* The key is two half length keys in reality */
 812         const int bytes = EVP_CIPHER_CTX_key_length(ctx) / 2;
 813         const int bits = bytes * 8;
 814
 815         /*
 816          * Verify that the two keys are different.
 817          *
 818          * This addresses Rogaway's vulnerability.
 819          * See comment in aes_xts_init_key() below.
 820          */
 821         if (memcmp(key, key + bytes, bytes) == 0) {
 822             EVPerr(EVP_F_AES_T4_XTS_INIT_KEY, EVP_R_XTS_DUPLICATED_KEYS);
 823             return 0;
 824         }
 825
 826         xctx->stream = NULL;
 827         /* key_len is two AES keys */
 828         if (enc) {
 829             aes_t4_set_encrypt_key(key, bits, &xctx->ks1.ks);
 830             xctx->xts.block1 = (block128_f) aes_t4_encrypt;
 831             switch (bits) {
 832             case 128:
 833                 xctx->stream = aes128_t4_xts_encrypt;
 834                 break;
 835             case 256:
 836                 xctx->stream = aes256_t4_xts_encrypt;
 837                 break;
 838             default:
 839                 return 0;
 840             }
 841         } else {
 842             aes_t4_set_decrypt_key(key, bits, &xctx->ks1.ks);
 843             xctx->xts.block1 = (block128_f) aes_t4_decrypt;
 844             switch (bits) {
 845             case 128:
 846                 xctx->stream = aes128_t4_xts_decrypt;
 847                 break;
 848             case 256:
 849                 xctx->stream = aes256_t4_xts_decrypt;
 850                 break;
 851             default:
 852                 return 0;
 853             }
 854         }
 855
 856         aes_t4_set_encrypt_key(key + bytes, bits, &xctx->ks2.ks);
 857         xctx->xts.block2 = (block128_f) aes_t4_encrypt;
 858
 859         xctx->xts.key1 = &xctx->ks1;
 860     }
 861
 862     if (iv) {
 863         xctx->xts.key2 = &xctx->ks2;
 864         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 16);
 865     }
 866
 867     return 1;
 868 }
 869
 870 # define aes_t4_xts_cipher aes_xts_cipher
 871 static int aes_t4_xts_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 872                              const unsigned char *in, size_t len);
 873
 874 static int aes_t4_ccm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 875                                const unsigned char *iv, int enc)
 876 {
 877     EVP_AES_CCM_CTX *cctx = EVP_C_DATA(EVP_AES_CCM_CTX,ctx);
 878     if (!iv && !key)
 879         return 1;
 880     if (key) {
 881         int bits = EVP_CIPHER_CTX_key_length(ctx) * 8;
 882         aes_t4_set_encrypt_key(key, bits, &cctx->ks.ks);
 883         CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
 884                            &cctx->ks, (block128_f) aes_t4_encrypt);
 885         cctx->str = NULL;
 886         cctx->key_set = 1;
 887     }
 888     if (iv) {
 889         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 15 - cctx->L);
 890         cctx->iv_set = 1;
 891     }
 892     return 1;
 893 }
 894
 895 # define aes_t4_ccm_cipher aes_ccm_cipher
 896 static int aes_t4_ccm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 897                              const unsigned char *in, size_t len);
 898
 899 # ifndef OPENSSL_NO_OCB
 900 static int aes_t4_ocb_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 901                                const unsigned char *iv, int enc)
 902 {
 903     EVP_AES_OCB_CTX *octx = EVP_C_DATA(EVP_AES_OCB_CTX,ctx);
 904     if (!iv && !key)
 905         return 1;
 906     if (key) {
 907         do {
 908             /*
 909              * We set both the encrypt and decrypt key here because decrypt
 910              * needs both. We could possibly optimise to remove setting the
 911              * decrypt for an encryption operation.
 912              */
 913             aes_t4_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 914                                    &octx->ksenc.ks);
 915             aes_t4_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
 916                                    &octx->ksdec.ks);
 917             if (!CRYPTO_ocb128_init(&octx->ocb,
 918                                     &octx->ksenc.ks, &octx->ksdec.ks,
 919                                     (block128_f) aes_t4_encrypt,
 920                                     (block128_f) aes_t4_decrypt,
 921                                     NULL))
 922                 return 0;
 923         }
 924         while (0);
 925
 926         /*
 927          * If we have an iv we can set it directly, otherwise use saved IV.
 928          */
 929         if (iv == NULL && octx->iv_set)
 930             iv = octx->iv;
 931         if (iv) {
 932             if (CRYPTO_ocb128_setiv(&octx->ocb, iv, octx->ivlen, octx->taglen)
 933                 != 1)
 934                 return 0;
 935             octx->iv_set = 1;
 936         }
 937         octx->key_set = 1;
 938     } else {
 939         /* If key set use IV, otherwise copy */
 940         if (octx->key_set)
 941             CRYPTO_ocb128_setiv(&octx->ocb, iv, octx->ivlen, octx->taglen);
 942         else
 943             memcpy(octx->iv, iv, octx->ivlen);
 944         octx->iv_set = 1;
 945     }
 946     return 1;
 947 }
 948
 949 #  define aes_t4_ocb_cipher aes_ocb_cipher
 950 static int aes_t4_ocb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 951                              const unsigned char *in, size_t len);
 952 # endif                        /* OPENSSL_NO_OCB */
 953
 954 # ifndef OPENSSL_NO_SIV
 955 #  define aes_t4_siv_init_key aes_siv_init_key
 956 #  define aes_t4_siv_cipher aes_siv_cipher
 957 # endif /* OPENSSL_NO_SIV */
 958
 959 # define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \
 960 static const EVP_CIPHER aes_t4_##keylen##_##mode = { \
 961         nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \
 962         flags|EVP_CIPH_##MODE##_MODE,   \
 963         aes_t4_init_key,                \
 964         aes_t4_##mode##_cipher,         \
 965         NULL,                           \
 966         sizeof(EVP_AES_KEY),            \
 967         NULL,NULL,NULL,NULL }; \
 968 static const EVP_CIPHER aes_##keylen##_##mode = { \
 969         nid##_##keylen##_##nmode,blocksize,     \
 970         keylen/8,ivlen, \
 971         flags|EVP_CIPH_##MODE##_MODE,   \
 972         aes_init_key,                   \
 973         aes_##mode##_cipher,            \
 974         NULL,                           \
 975         sizeof(EVP_AES_KEY),            \
 976         NULL,NULL,NULL,NULL }; \
 977 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 978 { return SPARC_AES_CAPABLE?&aes_t4_##keylen##_##mode:&aes_##keylen##_##mode; }
 979
 980 # define BLOCK_CIPHER_custom(nid,keylen,blocksize,ivlen,mode,MODE,flags) \
 981 static const EVP_CIPHER aes_t4_##keylen##_##mode = { \
 982         nid##_##keylen##_##mode,blocksize, \
 983         (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE||EVP_CIPH_##MODE##_MODE==EVP_CIPH_SIV_MODE?2:1)*keylen/8, \
 984         ivlen,                          \
 985         flags|EVP_CIPH_##MODE##_MODE,   \
 986         aes_t4_##mode##_init_key,       \
 987         aes_t4_##mode##_cipher,         \
 988         aes_##mode##_cleanup,           \
 989         sizeof(EVP_AES_##MODE##_CTX),   \
 990         NULL,NULL,aes_##mode##_ctrl,NULL }; \
 991 static const EVP_CIPHER aes_##keylen##_##mode = { \
 992         nid##_##keylen##_##mode,blocksize, \
 993         (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE||EVP_CIPH_##MODE##_MODE==EVP_CIPH_SIV_MODE?2:1)*keylen/8, \
 994         ivlen,                          \
 995         flags|EVP_CIPH_##MODE##_MODE,   \
 996         aes_##mode##_init_key,          \
 997         aes_##mode##_cipher,            \
 998         aes_##mode##_cleanup,           \
 999         sizeof(EVP_AES_##MODE##_CTX),   \
1000         NULL,NULL,aes_##mode##_ctrl,NULL }; \
1001 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
1002 { return SPARC_AES_CAPABLE?&aes_t4_##keylen##_##mode:&aes_##keylen##_##mode; }
1003
1004 #elif defined(OPENSSL_CPUID_OBJ) && defined(__s390__)
1005 /*
1006  * IBM S390X support
1007  */
1008 # include "s390x_arch.h"
1009
1010 typedef struct {
1011     union {
1012         OSSL_UNION_ALIGN;
1013         /*-
1014          * KM-AES parameter block - begin
1015          * (see z/Architecture Principles of Operation >= SA22-7832-06)
1016          */
1017         struct {
1018             unsigned char k[32];
1019         } param;
1020         /* KM-AES parameter block - end */
1021     } km;
1022     unsigned int fc;
1023 } S390X_AES_ECB_CTX;
1024
1025 typedef struct {
1026     union {
1027         OSSL_UNION_ALIGN;
1028         /*-
1029          * KMO-AES parameter block - begin
1030          * (see z/Architecture Principles of Operation >= SA22-7832-08)
1031          */
1032         struct {
1033             unsigned char cv[16];
1034             unsigned char k[32];
1035         } param;
1036         /* KMO-AES parameter block - end */
1037     } kmo;
1038     unsigned int fc;
1039
1040     int res;
1041 } S390X_AES_OFB_CTX;
1042
1043 typedef struct {
1044     union {
1045         OSSL_UNION_ALIGN;
1046         /*-
1047          * KMF-AES parameter block - begin
1048          * (see z/Architecture Principles of Operation >= SA22-7832-08)
1049          */
1050         struct {
1051             unsigned char cv[16];
1052             unsigned char k[32];
1053         } param;
1054         /* KMF-AES parameter block - end */
1055     } kmf;
1056     unsigned int fc;
1057
1058     int res;
1059 } S390X_AES_CFB_CTX;
1060
1061 typedef struct {
1062     union {
1063         OSSL_UNION_ALIGN;
1064         /*-
1065          * KMA-GCM-AES parameter block - begin
1066          * (see z/Architecture Principles of Operation >= SA22-7832-11)
1067          */
1068         struct {
1069             unsigned char reserved[12];
1070             union {
1071                 unsigned int w;
1072                 unsigned char b[4];
1073             } cv;
1074             union {
1075                 unsigned long long g[2];
1076                 unsigned char b[16];
1077             } t;
1078             unsigned char h[16];
1079             unsigned long long taadl;
1080             unsigned long long tpcl;
1081             union {
1082                 unsigned long long g[2];
1083                 unsigned int w[4];
1084             } j0;
1085             unsigned char k[32];
1086         } param;
1087         /* KMA-GCM-AES parameter block - end */
1088     } kma;
1089     unsigned int fc;
1090     int key_set;
1091
1092     unsigned char *iv;
1093     int ivlen;
1094     int iv_set;
1095     int iv_gen;
1096
1097     int taglen;
1098
1099     unsigned char ares[16];
1100     unsigned char mres[16];
1101     unsigned char kres[16];
1102     int areslen;
1103     int mreslen;
1104     int kreslen;
1105
1106     int tls_aad_len;
1107     uint64_t tls_enc_records;   /* Number of TLS records encrypted */
1108 } S390X_AES_GCM_CTX;
1109
1110 typedef struct {
1111     union {
1112         OSSL_UNION_ALIGN;
1113         /*-
1114          * Padding is chosen so that ccm.kmac_param.k overlaps with key.k and
1115          * ccm.fc with key.k.rounds. Remember that on s390x, an AES_KEY's
1116          * rounds field is used to store the function code and that the key
1117          * schedule is not stored (if aes hardware support is detected).
1118          */
1119         struct {
1120             unsigned char pad[16];
1121             AES_KEY k;
1122         } key;
1123
1124         struct {
1125             /*-
1126              * KMAC-AES parameter block - begin
1127              * (see z/Architecture Principles of Operation >= SA22-7832-08)
1128              */
1129             struct {
1130                 union {
1131                     unsigned long long g[2];
1132                     unsigned char b[16];
1133                 } icv;
1134                 unsigned char k[32];
1135             } kmac_param;
1136             /* KMAC-AES paramater block - end */
1137
1138             union {
1139                 unsigned long long g[2];
1140                 unsigned char b[16];
1141             } nonce;
1142             union {
1143                 unsigned long long g[2];
1144                 unsigned char b[16];
1145             } buf;
1146
1147             unsigned long long blocks;
1148             int l;
1149             int m;
1150             int tls_aad_len;
1151             int iv_set;
1152             int tag_set;
1153             int len_set;
1154             int key_set;
1155
1156             unsigned char pad[140];
1157             unsigned int fc;
1158         } ccm;
1159     } aes;
1160 } S390X_AES_CCM_CTX;
1161
1162 /* Convert key size to function code: [16,24,32] -> [18,19,20]. */
1163 # define S390X_AES_FC(keylen)  (S390X_AES_128 + ((((keylen) << 3) - 128) >> 6))
1164
1165 /* Most modes of operation need km for partial block processing. */
1166 # define S390X_aes_128_CAPABLE (OPENSSL_s390xcap_P.km[0] &      \
1167                                 S390X_CAPBIT(S390X_AES_128))
1168 # define S390X_aes_192_CAPABLE (OPENSSL_s390xcap_P.km[0] &      \
1169                                 S390X_CAPBIT(S390X_AES_192))
1170 # define S390X_aes_256_CAPABLE (OPENSSL_s390xcap_P.km[0] &      \
1171                                 S390X_CAPBIT(S390X_AES_256))
1172
1173 # define s390x_aes_init_key aes_init_key
1174 static int s390x_aes_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
1175                               const unsigned char *iv, int enc);
1176
1177 # define S390X_aes_128_cbc_CAPABLE      1       /* checked by callee */
1178 # define S390X_aes_192_cbc_CAPABLE      1
1179 # define S390X_aes_256_cbc_CAPABLE      1
1180 # define S390X_AES_CBC_CTX              EVP_AES_KEY
1181
1182 # define s390x_aes_cbc_init_key aes_init_key
1183
1184 # define s390x_aes_cbc_cipher aes_cbc_cipher
1185 static int s390x_aes_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1186                                 const unsigned char *in, size_t len);
1187
1188 # define S390X_aes_128_ecb_CAPABLE      S390X_aes_128_CAPABLE
1189 # define S390X_aes_192_ecb_CAPABLE      S390X_aes_192_CAPABLE
1190 # define S390X_aes_256_ecb_CAPABLE      S390X_aes_256_CAPABLE
1191
1192 static int s390x_aes_ecb_init_key(EVP_CIPHER_CTX *ctx,
1193                                   const unsigned char *key,
1194                                   const unsigned char *iv, int enc)
1195 {
1196     S390X_AES_ECB_CTX *cctx = EVP_C_DATA(S390X_AES_ECB_CTX, ctx);
1197     const int keylen = EVP_CIPHER_CTX_key_length(ctx);
1198
1199     cctx->fc = S390X_AES_FC(keylen);
1200     if (!enc)
1201         cctx->fc |= S390X_DECRYPT;
1202
1203     memcpy(cctx->km.param.k, key, keylen);
1204     return 1;
1205 }
1206
1207 static int s390x_aes_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1208                                 const unsigned char *in, size_t len)
1209 {
1210     S390X_AES_ECB_CTX *cctx = EVP_C_DATA(S390X_AES_ECB_CTX, ctx);
1211
1212     s390x_km(in, len, out, cctx->fc, &cctx->km.param);
1213     return 1;
1214 }
1215
1216 # define S390X_aes_128_ofb_CAPABLE (S390X_aes_128_CAPABLE &&            \
1217                                     (OPENSSL_s390xcap_P.kmo[0] &        \
1218                                      S390X_CAPBIT(S390X_AES_128)))
1219 # define S390X_aes_192_ofb_CAPABLE (S390X_aes_192_CAPABLE &&            \
1220                                     (OPENSSL_s390xcap_P.kmo[0] &        \
1221                                      S390X_CAPBIT(S390X_AES_192)))
1222 # define S390X_aes_256_ofb_CAPABLE (S390X_aes_256_CAPABLE &&            \
1223                                     (OPENSSL_s390xcap_P.kmo[0] &        \
1224                                      S390X_CAPBIT(S390X_AES_256)))
1225
1226 static int s390x_aes_ofb_init_key(EVP_CIPHER_CTX *ctx,
1227                                   const unsigned char *key,
1228                                   const unsigned char *ivec, int enc)
1229 {
1230     S390X_AES_OFB_CTX *cctx = EVP_C_DATA(S390X_AES_OFB_CTX, ctx);
1231     const unsigned char *iv = EVP_CIPHER_CTX_original_iv(ctx);
1232     const int keylen = EVP_CIPHER_CTX_key_length(ctx);
1233     const int ivlen = EVP_CIPHER_CTX_iv_length(ctx);
1234
1235     memcpy(cctx->kmo.param.cv, iv, ivlen);
1236     memcpy(cctx->kmo.param.k, key, keylen);
1237     cctx->fc = S390X_AES_FC(keylen);
1238     cctx->res = 0;
1239     return 1;
1240 }
1241
1242 static int s390x_aes_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1243                                 const unsigned char *in, size_t len)
1244 {
1245     S390X_AES_OFB_CTX *cctx = EVP_C_DATA(S390X_AES_OFB_CTX, ctx);
1246     int n = cctx->res;
1247     int rem;
1248
1249     while (n && len) {
1250         *out = *in ^ cctx->kmo.param.cv[n];
1251         n = (n + 1) & 0xf;
1252         --len;
1253         ++in;
1254         ++out;
1255     }
1256
1257     rem = len & 0xf;
1258
1259     len &= ~(size_t)0xf;
1260     if (len) {
1261         s390x_kmo(in, len, out, cctx->fc, &cctx->kmo.param);
1262
1263         out += len;
1264         in += len;
1265     }
1266
1267     if (rem) {
1268         s390x_km(cctx->kmo.param.cv, 16, cctx->kmo.param.cv, cctx->fc,
1269                  cctx->kmo.param.k);
1270
1271         while (rem--) {
1272             out[n] = in[n] ^ cctx->kmo.param.cv[n];
1273             ++n;
1274         }
1275     }
1276
1277     cctx->res = n;
1278     return 1;
1279 }
1280
1281 # define S390X_aes_128_cfb_CAPABLE (S390X_aes_128_CAPABLE &&            \
1282                                     (OPENSSL_s390xcap_P.kmf[0] &        \
1283                                      S390X_CAPBIT(S390X_AES_128)))
1284 # define S390X_aes_192_cfb_CAPABLE (S390X_aes_192_CAPABLE &&            \
1285                                     (OPENSSL_s390xcap_P.kmf[0] &        \
1286                                      S390X_CAPBIT(S390X_AES_192)))
1287 # define S390X_aes_256_cfb_CAPABLE (S390X_aes_256_CAPABLE &&            \
1288                                     (OPENSSL_s390xcap_P.kmf[0] &        \
1289                                      S390X_CAPBIT(S390X_AES_256)))
1290
1291 static int s390x_aes_cfb_init_key(EVP_CIPHER_CTX *ctx,
1292                                   const unsigned char *key,
1293                                   const unsigned char *ivec, int enc)
1294 {
1295     S390X_AES_CFB_CTX *cctx = EVP_C_DATA(S390X_AES_CFB_CTX, ctx);
1296     const unsigned char *iv = EVP_CIPHER_CTX_original_iv(ctx);
1297     const int keylen = EVP_CIPHER_CTX_key_length(ctx);
1298     const int ivlen = EVP_CIPHER_CTX_iv_length(ctx);
1299
1300     cctx->fc = S390X_AES_FC(keylen);
1301     cctx->fc |= 16 << 24;   /* 16 bytes cipher feedback */
1302     if (!enc)
1303         cctx->fc |= S390X_DECRYPT;
1304
1305     cctx->res = 0;
1306     memcpy(cctx->kmf.param.cv, iv, ivlen);
1307     memcpy(cctx->kmf.param.k, key, keylen);
1308     return 1;
1309 }
1310
1311 static int s390x_aes_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1312                                 const unsigned char *in, size_t len)
1313 {
1314     S390X_AES_CFB_CTX *cctx = EVP_C_DATA(S390X_AES_CFB_CTX, ctx);
1315     const int keylen = EVP_CIPHER_CTX_key_length(ctx);
1316     const int enc = EVP_CIPHER_CTX_encrypting(ctx);
1317     int n = cctx->res;
1318     int rem;
1319     unsigned char tmp;
1320
1321     while (n && len) {
1322         tmp = *in;
1323         *out = cctx->kmf.param.cv[n] ^ tmp;
1324         cctx->kmf.param.cv[n] = enc ? *out : tmp;
1325         n = (n + 1) & 0xf;
1326         --len;
1327         ++in;
1328         ++out;
1329     }
1330
1331     rem = len & 0xf;
1332
1333     len &= ~(size_t)0xf;
1334     if (len) {
1335         s390x_kmf(in, len, out, cctx->fc, &cctx->kmf.param);
1336
1337         out += len;
1338         in += len;
1339     }
1340
1341     if (rem) {
1342         s390x_km(cctx->kmf.param.cv, 16, cctx->kmf.param.cv,
1343                  S390X_AES_FC(keylen), cctx->kmf.param.k);
1344
1345         while (rem--) {
1346             tmp = in[n];
1347             out[n] = cctx->kmf.param.cv[n] ^ tmp;
1348             cctx->kmf.param.cv[n] = enc ? out[n] : tmp;
1349             ++n;
1350         }
1351     }
1352
1353     cctx->res = n;
1354     return 1;
1355 }
1356
1357 # define S390X_aes_128_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] &        \
1358                                      S390X_CAPBIT(S390X_AES_128))
1359 # define S390X_aes_192_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] &        \
1360                                      S390X_CAPBIT(S390X_AES_192))
1361 # define S390X_aes_256_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] &        \
1362                                      S390X_CAPBIT(S390X_AES_256))
1363
1364 static int s390x_aes_cfb8_init_key(EVP_CIPHER_CTX *ctx,
1365                                    const unsigned char *key,
1366                                    const unsigned char *ivec, int enc)
1367 {
1368     S390X_AES_CFB_CTX *cctx = EVP_C_DATA(S390X_AES_CFB_CTX, ctx);
1369     const unsigned char *iv = EVP_CIPHER_CTX_original_iv(ctx);
1370     const int keylen = EVP_CIPHER_CTX_key_length(ctx);
1371     const int ivlen = EVP_CIPHER_CTX_iv_length(ctx);
1372
1373     cctx->fc = S390X_AES_FC(keylen);
1374     cctx->fc |= 1 << 24;   /* 1 byte cipher feedback */
1375     if (!enc)
1376         cctx->fc |= S390X_DECRYPT;
1377
1378     memcpy(cctx->kmf.param.cv, iv, ivlen);
1379     memcpy(cctx->kmf.param.k, key, keylen);
1380     return 1;
1381 }
1382
1383 static int s390x_aes_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1384                                  const unsigned char *in, size_t len)
1385 {
1386     S390X_AES_CFB_CTX *cctx = EVP_C_DATA(S390X_AES_CFB_CTX, ctx);
1387
1388     s390x_kmf(in, len, out, cctx->fc, &cctx->kmf.param);
1389     return 1;
1390 }
1391
1392 # define S390X_aes_128_cfb1_CAPABLE     0
1393 # define S390X_aes_192_cfb1_CAPABLE     0
1394 # define S390X_aes_256_cfb1_CAPABLE     0
1395
1396 # define s390x_aes_cfb1_init_key aes_init_key
1397
1398 # define s390x_aes_cfb1_cipher aes_cfb1_cipher
1399 static int s390x_aes_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1400                                  const unsigned char *in, size_t len);
1401
1402 # define S390X_aes_128_ctr_CAPABLE      1       /* checked by callee */
1403 # define S390X_aes_192_ctr_CAPABLE      1
1404 # define S390X_aes_256_ctr_CAPABLE      1
1405 # define S390X_AES_CTR_CTX              EVP_AES_KEY
1406
1407 # define s390x_aes_ctr_init_key aes_init_key
1408
1409 # define s390x_aes_ctr_cipher aes_ctr_cipher
1410 static int s390x_aes_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1411                                 const unsigned char *in, size_t len);
1412
1413 # define S390X_aes_128_gcm_CAPABLE (S390X_aes_128_CAPABLE &&            \
1414                                     (OPENSSL_s390xcap_P.kma[0] &        \
1415                                      S390X_CAPBIT(S390X_AES_128)))
1416 # define S390X_aes_192_gcm_CAPABLE (S390X_aes_192_CAPABLE &&            \
1417                                     (OPENSSL_s390xcap_P.kma[0] &        \
1418                                      S390X_CAPBIT(S390X_AES_192)))
1419 # define S390X_aes_256_gcm_CAPABLE (S390X_aes_256_CAPABLE &&            \
1420                                     (OPENSSL_s390xcap_P.kma[0] &        \
1421                                      S390X_CAPBIT(S390X_AES_256)))
1422
1423 /* iv + padding length for iv lengths != 12 */
1424 # define S390X_gcm_ivpadlen(i)  ((((i) + 15) >> 4 << 4) + 16)
1425
1426 /*-
1427  * Process additional authenticated data. Returns 0 on success. Code is
1428  * big-endian.
1429  */
1430 static int s390x_aes_gcm_aad(S390X_AES_GCM_CTX *ctx, const unsigned char *aad,
1431                              size_t len)
1432 {
1433     unsigned long long alen;
1434     int n, rem;
1435
1436     if (ctx->kma.param.tpcl)
1437         return -2;
1438
1439     alen = ctx->kma.param.taadl + len;
1440     if (alen > (U64(1) << 61) || (sizeof(len) == 8 && alen < len))
1441         return -1;
1442     ctx->kma.param.taadl = alen;
1443
1444     n = ctx->areslen;
1445     if (n) {
1446         while (n && len) {
1447             ctx->ares[n] = *aad;
1448             n = (n + 1) & 0xf;
1449             ++aad;
1450             --len;
1451         }
1452         /* ctx->ares contains a complete block if offset has wrapped around */
1453         if (!n) {
1454             s390x_kma(ctx->ares, 16, NULL, 0, NULL, ctx->fc, &ctx->kma.param);
1455             ctx->fc |= S390X_KMA_HS;
1456         }
1457         ctx->areslen = n;
1458     }
1459
1460     rem = len & 0xf;
1461
1462     len &= ~(size_t)0xf;
1463     if (len) {
1464         s390x_kma(aad, len, NULL, 0, NULL, ctx->fc, &ctx->kma.param);
1465         aad += len;
1466         ctx->fc |= S390X_KMA_HS;
1467     }
1468
1469     if (rem) {
1470         ctx->areslen = rem;
1471
1472         do {
1473             --rem;
1474             ctx->ares[rem] = aad[rem];
1475         } while (rem);
1476     }
1477     return 0;
1478 }
1479
1480 /*-
1481  * En/de-crypt plain/cipher-text and authenticate ciphertext. Returns 0 for
1482  * success. Code is big-endian.
1483  */
1484 static int s390x_aes_gcm(S390X_AES_GCM_CTX *ctx, const unsigned char *in,
1485                          unsigned char *out, size_t len)
1486 {
1487     const unsigned char *inptr;
1488     unsigned long long mlen;
1489     union {
1490         unsigned int w[4];
1491         unsigned char b[16];
1492     } buf;
1493     size_t inlen;
1494     int n, rem, i;
1495
1496     mlen = ctx->kma.param.tpcl + len;
1497     if (mlen > ((U64(1) << 36) - 32) || (sizeof(len) == 8 && mlen < len))
1498         return -1;
1499     ctx->kma.param.tpcl = mlen;
1500
1501     n = ctx->mreslen;
1502     if (n) {
1503         inptr = in;
1504         inlen = len;
1505         while (n && inlen) {
1506             ctx->mres[n] = *inptr;
1507             n = (n + 1) & 0xf;
1508             ++inptr;
1509             --inlen;
1510         }
1511         /* ctx->mres contains a complete block if offset has wrapped around */
1512         if (!n) {
1513             s390x_kma(ctx->ares, ctx->areslen, ctx->mres, 16, buf.b,
1514                       ctx->fc | S390X_KMA_LAAD, &ctx->kma.param);
1515             ctx->fc |= S390X_KMA_HS;
1516             ctx->areslen = 0;
1517
1518             /* previous call already encrypted/decrypted its remainder,
1519              * see comment below */
1520             n = ctx->mreslen;
1521             while (n) {
1522                 *out = buf.b[n];
1523                 n = (n + 1) & 0xf;
1524                 ++out;
1525                 ++in;
1526                 --len;
1527             }
1528             ctx->mreslen = 0;
1529         }
1530     }
1531
1532     rem = len & 0xf;
1533
1534     len &= ~(size_t)0xf;
1535     if (len) {
1536         s390x_kma(ctx->ares, ctx->areslen, in, len, out,
1537                   ctx->fc | S390X_KMA_LAAD, &ctx->kma.param);
1538         in += len;
1539         out += len;
1540         ctx->fc |= S390X_KMA_HS;
1541         ctx->areslen = 0;
1542     }
1543
1544     /*-
1545      * If there is a remainder, it has to be saved such that it can be
1546      * processed by kma later. However, we also have to do the for-now
1547      * unauthenticated encryption/decryption part here and now...
1548      */
1549     if (rem) {
1550         if (!ctx->mreslen) {
1551             buf.w[0] = ctx->kma.param.j0.w[0];
1552             buf.w[1] = ctx->kma.param.j0.w[1];
1553             buf.w[2] = ctx->kma.param.j0.w[2];
1554             buf.w[3] = ctx->kma.param.cv.w + 1;
1555             s390x_km(buf.b, 16, ctx->kres, ctx->fc & 0x1f, &ctx->kma.param.k);
1556         }
1557
1558         n = ctx->mreslen;
1559         for (i = 0; i < rem; i++) {
1560             ctx->mres[n + i] = in[i];
1561             out[i] = in[i] ^ ctx->kres[n + i];
1562         }
1563
1564         ctx->mreslen += rem;
1565     }
1566     return 0;
1567 }
1568
1569 /*-
1570  * Initialize context structure. Code is big-endian.
1571  */
1572 static void s390x_aes_gcm_setiv(S390X_AES_GCM_CTX *ctx,
1573                                 const unsigned char *iv)
1574 {
1575     ctx->kma.param.t.g[0] = 0;
1576     ctx->kma.param.t.g[1] = 0;
1577     ctx->kma.param.tpcl = 0;
1578     ctx->kma.param.taadl = 0;
1579     ctx->mreslen = 0;
1580     ctx->areslen = 0;
1581     ctx->kreslen = 0;
1582
1583     if (ctx->ivlen == 12) {
1584         memcpy(&ctx->kma.param.j0, iv, ctx->ivlen);
1585         ctx->kma.param.j0.w[3] = 1;
1586         ctx->kma.param.cv.w = 1;
1587     } else {
1588         /* ctx->iv has the right size and is already padded. */
1589         memcpy(ctx->iv, iv, ctx->ivlen);
1590         s390x_kma(ctx->iv, S390X_gcm_ivpadlen(ctx->ivlen), NULL, 0, NULL,
1591                   ctx->fc, &ctx->kma.param);
1592         ctx->fc |= S390X_KMA_HS;
1593
1594         ctx->kma.param.j0.g[0] = ctx->kma.param.t.g[0];
1595         ctx->kma.param.j0.g[1] = ctx->kma.param.t.g[1];
1596         ctx->kma.param.cv.w = ctx->kma.param.j0.w[3];
1597         ctx->kma.param.t.g[0] = 0;
1598         ctx->kma.param.t.g[1] = 0;
1599     }
1600 }
1601
1602 /*-
1603  * Performs various operations on the context structure depending on control
1604  * type. Returns 1 for success, 0 for failure and -1 for unknown control type.
1605  * Code is big-endian.
1606  */
1607 static int s390x_aes_gcm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
1608 {
1609     S390X_AES_GCM_CTX *gctx = EVP_C_DATA(S390X_AES_GCM_CTX, c);
1610     S390X_AES_GCM_CTX *gctx_out;
1611     EVP_CIPHER_CTX *out;
1612     unsigned char *buf, *iv;
1613     int ivlen, enc, len;
1614
1615     switch (type) {
1616     case EVP_CTRL_INIT:
1617         ivlen = EVP_CIPHER_CTX_iv_length(c);
1618         iv = EVP_CIPHER_CTX_iv_noconst(c);
1619         gctx->key_set = 0;
1620         gctx->iv_set = 0;
1621         gctx->ivlen = ivlen;
1622         gctx->iv = iv;
1623         gctx->taglen = -1;
1624         gctx->iv_gen = 0;
1625         gctx->tls_aad_len = -1;
1626         return 1;
1627
1628     case EVP_CTRL_AEAD_SET_IVLEN:
1629         if (arg <= 0)
1630             return 0;
1631
1632         if (arg != 12) {
1633             iv = EVP_CIPHER_CTX_iv_noconst(c);
1634             len = S390X_gcm_ivpadlen(arg);
1635
1636             /* Allocate memory for iv if needed. */
1637             if (gctx->ivlen == 12 || len > S390X_gcm_ivpadlen(gctx->ivlen)) {
1638                 if (gctx->iv != iv)
1639                     OPENSSL_free(gctx->iv);
1640
1641                 if ((gctx->iv = OPENSSL_malloc(len)) == NULL) {
1642                     EVPerr(EVP_F_S390X_AES_GCM_CTRL, ERR_R_MALLOC_FAILURE);
1643                     return 0;
1644                 }
1645             }
1646             /* Add padding. */
1647             memset(gctx->iv + arg, 0, len - arg - 8);
1648             *((unsigned long long *)(gctx->iv + len - 8)) = arg << 3;
1649         }
1650         gctx->ivlen = arg;
1651         return 1;
1652
1653     case EVP_CTRL_AEAD_SET_TAG:
1654         buf = EVP_CIPHER_CTX_buf_noconst(c);
1655         enc = EVP_CIPHER_CTX_encrypting(c);
1656         if (arg <= 0 || arg > 16 || enc)
1657             return 0;
1658
1659         memcpy(buf, ptr, arg);
1660         gctx->taglen = arg;
1661         return 1;
1662
1663     case EVP_CTRL_AEAD_GET_TAG:
1664         enc = EVP_CIPHER_CTX_encrypting(c);
1665         if (arg <= 0 || arg > 16 || !enc || gctx->taglen < 0)
1666             return 0;
1667
1668         memcpy(ptr, gctx->kma.param.t.b, arg);
1669         return 1;
1670
1671     case EVP_CTRL_GCM_SET_IV_FIXED:
1672         /* Special case: -1 length restores whole iv */
1673         if (arg == -1) {
1674             memcpy(gctx->iv, ptr, gctx->ivlen);
1675             gctx->iv_gen = 1;
1676             return 1;
1677         }
1678         /*
1679          * Fixed field must be at least 4 bytes and invocation field at least
1680          * 8.
1681          */
1682         if ((arg < 4) || (gctx->ivlen - arg) < 8)
1683             return 0;
1684
1685         if (arg)
1686             memcpy(gctx->iv, ptr, arg);
1687
1688         enc = EVP_CIPHER_CTX_encrypting(c);
1689         if (enc && RAND_bytes(gctx->iv + arg, gctx->ivlen - arg) <= 0)
1690             return 0;
1691
1692         gctx->iv_gen = 1;
1693         return 1;
1694
1695     case EVP_CTRL_GCM_IV_GEN:
1696         if (gctx->iv_gen == 0 || gctx->key_set == 0)
1697             return 0;
1698
1699         s390x_aes_gcm_setiv(gctx, gctx->iv);
1700
1701         if (arg <= 0 || arg > gctx->ivlen)
1702             arg = gctx->ivlen;
1703
1704         memcpy(ptr, gctx->iv + gctx->ivlen - arg, arg);
1705         /*
1706          * Invocation field will be at least 8 bytes in size and so no need
1707          * to check wrap around or increment more than last 8 bytes.
1708          */
1709         ctr64_inc(gctx->iv + gctx->ivlen - 8);
1710         gctx->iv_set = 1;
1711         return 1;
1712
1713     case EVP_CTRL_GCM_SET_IV_INV:
1714         enc = EVP_CIPHER_CTX_encrypting(c);
1715         if (gctx->iv_gen == 0 || gctx->key_set == 0 || enc)
1716             return 0;
1717
1718         memcpy(gctx->iv + gctx->ivlen - arg, ptr, arg);
1719         s390x_aes_gcm_setiv(gctx, gctx->iv);
1720         gctx->iv_set = 1;
1721         return 1;
1722
1723     case EVP_CTRL_AEAD_TLS1_AAD:
1724         /* Save the aad for later use. */
1725         if (arg != EVP_AEAD_TLS1_AAD_LEN)
1726             return 0;
1727
1728         buf = EVP_CIPHER_CTX_buf_noconst(c);
1729         memcpy(buf, ptr, arg);
1730         gctx->tls_aad_len = arg;
1731         gctx->tls_enc_records = 0;
1732
1733         len = buf[arg - 2] << 8 | buf[arg - 1];
1734         /* Correct length for explicit iv. */
1735         if (len < EVP_GCM_TLS_EXPLICIT_IV_LEN)
1736             return 0;
1737         len -= EVP_GCM_TLS_EXPLICIT_IV_LEN;
1738
1739         /* If decrypting correct for tag too. */
1740         enc = EVP_CIPHER_CTX_encrypting(c);
1741         if (!enc) {
1742             if (len < EVP_GCM_TLS_TAG_LEN)
1743                 return 0;
1744             len -= EVP_GCM_TLS_TAG_LEN;
1745         }
1746         buf[arg - 2] = len >> 8;
1747         buf[arg - 1] = len & 0xff;
1748         /* Extra padding: tag appended to record. */
1749         return EVP_GCM_TLS_TAG_LEN;
1750
1751     case EVP_CTRL_COPY:
1752         out = ptr;
1753         gctx_out = EVP_C_DATA(S390X_AES_GCM_CTX, out);
1754         iv = EVP_CIPHER_CTX_iv_noconst(c);
1755
1756         if (gctx->iv == iv) {
1757             gctx_out->iv = EVP_CIPHER_CTX_iv_noconst(out);
1758         } else {
1759             len = S390X_gcm_ivpadlen(gctx->ivlen);
1760
1761             if ((gctx_out->iv = OPENSSL_malloc(len)) == NULL) {
1762                 EVPerr(EVP_F_S390X_AES_GCM_CTRL, ERR_R_MALLOC_FAILURE);
1763                 return 0;
1764             }
1765
1766             memcpy(gctx_out->iv, gctx->iv, len);
1767         }
1768         return 1;
1769
1770     default:
1771         return -1;
1772     }
1773 }
1774
1775 /*-
1776  * Set key and/or iv. Returns 1 on success. Otherwise 0 is returned.
1777  */
1778 static int s390x_aes_gcm_init_key(EVP_CIPHER_CTX *ctx,
1779                                   const unsigned char *key,
1780                                   const unsigned char *iv, int enc)
1781 {
1782     S390X_AES_GCM_CTX *gctx = EVP_C_DATA(S390X_AES_GCM_CTX, ctx);
1783     int keylen;
1784
1785     if (iv == NULL && key == NULL)
1786         return 1;
1787
1788     if (key != NULL) {
1789         keylen = EVP_CIPHER_CTX_key_length(ctx);
1790         memcpy(&gctx->kma.param.k, key, keylen);
1791
1792         gctx->fc = S390X_AES_FC(keylen);
1793         if (!enc)
1794             gctx->fc |= S390X_DECRYPT;
1795
1796         if (iv == NULL && gctx->iv_set)
1797             iv = gctx->iv;
1798
1799         if (iv != NULL) {
1800             s390x_aes_gcm_setiv(gctx, iv);
1801             gctx->iv_set = 1;
1802         }
1803         gctx->key_set = 1;
1804     } else {
1805         if (gctx->key_set)
1806             s390x_aes_gcm_setiv(gctx, iv);
1807         else
1808             memcpy(gctx->iv, iv, gctx->ivlen);
1809
1810         gctx->iv_set = 1;
1811         gctx->iv_gen = 0;
1812     }
1813     return 1;
1814 }
1815
1816 /*-
1817  * En/de-crypt and authenticate TLS packet. Returns the number of bytes written
1818  * if successful. Otherwise -1 is returned. Code is big-endian.
1819  */
1820 static int s390x_aes_gcm_tls_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1821                                     const unsigned char *in, size_t len)
1822 {
1823     S390X_AES_GCM_CTX *gctx = EVP_C_DATA(S390X_AES_GCM_CTX, ctx);
1824     const unsigned char *buf = EVP_CIPHER_CTX_buf_noconst(ctx);
1825     const int enc = EVP_CIPHER_CTX_encrypting(ctx);
1826     int rv = -1;
1827
1828     if (out != in || len < (EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN))
1829         return -1;
1830
1831     /*
1832      * Check for too many keys as per FIPS 140-2 IG A.5 "Key/IV Pair Uniqueness
1833      * Requirements from SP 800-38D".  The requirements is for one party to the
1834      * communication to fail after 2^64 - 1 keys.  We do this on the encrypting
1835      * side only.
1836      */
1837     if (ctx->encrypt && ++gctx->tls_enc_records == 0) {
1838         EVPerr(EVP_F_S390X_AES_GCM_TLS_CIPHER, EVP_R_TOO_MANY_RECORDS);
1839         goto err;
1840     }
1841
1842     if (EVP_CIPHER_CTX_ctrl(ctx, enc ? EVP_CTRL_GCM_IV_GEN
1843                                      : EVP_CTRL_GCM_SET_IV_INV,
1844                             EVP_GCM_TLS_EXPLICIT_IV_LEN, out) <= 0)
1845         goto err;
1846
1847     in += EVP_GCM_TLS_EXPLICIT_IV_LEN;
1848     out += EVP_GCM_TLS_EXPLICIT_IV_LEN;
1849     len -= EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
1850
1851     gctx->kma.param.taadl = gctx->tls_aad_len << 3;
1852     gctx->kma.param.tpcl = len << 3;
1853     s390x_kma(buf, gctx->tls_aad_len, in, len, out,
1854               gctx->fc | S390X_KMA_LAAD | S390X_KMA_LPC, &gctx->kma.param);
1855
1856     if (enc) {
1857         memcpy(out + len, gctx->kma.param.t.b, EVP_GCM_TLS_TAG_LEN);
1858         rv = len + EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
1859     } else {
1860         if (CRYPTO_memcmp(gctx->kma.param.t.b, in + len,
1861                           EVP_GCM_TLS_TAG_LEN)) {
1862             OPENSSL_cleanse(out, len);
1863             goto err;
1864         }
1865         rv = len;
1866     }
1867 err:
1868     gctx->iv_set = 0;
1869     gctx->tls_aad_len = -1;
1870     return rv;
1871 }
1872
1873 /*-
1874  * Called from EVP layer to initialize context, process additional
1875  * authenticated data, en/de-crypt plain/cipher-text and authenticate
1876  * ciphertext or process a TLS packet, depending on context. Returns bytes
1877  * written on success. Otherwise -1 is returned. Code is big-endian.
1878  */
1879 static int s390x_aes_gcm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1880                                 const unsigned char *in, size_t len)
1881 {
1882     S390X_AES_GCM_CTX *gctx = EVP_C_DATA(S390X_AES_GCM_CTX, ctx);
1883     unsigned char *buf, tmp[16];
1884     int enc;
1885
1886     if (!gctx->key_set)
1887         return -1;
1888
1889     if (gctx->tls_aad_len >= 0)
1890         return s390x_aes_gcm_tls_cipher(ctx, out, in, len);
1891
1892     if (!gctx->iv_set)
1893         return -1;
1894
1895     if (in != NULL) {
1896         if (out == NULL) {
1897             if (s390x_aes_gcm_aad(gctx, in, len))
1898                 return -1;
1899         } else {
1900             if (s390x_aes_gcm(gctx, in, out, len))
1901                 return -1;
1902         }
1903         return len;
1904     } else {
1905         gctx->kma.param.taadl <<= 3;
1906         gctx->kma.param.tpcl <<= 3;
1907         s390x_kma(gctx->ares, gctx->areslen, gctx->mres, gctx->mreslen, tmp,
1908                   gctx->fc | S390X_KMA_LAAD | S390X_KMA_LPC, &gctx->kma.param);
1909         /* recall that we already did en-/decrypt gctx->mres
1910          * and returned it to caller... */
1911         OPENSSL_cleanse(tmp, gctx->mreslen);
1912         gctx->iv_set = 0;
1913
1914         enc = EVP_CIPHER_CTX_encrypting(ctx);
1915         if (enc) {
1916             gctx->taglen = 16;
1917         } else {
1918             if (gctx->taglen < 0)
1919                 return -1;
1920
1921             buf = EVP_CIPHER_CTX_buf_noconst(ctx);
1922             if (CRYPTO_memcmp(buf, gctx->kma.param.t.b, gctx->taglen))
1923                 return -1;
1924         }
1925         return 0;
1926     }
1927 }
1928
1929 static int s390x_aes_gcm_cleanup(EVP_CIPHER_CTX *c)
1930 {
1931     S390X_AES_GCM_CTX *gctx = EVP_C_DATA(S390X_AES_GCM_CTX, c);
1932     const unsigned char *iv;
1933
1934     if (gctx == NULL)
1935         return 0;
1936
1937     iv = EVP_CIPHER_CTX_iv(c);
1938     if (iv != gctx->iv)
1939         OPENSSL_free(gctx->iv);
1940
1941     OPENSSL_cleanse(gctx, sizeof(*gctx));
1942     return 1;
1943 }
1944
1945 # define S390X_AES_XTS_CTX              EVP_AES_XTS_CTX
1946 # define S390X_aes_128_xts_CAPABLE      1       /* checked by callee */
1947 # define S390X_aes_256_xts_CAPABLE      1
1948
1949 # define s390x_aes_xts_init_key aes_xts_init_key
1950 static int s390x_aes_xts_init_key(EVP_CIPHER_CTX *ctx,
1951                                   const unsigned char *key,
1952                                   const unsigned char *iv, int enc);
1953 # define s390x_aes_xts_cipher aes_xts_cipher
1954 static int s390x_aes_xts_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1955                                 const unsigned char *in, size_t len);
1956 # define s390x_aes_xts_ctrl aes_xts_ctrl
1957 static int s390x_aes_xts_ctrl(EVP_CIPHER_CTX *, int type, int arg, void *ptr);
1958 # define s390x_aes_xts_cleanup aes_xts_cleanup
1959
1960 # define S390X_aes_128_ccm_CAPABLE (S390X_aes_128_CAPABLE &&            \
1961                                     (OPENSSL_s390xcap_P.kmac[0] &       \
1962                                      S390X_CAPBIT(S390X_AES_128)))
1963 # define S390X_aes_192_ccm_CAPABLE (S390X_aes_192_CAPABLE &&            \
1964                                     (OPENSSL_s390xcap_P.kmac[0] &       \
1965                                      S390X_CAPBIT(S390X_AES_192)))
1966 # define S390X_aes_256_ccm_CAPABLE (S390X_aes_256_CAPABLE &&            \
1967                                     (OPENSSL_s390xcap_P.kmac[0] &       \
1968                                      S390X_CAPBIT(S390X_AES_256)))
1969
1970 # define S390X_CCM_AAD_FLAG     0x40
1971
1972 /*-
1973  * Set nonce and length fields. Code is big-endian.
1974  */
1975 static inline void s390x_aes_ccm_setiv(S390X_AES_CCM_CTX *ctx,
1976                                           const unsigned char *nonce,
1977                                           size_t mlen)
1978 {
1979     ctx->aes.ccm.nonce.b[0] &= ~S390X_CCM_AAD_FLAG;
1980     ctx->aes.ccm.nonce.g[1] = mlen;
1981     memcpy(ctx->aes.ccm.nonce.b + 1, nonce, 15 - ctx->aes.ccm.l);
1982 }
1983
1984 /*-
1985  * Process additional authenticated data. Code is big-endian.
1986  */
1987 static void s390x_aes_ccm_aad(S390X_AES_CCM_CTX *ctx, const unsigned char *aad,
1988                               size_t alen)
1989 {
1990     unsigned char *ptr;
1991     int i, rem;
1992
1993     if (!alen)
1994         return;
1995
1996     ctx->aes.ccm.nonce.b[0] |= S390X_CCM_AAD_FLAG;
1997
1998     /* Suppress 'type-punned pointer dereference' warning. */
1999     ptr = ctx->aes.ccm.buf.b;
2000
2001     if (alen < ((1 << 16) - (1 << 8))) {
2002         *(uint16_t *)ptr = alen;
2003         i = 2;
2004     } else if (sizeof(alen) == 8
2005                && alen >= (size_t)1 << (32 % (sizeof(alen) * 8))) {
2006         *(uint16_t *)ptr = 0xffff;
2007         *(uint64_t *)(ptr + 2) = alen;
2008         i = 10;
2009     } else {
2010         *(uint16_t *)ptr = 0xfffe;
2011         *(uint32_t *)(ptr + 2) = alen;
2012         i = 6;
2013     }
2014
2015     while (i < 16 && alen) {
2016         ctx->aes.ccm.buf.b[i] = *aad;
2017         ++aad;
2018         --alen;
2019         ++i;
2020     }
2021     while (i < 16) {
2022         ctx->aes.ccm.buf.b[i] = 0;
2023         ++i;
2024     }
2025
2026     ctx->aes.ccm.kmac_param.icv.g[0] = 0;
2027     ctx->aes.ccm.kmac_param.icv.g[1] = 0;
2028     s390x_kmac(ctx->aes.ccm.nonce.b, 32, ctx->aes.ccm.fc,
2029                &ctx->aes.ccm.kmac_param);
2030     ctx->aes.ccm.blocks += 2;
2031
2032     rem = alen & 0xf;
2033     alen &= ~(size_t)0xf;
2034     if (alen) {
2035         s390x_kmac(aad, alen, ctx->aes.ccm.fc, &ctx->aes.ccm.kmac_param);
2036         ctx->aes.ccm.blocks += alen >> 4;
2037         aad += alen;
2038     }
2039     if (rem) {
2040         for (i = 0; i < rem; i++)
2041             ctx->aes.ccm.kmac_param.icv.b[i] ^= aad[i];
2042
2043         s390x_km(ctx->aes.ccm.kmac_param.icv.b, 16,
2044                  ctx->aes.ccm.kmac_param.icv.b, ctx->aes.ccm.fc,
2045                  ctx->aes.ccm.kmac_param.k);
2046         ctx->aes.ccm.blocks++;
2047     }
2048 }
2049
2050 /*-
2051  * En/de-crypt plain/cipher-text. Compute tag from plaintext. Returns 0 for
2052  * success.
2053  */
2054 static int s390x_aes_ccm(S390X_AES_CCM_CTX *ctx, const unsigned char *in,
2055                          unsigned char *out, size_t len, int enc)
2056 {
2057     size_t n, rem;
2058     unsigned int i, l, num;
2059     unsigned char flags;
2060
2061     flags = ctx->aes.ccm.nonce.b[0];
2062     if (!(flags & S390X_CCM_AAD_FLAG)) {
2063         s390x_km(ctx->aes.ccm.nonce.b, 16, ctx->aes.ccm.kmac_param.icv.b,
2064                  ctx->aes.ccm.fc, ctx->aes.ccm.kmac_param.k);
2065         ctx->aes.ccm.blocks++;
2066     }
2067     l = flags & 0x7;
2068     ctx->aes.ccm.nonce.b[0] = l;
2069
2070     /*-
2071      * Reconstruct length from encoded length field
2072      * and initialize it with counter value.
2073      */
2074     n = 0;
2075     for (i = 15 - l; i < 15; i++) {
2076         n |= ctx->aes.ccm.nonce.b[i];
2077         ctx->aes.ccm.nonce.b[i] = 0;
2078         n <<= 8;
2079     }
2080     n |= ctx->aes.ccm.nonce.b[15];
2081     ctx->aes.ccm.nonce.b[15] = 1;
2082
2083     if (n != len)
2084         return -1;              /* length mismatch */
2085
2086     if (enc) {
2087         /* Two operations per block plus one for tag encryption */
2088         ctx->aes.ccm.blocks += (((len + 15) >> 4) << 1) + 1;
2089         if (ctx->aes.ccm.blocks > (1ULL << 61))
2090             return -2;          /* too much data */
2091     }
2092
2093     num = 0;
2094     rem = len & 0xf;
2095     len &= ~(size_t)0xf;
2096
2097     if (enc) {
2098         /* mac-then-encrypt */
2099         if (len)
2100             s390x_kmac(in, len, ctx->aes.ccm.fc, &ctx->aes.ccm.kmac_param);
2101         if (rem) {
2102             for (i = 0; i < rem; i++)
2103                 ctx->aes.ccm.kmac_param.icv.b[i] ^= in[len + i];
2104
2105             s390x_km(ctx->aes.ccm.kmac_param.icv.b, 16,
2106                      ctx->aes.ccm.kmac_param.icv.b, ctx->aes.ccm.fc,
2107                      ctx->aes.ccm.kmac_param.k);
2108         }
2109
2110         CRYPTO_ctr128_encrypt_ctr32(in, out, len + rem, &ctx->aes.key.k,
2111                                     ctx->aes.ccm.nonce.b, ctx->aes.ccm.buf.b,
2112                                     &num, (ctr128_f)AES_ctr32_encrypt);
2113     } else {
2114         /* decrypt-then-mac */
2115         CRYPTO_ctr128_encrypt_ctr32(in, out, len + rem, &ctx->aes.key.k,
2116                                     ctx->aes.ccm.nonce.b, ctx->aes.ccm.buf.b,
2117                                     &num, (ctr128_f)AES_ctr32_encrypt);
2118
2119         if (len)
2120             s390x_kmac(out, len, ctx->aes.ccm.fc, &ctx->aes.ccm.kmac_param);
2121         if (rem) {
2122             for (i = 0; i < rem; i++)
2123                 ctx->aes.ccm.kmac_param.icv.b[i] ^= out[len + i];
2124
2125             s390x_km(ctx->aes.ccm.kmac_param.icv.b, 16,
2126                      ctx->aes.ccm.kmac_param.icv.b, ctx->aes.ccm.fc,
2127                      ctx->aes.ccm.kmac_param.k);
2128         }
2129     }
2130     /* encrypt tag */
2131     for (i = 15 - l; i < 16; i++)
2132         ctx->aes.ccm.nonce.b[i] = 0;
2133
2134     s390x_km(ctx->aes.ccm.nonce.b, 16, ctx->aes.ccm.buf.b, ctx->aes.ccm.fc,
2135              ctx->aes.ccm.kmac_param.k);
2136     ctx->aes.ccm.kmac_param.icv.g[0] ^= ctx->aes.ccm.buf.g[0];
2137     ctx->aes.ccm.kmac_param.icv.g[1] ^= ctx->aes.ccm.buf.g[1];
2138
2139     ctx->aes.ccm.nonce.b[0] = flags;    /* restore flags field */
2140     return 0;
2141 }
2142
2143 /*-
2144  * En/de-crypt and authenticate TLS packet. Returns the number of bytes written
2145  * if successful. Otherwise -1 is returned.
2146  */
2147 static int s390x_aes_ccm_tls_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2148                                     const unsigned char *in, size_t len)
2149 {
2150     S390X_AES_CCM_CTX *cctx = EVP_C_DATA(S390X_AES_CCM_CTX, ctx);
2151     unsigned char *ivec = EVP_CIPHER_CTX_iv_noconst(ctx);
2152     unsigned char *buf = EVP_CIPHER_CTX_buf_noconst(ctx);
2153     const int enc = EVP_CIPHER_CTX_encrypting(ctx);
2154
2155     if (out != in
2156             || len < (EVP_CCM_TLS_EXPLICIT_IV_LEN + (size_t)cctx->aes.ccm.m))
2157         return -1;
2158
2159     if (enc) {
2160         /* Set explicit iv (sequence number). */
2161         memcpy(out, buf, EVP_CCM_TLS_EXPLICIT_IV_LEN);
2162     }
2163
2164     len -= EVP_CCM_TLS_EXPLICIT_IV_LEN + cctx->aes.ccm.m;
2165     /*-
2166      * Get explicit iv (sequence number). We already have fixed iv
2167      * (server/client_write_iv) here.
2168      */
2169     memcpy(ivec + EVP_CCM_TLS_FIXED_IV_LEN, in, EVP_CCM_TLS_EXPLICIT_IV_LEN);
2170     s390x_aes_ccm_setiv(cctx, ivec, len);
2171
2172     /* Process aad (sequence number|type|version|length) */
2173     s390x_aes_ccm_aad(cctx, buf, cctx->aes.ccm.tls_aad_len);
2174
2175     in += EVP_CCM_TLS_EXPLICIT_IV_LEN;
2176     out += EVP_CCM_TLS_EXPLICIT_IV_LEN;
2177
2178     if (enc) {
2179         if (s390x_aes_ccm(cctx, in, out, len, enc))
2180             return -1;
2181
2182         memcpy(out + len, cctx->aes.ccm.kmac_param.icv.b, cctx->aes.ccm.m);
2183         return len + EVP_CCM_TLS_EXPLICIT_IV_LEN + cctx->aes.ccm.m;
2184     } else {
2185         if (!s390x_aes_ccm(cctx, in, out, len, enc)) {
2186             if (!CRYPTO_memcmp(cctx->aes.ccm.kmac_param.icv.b, in + len,
2187                                cctx->aes.ccm.m))
2188                 return len;
2189         }
2190
2191         OPENSSL_cleanse(out, len);
2192         return -1;
2193     }
2194 }
2195
2196 /*-
2197  * Set key and flag field and/or iv. Returns 1 if successful. Otherwise 0 is
2198  * returned.
2199  */
2200 static int s390x_aes_ccm_init_key(EVP_CIPHER_CTX *ctx,
2201                                   const unsigned char *key,
2202                                   const unsigned char *iv, int enc)
2203 {
2204     S390X_AES_CCM_CTX *cctx = EVP_C_DATA(S390X_AES_CCM_CTX, ctx);
2205     unsigned char *ivec;
2206     int keylen;
2207
2208     if (iv == NULL && key == NULL)
2209         return 1;
2210
2211     if (key != NULL) {
2212         keylen = EVP_CIPHER_CTX_key_length(ctx);
2213         cctx->aes.ccm.fc = S390X_AES_FC(keylen);
2214         memcpy(cctx->aes.ccm.kmac_param.k, key, keylen);
2215
2216         /* Store encoded m and l. */
2217         cctx->aes.ccm.nonce.b[0] = ((cctx->aes.ccm.l - 1) & 0x7)
2218                                  | (((cctx->aes.ccm.m - 2) >> 1) & 0x7) << 3;
2219         memset(cctx->aes.ccm.nonce.b + 1, 0,
2220                sizeof(cctx->aes.ccm.nonce.b));
2221         cctx->aes.ccm.blocks = 0;
2222
2223         cctx->aes.ccm.key_set = 1;
2224     }
2225
2226     if (iv != NULL) {
2227         ivec = EVP_CIPHER_CTX_iv_noconst(ctx);
2228         memcpy(ivec, iv, 15 - cctx->aes.ccm.l);
2229
2230         cctx->aes.ccm.iv_set = 1;
2231     }
2232
2233     return 1;
2234 }
2235
2236 /*-
2237  * Called from EVP layer to initialize context, process additional
2238  * authenticated data, en/de-crypt plain/cipher-text and authenticate
2239  * plaintext or process a TLS packet, depending on context. Returns bytes
2240  * written on success. Otherwise -1 is returned.
2241  */
2242 static int s390x_aes_ccm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2243                                 const unsigned char *in, size_t len)
2244 {
2245     S390X_AES_CCM_CTX *cctx = EVP_C_DATA(S390X_AES_CCM_CTX, ctx);
2246     const int enc = EVP_CIPHER_CTX_encrypting(ctx);
2247     int rv;
2248     unsigned char *buf, *ivec;
2249
2250     if (!cctx->aes.ccm.key_set)
2251         return -1;
2252
2253     if (cctx->aes.ccm.tls_aad_len >= 0)
2254         return s390x_aes_ccm_tls_cipher(ctx, out, in, len);
2255
2256     /*-
2257      * Final(): Does not return any data. Recall that ccm is mac-then-encrypt
2258      * so integrity must be checked already at Update() i.e., before
2259      * potentially corrupted data is output.
2260      */
2261     if (in == NULL && out != NULL)
2262         return 0;
2263
2264     if (!cctx->aes.ccm.iv_set)
2265         return -1;
2266
2267     if (!enc && !cctx->aes.ccm.tag_set)
2268         return -1;
2269
2270     if (out == NULL) {
2271         /* Update(): Pass message length. */
2272         if (in == NULL) {
2273             ivec = EVP_CIPHER_CTX_iv_noconst(ctx);
2274             s390x_aes_ccm_setiv(cctx, ivec, len);
2275
2276             cctx->aes.ccm.len_set = 1;
2277             return len;
2278         }
2279
2280         /* Update(): Process aad. */
2281         if (!cctx->aes.ccm.len_set && len)
2282             return -1;
2283
2284         s390x_aes_ccm_aad(cctx, in, len);
2285         return len;
2286     }
2287
2288     /* Update(): Process message. */
2289
2290     if (!cctx->aes.ccm.len_set) {
2291         /*-
2292          * In case message length was not previously set explicitly via
2293          * Update(), set it now.
2294          */
2295         ivec = EVP_CIPHER_CTX_iv_noconst(ctx);
2296         s390x_aes_ccm_setiv(cctx, ivec, len);
2297
2298         cctx->aes.ccm.len_set = 1;
2299     }
2300
2301     if (enc) {
2302         if (s390x_aes_ccm(cctx, in, out, len, enc))
2303             return -1;
2304
2305         cctx->aes.ccm.tag_set = 1;
2306         return len;
2307     } else {
2308         rv = -1;
2309
2310         if (!s390x_aes_ccm(cctx, in, out, len, enc)) {
2311             buf = EVP_CIPHER_CTX_buf_noconst(ctx);
2312             if (!CRYPTO_memcmp(cctx->aes.ccm.kmac_param.icv.b, buf,
2313                                cctx->aes.ccm.m))
2314                 rv = len;
2315         }
2316
2317         if (rv == -1)
2318             OPENSSL_cleanse(out, len);
2319
2320         cctx->aes.ccm.iv_set = 0;
2321         cctx->aes.ccm.tag_set = 0;
2322         cctx->aes.ccm.len_set = 0;
2323         return rv;
2324     }
2325 }
2326
2327 /*-
2328  * Performs various operations on the context structure depending on control
2329  * type. Returns 1 for success, 0 for failure and -1 for unknown control type.
2330  * Code is big-endian.
2331  */
2332 static int s390x_aes_ccm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
2333 {
2334     S390X_AES_CCM_CTX *cctx = EVP_C_DATA(S390X_AES_CCM_CTX, c);
2335     unsigned char *buf, *iv;
2336     int enc, len;
2337
2338     switch (type) {
2339     case EVP_CTRL_INIT:
2340         cctx->aes.ccm.key_set = 0;
2341         cctx->aes.ccm.iv_set = 0;
2342         cctx->aes.ccm.l = 8;
2343         cctx->aes.ccm.m = 12;
2344         cctx->aes.ccm.tag_set = 0;
2345         cctx->aes.ccm.len_set = 0;
2346         cctx->aes.ccm.tls_aad_len = -1;
2347         return 1;
2348
2349     case EVP_CTRL_AEAD_TLS1_AAD:
2350         if (arg != EVP_AEAD_TLS1_AAD_LEN)
2351             return 0;
2352
2353         /* Save the aad for later use. */
2354         buf = EVP_CIPHER_CTX_buf_noconst(c);
2355         memcpy(buf, ptr, arg);
2356         cctx->aes.ccm.tls_aad_len = arg;
2357
2358         len = buf[arg - 2] << 8 | buf[arg - 1];
2359         if (len < EVP_CCM_TLS_EXPLICIT_IV_LEN)
2360             return 0;
2361
2362         /* Correct length for explicit iv. */
2363         len -= EVP_CCM_TLS_EXPLICIT_IV_LEN;
2364
2365         enc = EVP_CIPHER_CTX_encrypting(c);
2366         if (!enc) {
2367             if (len < cctx->aes.ccm.m)
2368                 return 0;
2369
2370             /* Correct length for tag. */
2371             len -= cctx->aes.ccm.m;
2372         }
2373
2374         buf[arg - 2] = len >> 8;
2375         buf[arg - 1] = len & 0xff;
2376
2377         /* Extra padding: tag appended to record. */
2378         return cctx->aes.ccm.m;
2379
2380     case EVP_CTRL_CCM_SET_IV_FIXED:
2381         if (arg != EVP_CCM_TLS_FIXED_IV_LEN)
2382             return 0;
2383
2384         /* Copy to first part of the iv. */
2385         iv = EVP_CIPHER_CTX_iv_noconst(c);
2386         memcpy(iv, ptr, arg);
2387         return 1;
2388
2389     case EVP_CTRL_AEAD_SET_IVLEN:
2390         arg = 15 - arg;
2391         /* fall-through */
2392
2393     case EVP_CTRL_CCM_SET_L:
2394         if (arg < 2 || arg > 8)
2395             return 0;
2396
2397         cctx->aes.ccm.l = arg;
2398         return 1;
2399
2400     case EVP_CTRL_AEAD_SET_TAG:
2401         if ((arg & 1) || arg < 4 || arg > 16)
2402             return 0;
2403
2404         enc = EVP_CIPHER_CTX_encrypting(c);
2405         if (enc && ptr)
2406             return 0;
2407
2408         if (ptr) {
2409             cctx->aes.ccm.tag_set = 1;
2410             buf = EVP_CIPHER_CTX_buf_noconst(c);
2411             memcpy(buf, ptr, arg);
2412         }
2413
2414         cctx->aes.ccm.m = arg;
2415         return 1;
2416
2417     case EVP_CTRL_AEAD_GET_TAG:
2418         enc = EVP_CIPHER_CTX_encrypting(c);
2419         if (!enc || !cctx->aes.ccm.tag_set)
2420             return 0;
2421
2422         if(arg < cctx->aes.ccm.m)
2423             return 0;
2424
2425         memcpy(ptr, cctx->aes.ccm.kmac_param.icv.b, cctx->aes.ccm.m);
2426         cctx->aes.ccm.tag_set = 0;
2427         cctx->aes.ccm.iv_set = 0;
2428         cctx->aes.ccm.len_set = 0;
2429         return 1;
2430
2431     case EVP_CTRL_COPY:
2432         return 1;
2433
2434     default:
2435         return -1;
2436     }
2437 }
2438
2439 # define s390x_aes_ccm_cleanup aes_ccm_cleanup
2440
2441 # ifndef OPENSSL_NO_OCB
2442 #  define S390X_AES_OCB_CTX             EVP_AES_OCB_CTX
2443 #  define S390X_aes_128_ocb_CAPABLE     0
2444 #  define S390X_aes_192_ocb_CAPABLE     0
2445 #  define S390X_aes_256_ocb_CAPABLE     0
2446
2447 #  define s390x_aes_ocb_init_key aes_ocb_init_key
2448 static int s390x_aes_ocb_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
2449                                   const unsigned char *iv, int enc);
2450 #  define s390x_aes_ocb_cipher aes_ocb_cipher
2451 static int s390x_aes_ocb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2452                                 const unsigned char *in, size_t len);
2453 #  define s390x_aes_ocb_cleanup aes_ocb_cleanup
2454 static int s390x_aes_ocb_cleanup(EVP_CIPHER_CTX *);
2455 #  define s390x_aes_ocb_ctrl aes_ocb_ctrl
2456 static int s390x_aes_ocb_ctrl(EVP_CIPHER_CTX *, int type, int arg, void *ptr);
2457 # endif
2458
2459 # ifndef OPENSSL_NO_SIV
2460 #  define S390X_AES_SIV_CTX             EVP_AES_SIV_CTX
2461 #  define S390X_aes_128_siv_CAPABLE     0
2462 #  define S390X_aes_192_siv_CAPABLE     0
2463 #  define S390X_aes_256_siv_CAPABLE     0
2464
2465 #  define s390x_aes_siv_init_key aes_siv_init_key
2466 #  define s390x_aes_siv_cipher aes_siv_cipher
2467 #  define s390x_aes_siv_cleanup aes_siv_cleanup
2468 #  define s390x_aes_siv_ctrl aes_siv_ctrl
2469 # endif
2470
2471 # define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,    \
2472                               MODE,flags)                               \
2473 static const EVP_CIPHER s390x_aes_##keylen##_##mode = {                 \
2474     nid##_##keylen##_##nmode,blocksize,                                 \
2475     keylen / 8,                                                         \
2476     ivlen,                                                              \
2477     flags | EVP_CIPH_##MODE##_MODE,                                     \
2478     s390x_aes_##mode##_init_key,                                        \
2479     s390x_aes_##mode##_cipher,                                          \
2480     NULL,                                                               \
2481     sizeof(S390X_AES_##MODE##_CTX),                                     \
2482     NULL,                                                               \
2483     NULL,                                                               \
2484     NULL,                                                               \
2485     NULL                                                                \
2486 };                                                                      \
2487 static const EVP_CIPHER aes_##keylen##_##mode = {                       \
2488     nid##_##keylen##_##nmode,                                           \
2489     blocksize,                                                          \
2490     keylen / 8,                                                         \
2491     ivlen,                                                              \
2492     flags | EVP_CIPH_##MODE##_MODE,                                     \
2493     aes_init_key,                                                       \
2494     aes_##mode##_cipher,                                                \
2495     NULL,                                                               \
2496     sizeof(EVP_AES_KEY),                                                \
2497     NULL,                                                               \
2498     NULL,                                                               \
2499     NULL,                                                               \
2500     NULL                                                                \
2501 };                                                                      \
2502 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void)                       \
2503 {                                                                       \
2504     return S390X_aes_##keylen##_##mode##_CAPABLE ?                      \
2505            &s390x_aes_##keylen##_##mode : &aes_##keylen##_##mode;       \
2506 }
2507
2508 # define BLOCK_CIPHER_custom(nid,keylen,blocksize,ivlen,mode,MODE,flags)\
2509 static const EVP_CIPHER s390x_aes_##keylen##_##mode = {                 \
2510     nid##_##keylen##_##mode,                                            \
2511     blocksize,                                                          \
2512     (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE||EVP_CIPH_##MODE##_MODE==EVP_CIPH_SIV_MODE ? 2 : 1) * keylen / 8,        \
2513     ivlen,                                                              \
2514     flags | EVP_CIPH_##MODE##_MODE,                                     \
2515     s390x_aes_##mode##_init_key,                                        \
2516     s390x_aes_##mode##_cipher,                                          \
2517     s390x_aes_##mode##_cleanup,                                         \
2518     sizeof(S390X_AES_##MODE##_CTX),                                     \
2519     NULL,                                                               \
2520     NULL,                                                               \
2521     s390x_aes_##mode##_ctrl,                                            \
2522     NULL                                                                \
2523 };                                                                      \
2524 static const EVP_CIPHER aes_##keylen##_##mode = {                       \
2525     nid##_##keylen##_##mode,blocksize,                                  \
2526     (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE||EVP_CIPH_##MODE##_MODE==EVP_CIPH_SIV_MODE ? 2 : 1) * keylen / 8,        \
2527     ivlen,                                                              \
2528     flags | EVP_CIPH_##MODE##_MODE,                                     \
2529     aes_##mode##_init_key,                                              \
2530     aes_##mode##_cipher,                                                \
2531     aes_##mode##_cleanup,                                               \
2532     sizeof(EVP_AES_##MODE##_CTX),                                       \
2533     NULL,                                                               \
2534     NULL,                                                               \
2535     aes_##mode##_ctrl,                                                  \
2536     NULL                                                                \
2537 };                                                                      \
2538 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void)                       \
2539 {                                                                       \
2540     return S390X_aes_##keylen##_##mode##_CAPABLE ?                      \
2541            &s390x_aes_##keylen##_##mode : &aes_##keylen##_##mode;       \
2542 }
2543
2544 #else
2545
2546 # define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \
2547 static const EVP_CIPHER aes_##keylen##_##mode = { \
2548         nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \
2549         flags|EVP_CIPH_##MODE##_MODE,   \
2550         aes_init_key,                   \
2551         aes_##mode##_cipher,            \
2552         NULL,                           \
2553         sizeof(EVP_AES_KEY),            \
2554         NULL,NULL,NULL,NULL }; \
2555 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
2556 { return &aes_##keylen##_##mode; }
2557
2558 # define BLOCK_CIPHER_custom(nid,keylen,blocksize,ivlen,mode,MODE,flags) \
2559 static const EVP_CIPHER aes_##keylen##_##mode = { \
2560         nid##_##keylen##_##mode,blocksize, \
2561         (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE||EVP_CIPH_##MODE##_MODE==EVP_CIPH_SIV_MODE?2:1)*keylen/8, \
2562         ivlen,                          \
2563         flags|EVP_CIPH_##MODE##_MODE,   \
2564         aes_##mode##_init_key,          \
2565         aes_##mode##_cipher,            \
2566         aes_##mode##_cleanup,           \
2567         sizeof(EVP_AES_##MODE##_CTX),   \
2568         NULL,NULL,aes_##mode##_ctrl,NULL }; \
2569 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
2570 { return &aes_##keylen##_##mode; }
2571
2572 #endif
2573
2574 #if defined(OPENSSL_CPUID_OBJ) && (defined(__arm__) || defined(__arm) || defined(__aarch64__))
2575 # include "arm_arch.h"
2576 # if __ARM_MAX_ARCH__>=7
2577 #  if defined(BSAES_ASM)
2578 #   define BSAES_CAPABLE (OPENSSL_armcap_P & ARMV7_NEON)
2579 #  endif
2580 #  if defined(VPAES_ASM)
2581 #   define VPAES_CAPABLE (OPENSSL_armcap_P & ARMV7_NEON)
2582 #  endif
2583 #  define HWAES_CAPABLE (OPENSSL_armcap_P & ARMV8_AES)
2584 #  define HWAES_set_encrypt_key aes_v8_set_encrypt_key
2585 #  define HWAES_set_decrypt_key aes_v8_set_decrypt_key
2586 #  define HWAES_encrypt aes_v8_encrypt
2587 #  define HWAES_decrypt aes_v8_decrypt
2588 #  define HWAES_cbc_encrypt aes_v8_cbc_encrypt
2589 #  define HWAES_ctr32_encrypt_blocks aes_v8_ctr32_encrypt_blocks
2590 # endif
2591 #endif
2592
2593 #if defined(HWAES_CAPABLE)
2594 int HWAES_set_encrypt_key(const unsigned char *userKey, const int bits,
2595                           AES_KEY *key);
2596 int HWAES_set_decrypt_key(const unsigned char *userKey, const int bits,
2597                           AES_KEY *key);
2598 void HWAES_encrypt(const unsigned char *in, unsigned char *out,
2599                    const AES_KEY *key);
2600 void HWAES_decrypt(const unsigned char *in, unsigned char *out,
2601                    const AES_KEY *key);
2602 void HWAES_cbc_encrypt(const unsigned char *in, unsigned char *out,
2603                        size_t length, const AES_KEY *key,
2604                        unsigned char *ivec, const int enc);
2605 void HWAES_ctr32_encrypt_blocks(const unsigned char *in, unsigned char *out,
2606                                 size_t len, const AES_KEY *key,
2607                                 const unsigned char ivec[16]);
2608 void HWAES_xts_encrypt(const unsigned char *inp, unsigned char *out,
2609                        size_t len, const AES_KEY *key1,
2610                        const AES_KEY *key2, const unsigned char iv[16]);
2611 void HWAES_xts_decrypt(const unsigned char *inp, unsigned char *out,
2612                        size_t len, const AES_KEY *key1,
2613                        const AES_KEY *key2, const unsigned char iv[16]);
2614 #endif
2615
2616 #define BLOCK_CIPHER_generic_pack(nid,keylen,flags)             \
2617         BLOCK_CIPHER_generic(nid,keylen,16,16,cbc,cbc,CBC,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)     \
2618         BLOCK_CIPHER_generic(nid,keylen,16,0,ecb,ecb,ECB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)      \
2619         BLOCK_CIPHER_generic(nid,keylen,1,16,ofb128,ofb,OFB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)   \
2620         BLOCK_CIPHER_generic(nid,keylen,1,16,cfb128,cfb,CFB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)   \
2621         BLOCK_CIPHER_generic(nid,keylen,1,16,cfb1,cfb1,CFB,flags)       \
2622         BLOCK_CIPHER_generic(nid,keylen,1,16,cfb8,cfb8,CFB,flags)       \
2623         BLOCK_CIPHER_generic(nid,keylen,1,16,ctr,ctr,CTR,flags)
2624
2625 static int aes_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
2626                         const unsigned char *iv, int enc)
2627 {
2628     int ret, mode;
2629     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
2630
2631     mode = EVP_CIPHER_CTX_mode(ctx);
2632     if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
2633         && !enc) {
2634 #ifdef HWAES_CAPABLE
2635         if (HWAES_CAPABLE) {
2636             ret = HWAES_set_decrypt_key(key,
2637                                         EVP_CIPHER_CTX_key_length(ctx) * 8,
2638                                         &dat->ks.ks);
2639             dat->block = (block128_f) HWAES_decrypt;
2640             dat->stream.cbc = NULL;
2641 # ifdef HWAES_cbc_encrypt
2642             if (mode == EVP_CIPH_CBC_MODE)
2643                 dat->stream.cbc = (cbc128_f) HWAES_cbc_encrypt;
2644 # endif
2645         } else
2646 #endif
2647 #ifdef BSAES_CAPABLE
2648         if (BSAES_CAPABLE && mode == EVP_CIPH_CBC_MODE) {
2649             ret = AES_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2650                                       &dat->ks.ks);
2651             dat->block = (block128_f) AES_decrypt;
2652             dat->stream.cbc = (cbc128_f) bsaes_cbc_encrypt;
2653         } else
2654 #endif
2655 #ifdef VPAES_CAPABLE
2656         if (VPAES_CAPABLE) {
2657             ret = vpaes_set_decrypt_key(key,
2658                                         EVP_CIPHER_CTX_key_length(ctx) * 8,
2659                                         &dat->ks.ks);
2660             dat->block = (block128_f) vpaes_decrypt;
2661             dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
2662                 (cbc128_f) vpaes_cbc_encrypt : NULL;
2663         } else
2664 #endif
2665         {
2666             ret = AES_set_decrypt_key(key,
2667                                       EVP_CIPHER_CTX_key_length(ctx) * 8,
2668                                       &dat->ks.ks);
2669             dat->block = (block128_f) AES_decrypt;
2670             dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
2671                 (cbc128_f) AES_cbc_encrypt : NULL;
2672         }
2673     } else
2674 #ifdef HWAES_CAPABLE
2675     if (HWAES_CAPABLE) {
2676         ret = HWAES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2677                                     &dat->ks.ks);
2678         dat->block = (block128_f) HWAES_encrypt;
2679         dat->stream.cbc = NULL;
2680 # ifdef HWAES_cbc_encrypt
2681         if (mode == EVP_CIPH_CBC_MODE)
2682             dat->stream.cbc = (cbc128_f) HWAES_cbc_encrypt;
2683         else
2684 # endif
2685 # ifdef HWAES_ctr32_encrypt_blocks
2686         if (mode == EVP_CIPH_CTR_MODE)
2687             dat->stream.ctr = (ctr128_f) HWAES_ctr32_encrypt_blocks;
2688         else
2689 # endif
2690             (void)0;            /* terminate potentially open 'else' */
2691     } else
2692 #endif
2693 #ifdef BSAES_CAPABLE
2694     if (BSAES_CAPABLE && mode == EVP_CIPH_CTR_MODE) {
2695         ret = AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2696                                   &dat->ks.ks);
2697         dat->block = (block128_f) AES_encrypt;
2698         dat->stream.ctr = (ctr128_f) bsaes_ctr32_encrypt_blocks;
2699     } else
2700 #endif
2701 #ifdef VPAES_CAPABLE
2702     if (VPAES_CAPABLE) {
2703         ret = vpaes_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2704                                     &dat->ks.ks);
2705         dat->block = (block128_f) vpaes_encrypt;
2706         dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
2707             (cbc128_f) vpaes_cbc_encrypt : NULL;
2708     } else
2709 #endif
2710     {
2711         ret = AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
2712                                   &dat->ks.ks);
2713         dat->block = (block128_f) AES_encrypt;
2714         dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
2715             (cbc128_f) AES_cbc_encrypt : NULL;
2716 #ifdef AES_CTR_ASM
2717         if (mode == EVP_CIPH_CTR_MODE)
2718             dat->stream.ctr = (ctr128_f) AES_ctr32_encrypt;
2719 #endif
2720     }
2721
2722     if (ret < 0) {
2723         EVPerr(EVP_F_AES_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
2724         return 0;
2725     }
2726
2727     return 1;
2728 }
2729
2730 static int aes_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2731                           const unsigned char *in, size_t len)
2732 {
2733     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
2734
2735     if (dat->stream.cbc)
2736         (*dat->stream.cbc) (in, out, len, &dat->ks,
2737                             EVP_CIPHER_CTX_iv_noconst(ctx),
2738                             EVP_CIPHER_CTX_encrypting(ctx));
2739     else if (EVP_CIPHER_CTX_encrypting(ctx))
2740         CRYPTO_cbc128_encrypt(in, out, len, &dat->ks,
2741                               EVP_CIPHER_CTX_iv_noconst(ctx), dat->block);
2742     else
2743         CRYPTO_cbc128_decrypt(in, out, len, &dat->ks,
2744                               EVP_CIPHER_CTX_iv_noconst(ctx), dat->block);
2745
2746     return 1;
2747 }
2748
2749 static int aes_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2750                           const unsigned char *in, size_t len)
2751 {
2752     size_t bl = EVP_CIPHER_CTX_block_size(ctx);
2753     size_t i;
2754     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
2755
2756     if (len < bl)
2757         return 1;
2758
2759     for (i = 0, len -= bl; i <= len; i += bl)
2760         (*dat->block) (in + i, out + i, &dat->ks);
2761
2762     return 1;
2763 }
2764
2765 static int aes_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2766                           const unsigned char *in, size_t len)
2767 {
2768     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
2769
2770     int num = EVP_CIPHER_CTX_num(ctx);
2771     CRYPTO_ofb128_encrypt(in, out, len, &dat->ks,
2772                           EVP_CIPHER_CTX_iv_noconst(ctx), &num, dat->block);
2773     EVP_CIPHER_CTX_set_num(ctx, num);
2774     return 1;
2775 }
2776
2777 static int aes_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2778                           const unsigned char *in, size_t len)
2779 {
2780     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
2781
2782     int num = EVP_CIPHER_CTX_num(ctx);
2783     CRYPTO_cfb128_encrypt(in, out, len, &dat->ks,
2784                           EVP_CIPHER_CTX_iv_noconst(ctx), &num,
2785                           EVP_CIPHER_CTX_encrypting(ctx), dat->block);
2786     EVP_CIPHER_CTX_set_num(ctx, num);
2787     return 1;
2788 }
2789
2790 static int aes_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2791                            const unsigned char *in, size_t len)
2792 {
2793     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
2794
2795     int num = EVP_CIPHER_CTX_num(ctx);
2796     CRYPTO_cfb128_8_encrypt(in, out, len, &dat->ks,
2797                             EVP_CIPHER_CTX_iv_noconst(ctx), &num,
2798                             EVP_CIPHER_CTX_encrypting(ctx), dat->block);
2799     EVP_CIPHER_CTX_set_num(ctx, num);
2800     return 1;
2801 }
2802
2803 static int aes_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2804                            const unsigned char *in, size_t len)
2805 {
2806     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
2807
2808     if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS)) {
2809         int num = EVP_CIPHER_CTX_num(ctx);
2810         CRYPTO_cfb128_1_encrypt(in, out, len, &dat->ks,
2811                                 EVP_CIPHER_CTX_iv_noconst(ctx), &num,
2812                                 EVP_CIPHER_CTX_encrypting(ctx), dat->block);
2813         EVP_CIPHER_CTX_set_num(ctx, num);
2814         return 1;
2815     }
2816
2817     while (len >= MAXBITCHUNK) {
2818         int num = EVP_CIPHER_CTX_num(ctx);
2819         CRYPTO_cfb128_1_encrypt(in, out, MAXBITCHUNK * 8, &dat->ks,
2820                                 EVP_CIPHER_CTX_iv_noconst(ctx), &num,
2821                                 EVP_CIPHER_CTX_encrypting(ctx), dat->block);
2822         EVP_CIPHER_CTX_set_num(ctx, num);
2823         len -= MAXBITCHUNK;
2824         out += MAXBITCHUNK;
2825         in  += MAXBITCHUNK;
2826     }
2827     if (len) {
2828         int num = EVP_CIPHER_CTX_num(ctx);
2829         CRYPTO_cfb128_1_encrypt(in, out, len * 8, &dat->ks,
2830                                 EVP_CIPHER_CTX_iv_noconst(ctx), &num,
2831                                 EVP_CIPHER_CTX_encrypting(ctx), dat->block);
2832         EVP_CIPHER_CTX_set_num(ctx, num);
2833     }
2834
2835     return 1;
2836 }
2837
2838 static int aes_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
2839                           const unsigned char *in, size_t len)
2840 {
2841     unsigned int num = EVP_CIPHER_CTX_num(ctx);
2842     EVP_AES_KEY *dat = EVP_C_DATA(EVP_AES_KEY,ctx);
2843
2844     if (dat->stream.ctr)
2845         CRYPTO_ctr128_encrypt_ctr32(in, out, len, &dat->ks,
2846                                     EVP_CIPHER_CTX_iv_noconst(ctx),
2847                                     EVP_CIPHER_CTX_buf_noconst(ctx),
2848                                     &num, dat->stream.ctr);
2849     else
2850         CRYPTO_ctr128_encrypt(in, out, len, &dat->ks,
2851                               EVP_CIPHER_CTX_iv_noconst(ctx),
2852                               EVP_CIPHER_CTX_buf_noconst(ctx), &num,
2853                               dat->block);
2854     EVP_CIPHER_CTX_set_num(ctx, num);
2855     return 1;
2856 }
2857
2858 BLOCK_CIPHER_generic_pack(NID_aes, 128, 0)
2859     BLOCK_CIPHER_generic_pack(NID_aes, 192, 0)
2860     BLOCK_CIPHER_generic_pack(NID_aes, 256, 0)
2861
2862 static int aes_gcm_cleanup(EVP_CIPHER_CTX *c)
2863 {
2864     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,c);
2865     if (gctx == NULL)
2866         return 0;
2867     OPENSSL_cleanse(&gctx->gcm, sizeof(gctx->gcm));
2868     if (gctx->iv != EVP_CIPHER_CTX_iv_noconst(c))
2869         OPENSSL_free(gctx->iv);
2870     return 1;
2871 }
2872
2873 static int aes_gcm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
2874 {
2875     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,c);
2876     switch (type) {
2877     case EVP_CTRL_INIT:
2878         gctx->key_set = 0;
2879         gctx->iv_set = 0;
2880         gctx->ivlen = c->cipher->iv_len;
2881         gctx->iv = c->iv;
2882         gctx->taglen = -1;
2883         gctx->iv_gen = 0;
2884         gctx->tls_aad_len = -1;
2885         return 1;
2886
2887     case EVP_CTRL_AEAD_SET_IVLEN:
2888         if (arg <= 0)
2889             return 0;
2890         /* Allocate memory for IV if needed */
2891         if ((arg > EVP_MAX_IV_LENGTH) && (arg > gctx->ivlen)) {
2892             if (gctx->iv != c->iv)
2893                 OPENSSL_free(gctx->iv);
2894             if ((gctx->iv = OPENSSL_malloc(arg)) == NULL) {
2895                 EVPerr(EVP_F_AES_GCM_CTRL, ERR_R_MALLOC_FAILURE);
2896                 return 0;
2897             }
2898         }
2899         gctx->ivlen = arg;
2900         return 1;
2901
2902     case EVP_CTRL_AEAD_SET_TAG:
2903         if (arg <= 0 || arg > 16 || c->encrypt)
2904             return 0;
2905         memcpy(c->buf, ptr, arg);
2906         gctx->taglen = arg;
2907         return 1;
2908
2909     case EVP_CTRL_AEAD_GET_TAG:
2910         if (arg <= 0 || arg > 16 || !c->encrypt
2911             || gctx->taglen < 0)
2912             return 0;
2913         memcpy(ptr, c->buf, arg);
2914         return 1;
2915
2916     case EVP_CTRL_GET_IV:
2917         if (gctx->iv_gen != 1 && gctx->iv_gen_rand != 1)
2918             return 0;
2919         if (gctx->ivlen != arg)
2920             return 0;
2921         memcpy(ptr, gctx->iv, arg);
2922         return 1;
2923
2924     case EVP_CTRL_GCM_SET_IV_FIXED:
2925         /* Special case: -1 length restores whole IV */
2926         if (arg == -1) {
2927             memcpy(gctx->iv, ptr, gctx->ivlen);
2928             gctx->iv_gen = 1;
2929             return 1;
2930         }
2931         /*
2932          * Fixed field must be at least 4 bytes and invocation field at least
2933          * 8.
2934          */
2935         if ((arg < 4) || (gctx->ivlen - arg) < 8)
2936             return 0;
2937         if (arg)
2938             memcpy(gctx->iv, ptr, arg);
2939         if (c->encrypt && RAND_bytes(gctx->iv + arg, gctx->ivlen - arg) <= 0)
2940             return 0;
2941         gctx->iv_gen = 1;
2942         return 1;
2943
2944     case EVP_CTRL_GCM_IV_GEN:
2945         if (gctx->iv_gen == 0 || gctx->key_set == 0)
2946             return 0;
2947         CRYPTO_gcm128_setiv(&gctx->gcm, gctx->iv, gctx->ivlen);
2948         if (arg <= 0 || arg > gctx->ivlen)
2949             arg = gctx->ivlen;
2950         memcpy(ptr, gctx->iv + gctx->ivlen - arg, arg);
2951         /*
2952          * Invocation field will be at least 8 bytes in size and so no need
2953          * to check wrap around or increment more than last 8 bytes.
2954          */
2955         ctr64_inc(gctx->iv + gctx->ivlen - 8);
2956         gctx->iv_set = 1;
2957         return 1;
2958
2959     case EVP_CTRL_GCM_SET_IV_INV:
2960         if (gctx->iv_gen == 0 || gctx->key_set == 0 || c->encrypt)
2961             return 0;
2962         memcpy(gctx->iv + gctx->ivlen - arg, ptr, arg);
2963         CRYPTO_gcm128_setiv(&gctx->gcm, gctx->iv, gctx->ivlen);
2964         gctx->iv_set = 1;
2965         return 1;
2966
2967     case EVP_CTRL_AEAD_TLS1_AAD:
2968         /* Save the AAD for later use */
2969         if (arg != EVP_AEAD_TLS1_AAD_LEN)
2970             return 0;
2971         memcpy(c->buf, ptr, arg);
2972         gctx->tls_aad_len = arg;
2973         gctx->tls_enc_records = 0;
2974         {
2975             unsigned int len = c->buf[arg - 2] << 8 | c->buf[arg - 1];
2976             /* Correct length for explicit IV */
2977             if (len < EVP_GCM_TLS_EXPLICIT_IV_LEN)
2978                 return 0;
2979             len -= EVP_GCM_TLS_EXPLICIT_IV_LEN;
2980             /* If decrypting correct for tag too */
2981             if (!c->encrypt) {
2982                 if (len < EVP_GCM_TLS_TAG_LEN)
2983                     return 0;
2984                 len -= EVP_GCM_TLS_TAG_LEN;
2985             }
2986             c->buf[arg - 2] = len >> 8;
2987             c->buf[arg - 1] = len & 0xff;
2988         }
2989         /* Extra padding: tag appended to record */
2990         return EVP_GCM_TLS_TAG_LEN;
2991
2992     case EVP_CTRL_COPY:
2993         {
2994             EVP_CIPHER_CTX *out = ptr;
2995             EVP_AES_GCM_CTX *gctx_out = EVP_C_DATA(EVP_AES_GCM_CTX,out);
2996             if (gctx->gcm.key) {
2997                 if (gctx->gcm.key != &gctx->ks)
2998                     return 0;
2999                 gctx_out->gcm.key = &gctx_out->ks;
3000             }
3001             if (gctx->iv == c->iv)
3002                 gctx_out->iv = out->iv;
3003             else {
3004                 if ((gctx_out->iv = OPENSSL_malloc(gctx->ivlen)) == NULL) {
3005                     EVPerr(EVP_F_AES_GCM_CTRL, ERR_R_MALLOC_FAILURE);
3006                     return 0;
3007                 }
3008                 memcpy(gctx_out->iv, gctx->iv, gctx->ivlen);
3009             }
3010             return 1;
3011         }
3012
3013     default:
3014         return -1;
3015
3016     }
3017 }
3018
3019 static int aes_gcm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
3020                             const unsigned char *iv, int enc)
3021 {
3022     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,ctx);
3023     if (!iv && !key)
3024         return 1;
3025     if (key) {
3026         do {
3027 #ifdef HWAES_CAPABLE
3028             if (HWAES_CAPABLE) {
3029                 HWAES_set_encrypt_key(key, ctx->key_len * 8, &gctx->ks.ks);
3030                 CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
3031                                    (block128_f) HWAES_encrypt);
3032 # ifdef HWAES_ctr32_encrypt_blocks
3033                 gctx->ctr = (ctr128_f) HWAES_ctr32_encrypt_blocks;
3034 # else
3035                 gctx->ctr = NULL;
3036 # endif
3037                 break;
3038             } else
3039 #endif
3040 #ifdef BSAES_CAPABLE
3041             if (BSAES_CAPABLE) {
3042                 AES_set_encrypt_key(key, ctx->key_len * 8, &gctx->ks.ks);
3043                 CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
3044                                    (block128_f) AES_encrypt);
3045                 gctx->ctr = (ctr128_f) bsaes_ctr32_encrypt_blocks;
3046                 break;
3047             } else
3048 #endif
3049 #ifdef VPAES_CAPABLE
3050             if (VPAES_CAPABLE) {
3051                 vpaes_set_encrypt_key(key, ctx->key_len * 8, &gctx->ks.ks);
3052                 CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
3053                                    (block128_f) vpaes_encrypt);
3054                 gctx->ctr = NULL;
3055                 break;
3056             } else
3057 #endif
3058                 (void)0;        /* terminate potentially open 'else' */
3059
3060             AES_set_encrypt_key(key, ctx->key_len * 8, &gctx->ks.ks);
3061             CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
3062                                (block128_f) AES_encrypt);
3063 #ifdef AES_CTR_ASM
3064             gctx->ctr = (ctr128_f) AES_ctr32_encrypt;
3065 #else
3066             gctx->ctr = NULL;
3067 #endif
3068         } while (0);
3069
3070         /*
3071          * If we have an iv can set it directly, otherwise use saved IV.
3072          */
3073         if (iv == NULL && gctx->iv_set)
3074             iv = gctx->iv;
3075         if (iv) {
3076             CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
3077             gctx->iv_set = 1;
3078         }
3079         gctx->key_set = 1;
3080     } else {
3081         /* If key set use IV, otherwise copy */
3082         if (gctx->key_set)
3083             CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
3084         else
3085             memcpy(gctx->iv, iv, gctx->ivlen);
3086         gctx->iv_set = 1;
3087         gctx->iv_gen = 0;
3088     }
3089     return 1;
3090 }
3091
3092 /*
3093  * Handle TLS GCM packet format. This consists of the last portion of the IV
3094  * followed by the payload and finally the tag. On encrypt generate IV,
3095  * encrypt payload and write the tag. On verify retrieve IV, decrypt payload
3096  * and verify tag.
3097  */
3098
3099 static int aes_gcm_tls_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
3100                               const unsigned char *in, size_t len)
3101 {
3102     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,ctx);
3103     int rv = -1;
3104     /* Encrypt/decrypt must be performed in place */
3105     if (out != in
3106         || len < (EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN))
3107         return -1;
3108
3109     /*
3110      * Check for too many keys as per FIPS 140-2 IG A.5 "Key/IV Pair Uniqueness
3111      * Requirements from SP 800-38D".  The requirements is for one party to the
3112      * communication to fail after 2^64 - 1 keys.  We do this on the encrypting
3113      * side only.
3114      */
3115     if (ctx->encrypt && ++gctx->tls_enc_records == 0) {
3116         EVPerr(EVP_F_AES_GCM_TLS_CIPHER, EVP_R_TOO_MANY_RECORDS);
3117         goto err;
3118     }
3119
3120     /*
3121      * Set IV from start of buffer or generate IV and write to start of
3122      * buffer.
3123      */
3124     if (EVP_CIPHER_CTX_ctrl(ctx, ctx->encrypt ? EVP_CTRL_GCM_IV_GEN
3125                                               : EVP_CTRL_GCM_SET_IV_INV,
3126                             EVP_GCM_TLS_EXPLICIT_IV_LEN, out) <= 0)
3127         goto err;
3128     /* Use saved AAD */
3129     if (CRYPTO_gcm128_aad(&gctx->gcm, ctx->buf, gctx->tls_aad_len))
3130         goto err;
3131     /* Fix buffer and length to point to payload */
3132     in += EVP_GCM_TLS_EXPLICIT_IV_LEN;
3133     out += EVP_GCM_TLS_EXPLICIT_IV_LEN;
3134     len -= EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
3135     if (ctx->encrypt) {
3136         /* Encrypt payload */
3137         if (gctx->ctr) {
3138             size_t bulk = 0;
3139 #if defined(AES_GCM_ASM)
3140             if (len >= 32 && AES_GCM_ASM(gctx)) {
3141                 if (CRYPTO_gcm128_encrypt(&gctx->gcm, NULL, NULL, 0))
3142                     return -1;
3143
3144                 bulk = AES_gcm_encrypt(in, out, len,
3145                                        gctx->gcm.key,
3146                                        gctx->gcm.Yi.c, gctx->gcm.Xi.u);
3147                 gctx->gcm.len.u[1] += bulk;
3148             }
3149 #endif
3150             if (CRYPTO_gcm128_encrypt_ctr32(&gctx->gcm,
3151                                             in + bulk,
3152                                             out + bulk,
3153                                             len - bulk, gctx->ctr))
3154                 goto err;
3155         } else {
3156             size_t bulk = 0;
3157 #if defined(AES_GCM_ASM2)
3158             if (len >= 32 && AES_GCM_ASM2(gctx)) {
3159                 if (CRYPTO_gcm128_encrypt(&gctx->gcm, NULL, NULL, 0))
3160                     return -1;
3161
3162                 bulk = AES_gcm_encrypt(in, out, len,
3163                                        gctx->gcm.key,
3164                                        gctx->gcm.Yi.c, gctx->gcm.Xi.u);
3165                 gctx->gcm.len.u[1] += bulk;
3166             }
3167 #endif
3168             if (CRYPTO_gcm128_encrypt(&gctx->gcm,
3169                                       in + bulk, out + bulk, len - bulk))
3170                 goto err;
3171         }
3172         out += len;
3173         /* Finally write tag */
3174         CRYPTO_gcm128_tag(&gctx->gcm, out, EVP_GCM_TLS_TAG_LEN);
3175         rv = len + EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
3176     } else {
3177         /* Decrypt */
3178         if (gctx->ctr) {
3179             size_t bulk = 0;
3180 #if defined(AES_GCM_ASM)
3181             if (len >= 16 && AES_GCM_ASM(gctx)) {
3182                 if (CRYPTO_gcm128_decrypt(&gctx->gcm, NULL, NULL, 0))
3183                     return -1;
3184
3185                 bulk = AES_gcm_decrypt(in, out, len,
3186                                        gctx->gcm.key,
3187                                        gctx->gcm.Yi.c, gctx->gcm.Xi.u);
3188                 gctx->gcm.len.u[1] += bulk;
3189             }
3190 #endif
3191             if (CRYPTO_gcm128_decrypt_ctr32(&gctx->gcm,
3192                                             in + bulk,
3193                                             out + bulk,
3194                                             len - bulk, gctx->ctr))
3195                 goto err;
3196         } else {
3197             size_t bulk = 0;
3198 #if defined(AES_GCM_ASM2)
3199             if (len >= 16 && AES_GCM_ASM2(gctx)) {
3200                 if (CRYPTO_gcm128_decrypt(&gctx->gcm, NULL, NULL, 0))
3201                     return -1;
3202
3203                 bulk = AES_gcm_decrypt(in, out, len,
3204                                        gctx->gcm.key,
3205                                        gctx->gcm.Yi.c, gctx->gcm.Xi.u);
3206                 gctx->gcm.len.u[1] += bulk;
3207             }
3208 #endif
3209             if (CRYPTO_gcm128_decrypt(&gctx->gcm,
3210                                       in + bulk, out + bulk, len - bulk))
3211                 goto err;
3212         }
3213         /* Retrieve tag */
3214         CRYPTO_gcm128_tag(&gctx->gcm, ctx->buf, EVP_GCM_TLS_TAG_LEN);
3215         /* If tag mismatch wipe buffer */
3216         if (CRYPTO_memcmp(ctx->buf, in + len, EVP_GCM_TLS_TAG_LEN)) {
3217             OPENSSL_cleanse(out, len);
3218             goto err;
3219         }
3220         rv = len;
3221     }
3222
3223  err:
3224     gctx->iv_set = 0;
3225     gctx->tls_aad_len = -1;
3226     return rv;
3227 }
3228
3229 #ifdef FIPS_MODE
3230 /*
3231  * See SP800-38D (GCM) Section 8 "Uniqueness requirement on IVS and keys"
3232  *
3233  * See also 8.2.2 RBG-based construction.
3234  * Random construction consists of a free field (which can be NULL) and a
3235  * random field which will use a DRBG that can return at least 96 bits of
3236  * entropy strength. (The DRBG must be seeded by the FIPS module).
3237  */
3238 static int aes_gcm_iv_generate(EVP_AES_GCM_CTX *gctx, int offset)
3239 {
3240     int sz = gctx->ivlen - offset;
3241
3242     /* Must be at least 96 bits */
3243     if (sz <= 0 || gctx->ivlen < 12)
3244         return 0;
3245
3246     /* Use DRBG to generate random iv */
3247     if (RAND_bytes(gctx->iv + offset, sz) <= 0)
3248         return 0;
3249     return 1;
3250 }
3251 #endif /* FIPS_MODE */
3252
3253 static int aes_gcm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
3254                           const unsigned char *in, size_t len)
3255 {
3256     EVP_AES_GCM_CTX *gctx = EVP_C_DATA(EVP_AES_GCM_CTX,ctx);
3257
3258     /* If not set up, return error */
3259     if (!gctx->key_set)
3260         return -1;
3261
3262     if (gctx->tls_aad_len >= 0)
3263         return aes_gcm_tls_cipher(ctx, out, in, len);
3264
3265 #ifdef FIPS_MODE
3266     /*
3267      * FIPS requires generation of AES-GCM IV's inside the FIPS module.
3268      * The IV can still be set externally (the security policy will state that
3269      * this is not FIPS compliant). There are some applications
3270      * where setting the IV externally is the only option available.
3271      */
3272     if (!gctx->iv_set) {
3273         if (!ctx->encrypt || !aes_gcm_iv_generate(gctx, 0))
3274             return -1;
3275         CRYPTO_gcm128_setiv(&gctx->gcm, gctx->iv, gctx->ivlen);
3276         gctx->iv_set = 1;
3277         gctx->iv_gen_rand = 1;
3278     }
3279 #else
3280     if (!gctx->iv_set)
3281         return -1;
3282 #endif /* FIPS_MODE */
3283
3284     if (in) {
3285         if (out == NULL) {
3286             if (CRYPTO_gcm128_aad(&gctx->gcm, in, len))
3287                 return -1;
3288         } else if (ctx->encrypt) {
3289             if (gctx->ctr) {
3290                 size_t bulk = 0;
3291 #if defined(AES_GCM_ASM)
3292                 if (len >= 32 && AES_GCM_ASM(gctx)) {
3293                     size_t res = (16 - gctx->gcm.mres) % 16;
3294
3295                     if (CRYPTO_gcm128_encrypt(&gctx->gcm, in, out, res))
3296                         return -1;
3297
3298                     bulk = AES_gcm_encrypt(in + res,
3299                                            out + res, len - res,
3300                                            gctx->gcm.key, gctx->gcm.Yi.c,
3301                                            gctx->gcm.Xi.u);
3302                     gctx->gcm.len.u[1] += bulk;
3303                     bulk += res;
3304                 }
3305 #endif
3306                 if (CRYPTO_gcm128_encrypt_ctr32(&gctx->gcm,
3307                                                 in + bulk,
3308                                                 out + bulk,
3309                                                 len - bulk, gctx->ctr))
3310                     return -1;
3311             } else {
3312                 size_t bulk = 0;
3313 #if defined(AES_GCM_ASM2)
3314                 if (len >= 32 && AES_GCM_ASM2(gctx)) {
3315                     size_t res = (16 - gctx->gcm.mres) % 16;
3316
3317                     if (CRYPTO_gcm128_encrypt(&gctx->gcm, in, out, res))
3318                         return -1;
3319
3320                     bulk = AES_gcm_encrypt(in + res,
3321                                            out + res, len - res,
3322                                            gctx->gcm.key, gctx->gcm.Yi.c,
3323                                            gctx->gcm.Xi.u);
3324                     gctx->gcm.len.u[1] += bulk;
3325                     bulk += res;
3326                 }
3327 #endif
3328                 if (CRYPTO_gcm128_encrypt(&gctx->gcm,
3329                                           in + bulk, out + bulk, len - bulk))
3330                     return -1;
3331             }
3332         } else {
3333             if (gctx->ctr) {
3334                 size_t bulk = 0;
3335 #if defined(AES_GCM_ASM)
3336                 if (len >= 16 && AES_GCM_ASM(gctx)) {
3337                     size_t res = (16 - gctx->gcm.mres) % 16;
3338
3339                     if (CRYPTO_gcm128_decrypt(&gctx->gcm, in, out, res))
3340                         return -1;
3341
3342                     bulk = AES_gcm_decrypt(in + res,
3343                                            out + res, len - res,
3344                                            gctx->gcm.key,
3345                                            gctx->gcm.Yi.c, gctx->gcm.Xi.u);
3346                     gctx->gcm.len.u[1] += bulk;
3347                     bulk += res;
3348                 }
3349 #endif
3350                 if (CRYPTO_gcm128_decrypt_ctr32(&gctx->gcm,
3351                                                 in + bulk,
3352                                                 out + bulk,
3353                                                 len - bulk, gctx->ctr))
3354                     return -1;
3355             } else {
3356                 size_t bulk = 0;
3357 #if defined(AES_GCM_ASM2)
3358                 if (len >= 16 && AES_GCM_ASM2(gctx)) {
3359                     size_t res = (16 - gctx->gcm.mres) % 16;
3360
3361                     if (CRYPTO_gcm128_decrypt(&gctx->gcm, in, out, res))
3362                         return -1;
3363
3364                     bulk = AES_gcm_decrypt(in + res,
3365                                            out + res, len - res,
3366                                            gctx->gcm.key,
3367                                            gctx->gcm.Yi.c, gctx->gcm.Xi.u);
3368                     gctx->gcm.len.u[1] += bulk;
3369                     bulk += res;
3370                 }
3371 #endif
3372                 if (CRYPTO_gcm128_decrypt(&gctx->gcm,
3373                                           in + bulk, out + bulk, len - bulk))
3374                     return -1;
3375             }
3376         }
3377         return len;
3378     } else {
3379         if (!ctx->encrypt) {
3380             if (gctx->taglen < 0)
3381                 return -1;
3382             if (CRYPTO_gcm128_finish(&gctx->gcm, ctx->buf, gctx->taglen) != 0)
3383                 return -1;
3384             gctx->iv_set = 0;
3385             return 0;
3386         }
3387         CRYPTO_gcm128_tag(&gctx->gcm, ctx->buf, 16);
3388         gctx->taglen = 16;
3389         /* Don't reuse the IV */
3390         gctx->iv_set = 0;
3391         return 0;
3392     }
3393
3394 }
3395
3396 #define CUSTOM_FLAGS    (EVP_CIPH_FLAG_DEFAULT_ASN1 \
3397                 | EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER \
3398                 | EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT \
3399                 | EVP_CIPH_CUSTOM_COPY)
3400
3401 BLOCK_CIPHER_custom(NID_aes, 128, 1, 12, gcm, GCM,
3402                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
3403     BLOCK_CIPHER_custom(NID_aes, 192, 1, 12, gcm, GCM,
3404                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
3405     BLOCK_CIPHER_custom(NID_aes, 256, 1, 12, gcm, GCM,
3406                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
3407
3408 static int aes_xts_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
3409 {
3410     EVP_AES_XTS_CTX *xctx = EVP_C_DATA(EVP_AES_XTS_CTX,c);
3411     if (type == EVP_CTRL_COPY) {
3412         EVP_CIPHER_CTX *out = ptr;
3413         EVP_AES_XTS_CTX *xctx_out = EVP_C_DATA(EVP_AES_XTS_CTX,out);
3414         if (xctx->xts.key1) {
3415             if (xctx->xts.key1 != &xctx->ks1)
3416                 return 0;
3417             xctx_out->xts.key1 = &xctx_out->ks1;
3418         }
3419         if (xctx->xts.key2) {
3420             if (xctx->xts.key2 != &xctx->ks2)
3421                 return 0;
3422             xctx_out->xts.key2 = &xctx_out->ks2;
3423         }
3424         return 1;
3425     } else if (type != EVP_CTRL_INIT)
3426         return -1;
3427     /* key1 and key2 are used as an indicator both key and IV are set */
3428     xctx->xts.key1 = NULL;
3429     xctx->xts.key2 = NULL;
3430     return 1;
3431 }
3432
3433 static int aes_xts_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
3434                             const unsigned char *iv, int enc)
3435 {
3436     EVP_AES_XTS_CTX *xctx = EVP_C_DATA(EVP_AES_XTS_CTX,ctx);
3437     if (!iv && !key)
3438         return 1;
3439
3440     if (key) {
3441         do {
3442             /* The key is two half length keys in reality */
3443             const int bytes = EVP_CIPHER_CTX_key_length(ctx) / 2;
3444             const int bits = bytes * 8;
3445
3446             /*
3447              * Verify that the two keys are different.
3448              *
3449              * This addresses the vulnerability described in Rogaway's
3450              * September 2004 paper:
3451              *
3452              *      "Efficient Instantiations of Tweakable Blockciphers and
3453              *       Refinements to Modes OCB and PMAC".
3454              *      (http://web.cs.ucdavis.edu/~rogaway/papers/offsets.pdf)
3455              *
3456              * FIPS 140-2 IG A.9 XTS-AES Key Generation Requirements states
3457              * that:
3458              *      "The check for Key_1 != Key_2 shall be done at any place
3459              *       BEFORE using the keys in the XTS-AES algorithm to process
3460              *       data with them."
3461              */
3462             if (memcmp(key, key + bytes, bytes) == 0) {
3463                 EVPerr(EVP_F_AES_XTS_INIT_KEY, EVP_R_XTS_DUPLICATED_KEYS);
3464                 return 0;
3465             }
3466
3467 #ifdef AES_XTS_ASM
3468             xctx->stream = enc ? AES_xts_encrypt : AES_xts_decrypt;
3469 #else
3470             xctx->stream = NULL;
3471 #endif
3472             /* key_len is two AES keys */
3473 #ifdef HWAES_CAPABLE
3474             if (HWAES_CAPABLE) {
3475                 if (enc) {
3476                     HWAES_set_encrypt_key(key, bits, &xctx->ks1.ks);
3477                     xctx->xts.block1 = (block128_f) HWAES_encrypt;
3478 # ifdef HWAES_xts_encrypt
3479                     xctx->stream = HWAES_xts_encrypt;
3480 # endif
3481                 } else {
3482                     HWAES_set_decrypt_key(key, bits, &xctx->ks1.ks);
3483                     xctx->xts.block1 = (block128_f) HWAES_decrypt;
3484 # ifdef HWAES_xts_decrypt
3485                     xctx->stream = HWAES_xts_decrypt;
3486 #endif
3487                 }
3488
3489                 HWAES_set_encrypt_key(key + bytes, bits, &xctx->ks2.ks);
3490                 xctx->xts.block2 = (block128_f) HWAES_encrypt;
3491
3492                 xctx->xts.key1 = &xctx->ks1;
3493                 break;
3494             } else
3495 #endif
3496 #ifdef BSAES_CAPABLE
3497             if (BSAES_CAPABLE)
3498                 xctx->stream = enc ? bsaes_xts_encrypt : bsaes_xts_decrypt;
3499             else
3500 #endif
3501 #ifdef VPAES_CAPABLE
3502             if (VPAES_CAPABLE) {
3503                 if (enc) {
3504                     vpaes_set_encrypt_key(key, bits, &xctx->ks1.ks);
3505                     xctx->xts.block1 = (block128_f) vpaes_encrypt;
3506                 } else {
3507                     vpaes_set_decrypt_key(key, bits, &xctx->ks1.ks);
3508                     xctx->xts.block1 = (block128_f) vpaes_decrypt;
3509                 }
3510
3511                 vpaes_set_encrypt_key(key + bytes, bits, &xctx->ks2.ks);
3512                 xctx->xts.block2 = (block128_f) vpaes_encrypt;
3513
3514                 xctx->xts.key1 = &xctx->ks1;
3515                 break;
3516             } else
3517 #endif
3518                 (void)0;        /* terminate potentially open 'else' */
3519
3520             if (enc) {
3521                 AES_set_encrypt_key(key, bits, &xctx->ks1.ks);
3522                 xctx->xts.block1 = (block128_f) AES_encrypt;
3523             } else {
3524                 AES_set_decrypt_key(key, bits, &xctx->ks1.ks);
3525                 xctx->xts.block1 = (block128_f) AES_decrypt;
3526             }
3527
3528             AES_set_encrypt_key(key + bytes, bits, &xctx->ks2.ks);
3529             xctx->xts.block2 = (block128_f) AES_encrypt;
3530
3531             xctx->xts.key1 = &xctx->ks1;
3532         } while (0);
3533     }
3534
3535     if (iv) {
3536         xctx->xts.key2 = &xctx->ks2;
3537         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 16);
3538     }
3539
3540     return 1;
3541 }
3542
3543 static int aes_xts_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
3544                           const unsigned char *in, size_t len)
3545 {
3546     EVP_AES_XTS_CTX *xctx = EVP_C_DATA(EVP_AES_XTS_CTX,ctx);
3547
3548     if (xctx->xts.key1 == NULL
3549             || xctx->xts.key2 == NULL
3550             || out == NULL
3551             || in == NULL
3552             || len < AES_BLOCK_SIZE)
3553         return 0;
3554
3555     /*
3556      * Impose a limit of 2^20 blocks per data unit as specifed by
3557      * IEEE Std 1619-2018.  The earlier and obsolete IEEE Std 1619-2007
3558      * indicated that this was a SHOULD NOT rather than a MUST NOT.
3559      * NIST SP 800-38E mandates the same limit.
3560      */
3561     if (len > XTS_MAX_BLOCKS_PER_DATA_UNIT * AES_BLOCK_SIZE) {
3562         EVPerr(EVP_F_AES_XTS_CIPHER, EVP_R_XTS_DATA_UNIT_IS_TOO_LARGE);
3563         return 0;
3564     }
3565
3566     if (xctx->stream)
3567         (*xctx->stream) (in, out, len,
3568                          xctx->xts.key1, xctx->xts.key2,
3569                          EVP_CIPHER_CTX_iv_noconst(ctx));
3570     else if (CRYPTO_xts128_encrypt(&xctx->xts, EVP_CIPHER_CTX_iv_noconst(ctx),
3571                                    in, out, len,
3572                                    EVP_CIPHER_CTX_encrypting(ctx)))
3573         return 0;
3574     return 1;
3575 }
3576
3577 #define aes_xts_cleanup NULL
3578
3579 #define XTS_FLAGS       (EVP_CIPH_FLAG_DEFAULT_ASN1 | EVP_CIPH_CUSTOM_IV \
3580                          | EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT \
3581                          | EVP_CIPH_CUSTOM_COPY)
3582
3583 BLOCK_CIPHER_custom(NID_aes, 128, 1, 16, xts, XTS, XTS_FLAGS)
3584     BLOCK_CIPHER_custom(NID_aes, 256, 1, 16, xts, XTS, XTS_FLAGS)
3585
3586 static int aes_ccm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
3587 {
3588     EVP_AES_CCM_CTX *cctx = EVP_C_DATA(EVP_AES_CCM_CTX,c);
3589     switch (type) {
3590     case EVP_CTRL_INIT:
3591         cctx->key_set = 0;
3592         cctx->iv_set = 0;
3593         cctx->L = 8;
3594         cctx->M = 12;
3595         cctx->tag_set = 0;
3596         cctx->len_set = 0;
3597         cctx->tls_aad_len = -1;
3598         return 1;
3599
3600     case EVP_CTRL_AEAD_TLS1_AAD:
3601         /* Save the AAD for later use */
3602         if (arg != EVP_AEAD_TLS1_AAD_LEN)
3603             return 0;
3604         memcpy(EVP_CIPHER_CTX_buf_noconst(c), ptr, arg);
3605         cctx->tls_aad_len = arg;
3606         {
3607             uint16_t len =
3608                 EVP_CIPHER_CTX_buf_noconst(c)[arg - 2] << 8
3609                 | EVP_CIPHER_CTX_buf_noconst(c)[arg - 1];
3610             /* Correct length for explicit IV */
3611             if (len < EVP_CCM_TLS_EXPLICIT_IV_LEN)
3612                 return 0;
3613             len -= EVP_CCM_TLS_EXPLICIT_IV_LEN;
3614             /* If decrypting correct for tag too */
3615             if (!EVP_CIPHER_CTX_encrypting(c)) {
3616                 if (len < cctx->M)
3617                     return 0;
3618                 len -= cctx->M;
3619             }
3620             EVP_CIPHER_CTX_buf_noconst(c)[arg - 2] = len >> 8;
3621             EVP_CIPHER_CTX_buf_noconst(c)[arg - 1] = len & 0xff;
3622         }
3623         /* Extra padding: tag appended to record */
3624         return cctx->M;
3625
3626     case EVP_CTRL_CCM_SET_IV_FIXED:
3627         /* Sanity check length */
3628         if (arg != EVP_CCM_TLS_FIXED_IV_LEN)
3629             return 0;
3630         /* Just copy to first part of IV */
3631         memcpy(EVP_CIPHER_CTX_iv_noconst(c), ptr, arg);
3632         return 1;
3633
3634     case EVP_CTRL_AEAD_SET_IVLEN:
3635         arg = 15 - arg;
3636         /* fall thru */
3637     case EVP_CTRL_CCM_SET_L:
3638         if (arg < 2 || arg > 8)
3639             return 0;
3640         cctx->L = arg;
3641         return 1;
3642
3643     case EVP_CTRL_AEAD_SET_TAG:
3644         if ((arg & 1) || arg < 4 || arg > 16)
3645             return 0;
3646         if (EVP_CIPHER_CTX_encrypting(c) && ptr)
3647             return 0;
3648         if (ptr) {
3649             cctx->tag_set = 1;
3650             memcpy(EVP_CIPHER_CTX_buf_noconst(c), ptr, arg);
3651         }
3652         cctx->M = arg;
3653         return 1;
3654
3655     case EVP_CTRL_AEAD_GET_TAG:
3656         if (!EVP_CIPHER_CTX_encrypting(c) || !cctx->tag_set)
3657             return 0;
3658         if (!CRYPTO_ccm128_tag(&cctx->ccm, ptr, (size_t)arg))
3659             return 0;
3660         cctx->tag_set = 0;
3661         cctx->iv_set = 0;
3662         cctx->len_set = 0;
3663         return 1;
3664
3665     case EVP_CTRL_COPY:
3666         {
3667             EVP_CIPHER_CTX *out = ptr;
3668             EVP_AES_CCM_CTX *cctx_out = EVP_C_DATA(EVP_AES_CCM_CTX,out);
3669             if (cctx->ccm.key) {
3670                 if (cctx->ccm.key != &cctx->ks)
3671                     return 0;
3672                 cctx_out->ccm.key = &cctx_out->ks;
3673             }
3674             return 1;
3675         }
3676
3677     default:
3678         return -1;
3679
3680     }
3681 }
3682
3683 static int aes_ccm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
3684                             const unsigned char *iv, int enc)
3685 {
3686     EVP_AES_CCM_CTX *cctx = EVP_C_DATA(EVP_AES_CCM_CTX,ctx);
3687     if (!iv && !key)
3688         return 1;
3689     if (key)
3690         do {
3691 #ifdef HWAES_CAPABLE
3692             if (HWAES_CAPABLE) {
3693                 HWAES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
3694                                       &cctx->ks.ks);
3695
3696                 CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
3697                                    &cctx->ks, (block128_f) HWAES_encrypt);
3698                 cctx->str = NULL;
3699                 cctx->key_set = 1;
3700                 break;
3701             } else
3702 #endif
3703 #ifdef VPAES_CAPABLE
3704             if (VPAES_CAPABLE) {
3705                 vpaes_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
3706                                       &cctx->ks.ks);
3707                 CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
3708                                    &cctx->ks, (block128_f) vpaes_encrypt);
3709                 cctx->str = NULL;
3710                 cctx->key_set = 1;
3711                 break;
3712             }
3713 #endif
3714             AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
3715                                 &cctx->ks.ks);
3716             CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
3717                                &cctx->ks, (block128_f) AES_encrypt);
3718             cctx->str = NULL;
3719             cctx->key_set = 1;
3720         } while (0);
3721     if (iv) {
3722         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, 15 - cctx->L);
3723         cctx->iv_set = 1;
3724     }
3725     return 1;
3726 }
3727
3728 static int aes_ccm_tls_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
3729                               const unsigned char *in, size_t len)
3730 {
3731     EVP_AES_CCM_CTX *cctx = EVP_C_DATA(EVP_AES_CCM_CTX,ctx);
3732     CCM128_CONTEXT *ccm = &cctx->ccm;
3733     /* Encrypt/decrypt must be performed in place */
3734     if (out != in || len < (EVP_CCM_TLS_EXPLICIT_IV_LEN + (size_t)cctx->M))
3735         return -1;
3736     /* If encrypting set explicit IV from sequence number (start of AAD) */
3737     if (EVP_CIPHER_CTX_encrypting(ctx))
3738         memcpy(out, EVP_CIPHER_CTX_buf_noconst(ctx),
3739                EVP_CCM_TLS_EXPLICIT_IV_LEN);
3740     /* Get rest of IV from explicit IV */
3741     memcpy(EVP_CIPHER_CTX_iv_noconst(ctx) + EVP_CCM_TLS_FIXED_IV_LEN, in,
3742            EVP_CCM_TLS_EXPLICIT_IV_LEN);
3743     /* Correct length value */
3744     len -= EVP_CCM_TLS_EXPLICIT_IV_LEN + cctx->M;
3745     if (CRYPTO_ccm128_setiv(ccm, EVP_CIPHER_CTX_iv_noconst(ctx), 15 - cctx->L,
3746                             len))
3747             return -1;
3748     /* Use saved AAD */
3749     CRYPTO_ccm128_aad(ccm, EVP_CIPHER_CTX_buf_noconst(ctx), cctx->tls_aad_len);
3750     /* Fix buffer to point to payload */
3751     in += EVP_CCM_TLS_EXPLICIT_IV_LEN;
3752     out += EVP_CCM_TLS_EXPLICIT_IV_LEN;
3753     if (EVP_CIPHER_CTX_encrypting(ctx)) {
3754         if (cctx->str ? CRYPTO_ccm128_encrypt_ccm64(ccm, in, out, len,
3755                                                     cctx->str) :
3756             CRYPTO_ccm128_encrypt(ccm, in, out, len))
3757             return -1;
3758         if (!CRYPTO_ccm128_tag(ccm, out + len, cctx->M))
3759             return -1;
3760         return len + EVP_CCM_TLS_EXPLICIT_IV_LEN + cctx->M;
3761     } else {
3762         if (cctx->str ? !CRYPTO_ccm128_decrypt_ccm64(ccm, in, out, len,
3763                                                      cctx->str) :
3764             !CRYPTO_ccm128_decrypt(ccm, in, out, len)) {
3765             unsigned char tag[16];
3766             if (CRYPTO_ccm128_tag(ccm, tag, cctx->M)) {
3767                 if (!CRYPTO_memcmp(tag, in + len, cctx->M))
3768                     return len;
3769             }
3770         }
3771         OPENSSL_cleanse(out, len);
3772         return -1;
3773     }
3774 }
3775
3776 static int aes_ccm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
3777                           const unsigned char *in, size_t len)
3778 {
3779     EVP_AES_CCM_CTX *cctx = EVP_C_DATA(EVP_AES_CCM_CTX,ctx);
3780     CCM128_CONTEXT *ccm = &cctx->ccm;
3781     /* If not set up, return error */
3782     if (!cctx->key_set)
3783         return -1;
3784
3785     if (cctx->tls_aad_len >= 0)
3786         return aes_ccm_tls_cipher(ctx, out, in, len);
3787
3788     /* EVP_*Final() doesn't return any data */
3789     if (in == NULL && out != NULL)
3790         return 0;
3791
3792     if (!cctx->iv_set)
3793         return -1;
3794
3795     if (!EVP_CIPHER_CTX_encrypting(ctx) && !cctx->tag_set)
3796         return -1;
3797     if (!out) {
3798         if (!in) {
3799             if (CRYPTO_ccm128_setiv(ccm, EVP_CIPHER_CTX_iv_noconst(ctx),
3800                                     15 - cctx->L, len))
3801                 return -1;
3802             cctx->len_set = 1;
3803             return len;
3804         }
3805         /* If have AAD need message length */
3806         if (!cctx->len_set && len)
3807             return -1;
3808         CRYPTO_ccm128_aad(ccm, in, len);
3809         return len;
3810     }
3811     /* If not set length yet do it */
3812     if (!cctx->len_set) {
3813         if (CRYPTO_ccm128_setiv(ccm, EVP_CIPHER_CTX_iv_noconst(ctx),
3814                                 15 - cctx->L, len))
3815             return -1;
3816         cctx->len_set = 1;
3817     }
3818     if (EVP_CIPHER_CTX_encrypting(ctx)) {
3819         if (cctx->str ? CRYPTO_ccm128_encrypt_ccm64(ccm, in, out, len,
3820                                                     cctx->str) :
3821             CRYPTO_ccm128_encrypt(ccm, in, out, len))
3822             return -1;
3823         cctx->tag_set = 1;
3824         return len;
3825     } else {
3826         int rv = -1;
3827         if (cctx->str ? !CRYPTO_ccm128_decrypt_ccm64(ccm, in, out, len,
3828                                                      cctx->str) :
3829             !CRYPTO_ccm128_decrypt(ccm, in, out, len)) {
3830             unsigned char tag[16];
3831             if (CRYPTO_ccm128_tag(ccm, tag, cctx->M)) {
3832                 if (!CRYPTO_memcmp(tag, EVP_CIPHER_CTX_buf_noconst(ctx),
3833                                    cctx->M))
3834                     rv = len;
3835             }
3836         }
3837         if (rv == -1)
3838             OPENSSL_cleanse(out, len);
3839         cctx->iv_set = 0;
3840         cctx->tag_set = 0;
3841         cctx->len_set = 0;
3842         return rv;
3843     }
3844 }
3845
3846 #define aes_ccm_cleanup NULL
3847
3848 BLOCK_CIPHER_custom(NID_aes, 128, 1, 12, ccm, CCM,
3849                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
3850     BLOCK_CIPHER_custom(NID_aes, 192, 1, 12, ccm, CCM,
3851                         EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
3852     BLOCK_CIPHER_custom(NID_aes, 256, 1, 12, ccm, CCM,
3853                         EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
3854
3855 typedef struct {
3856     union {
3857         OSSL_UNION_ALIGN;
3858         AES_KEY ks;
3859     } ks;
3860     /* Indicates if IV has been set */
3861     unsigned char *iv;
3862 } EVP_AES_WRAP_CTX;
3863
3864 static int aes_wrap_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
3865                              const unsigned char *iv, int enc)
3866 {
3867     EVP_AES_WRAP_CTX *wctx = EVP_C_DATA(EVP_AES_WRAP_CTX,ctx);
3868     if (!iv && !key)
3869         return 1;
3870     if (key) {
3871         if (EVP_CIPHER_CTX_encrypting(ctx))
3872             AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
3873                                 &wctx->ks.ks);
3874         else
3875             AES_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
3876                                 &wctx->ks.ks);
3877         if (!iv)
3878             wctx->iv = NULL;
3879     }
3880     if (iv) {
3881         memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, EVP_CIPHER_CTX_iv_length(ctx));
3882         wctx->iv = EVP_CIPHER_CTX_iv_noconst(ctx);
3883     }
3884     return 1;
3885 }
3886
3887 static int aes_wrap_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
3888                            const unsigned char *in, size_t inlen)
3889 {
3890     EVP_AES_WRAP_CTX *wctx = EVP_C_DATA(EVP_AES_WRAP_CTX,ctx);
3891     size_t rv;
3892     /* AES wrap with padding has IV length of 4, without padding 8 */
3893     int pad = EVP_CIPHER_CTX_iv_length(ctx) == 4;
3894     /* No final operation so always return zero length */
3895     if (!in)
3896         return 0;
3897     /* Input length must always be non-zero */
3898     if (!inlen)
3899         return -1;
3900     /* If decrypting need at least 16 bytes and multiple of 8 */
3901     if (!EVP_CIPHER_CTX_encrypting(ctx) && (inlen < 16 || inlen & 0x7))
3902         return -1;
3903     /* If not padding input must be multiple of 8 */
3904     if (!pad && inlen & 0x7)
3905         return -1;
3906     if (is_partially_overlapping(out, in, inlen)) {
3907         EVPerr(EVP_F_AES_WRAP_CIPHER, EVP_R_PARTIALLY_OVERLAPPING);
3908         return 0;
3909     }
3910     if (!out) {
3911         if (EVP_CIPHER_CTX_encrypting(ctx)) {
3912             /* If padding round up to multiple of 8 */
3913             if (pad)
3914                 inlen = (inlen + 7) / 8 * 8;
3915             /* 8 byte prefix */
3916             return inlen + 8;
3917         } else {
3918             /*
3919              * If not padding output will be exactly 8 bytes smaller than
3920              * input. If padding it will be at least 8 bytes smaller but we
3921              * don't know how much.
3922              */
3923             return inlen - 8;
3924         }
3925     }
3926     if (pad) {
3927         if (EVP_CIPHER_CTX_encrypting(ctx))
3928             rv = CRYPTO_128_wrap_pad(&wctx->ks.ks, wctx->iv,
3929                                      out, in, inlen,
3930                                      (block128_f) AES_encrypt);
3931         else
3932             rv = CRYPTO_128_unwrap_pad(&wctx->ks.ks, wctx->iv,
3933                                        out, in, inlen,
3934                                        (block128_f) AES_decrypt);
3935     } else {
3936         if (EVP_CIPHER_CTX_encrypting(ctx))
3937             rv = CRYPTO_128_wrap(&wctx->ks.ks, wctx->iv,
3938                                  out, in, inlen, (block128_f) AES_encrypt);
3939         else
3940             rv = CRYPTO_128_unwrap(&wctx->ks.ks, wctx->iv,
3941                                    out, in, inlen, (block128_f) AES_decrypt);
3942     }
3943     return rv ? (int)rv : -1;
3944 }
3945
3946 #define WRAP_FLAGS      (EVP_CIPH_WRAP_MODE \
3947                 | EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER \
3948                 | EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_FLAG_DEFAULT_ASN1)
3949
3950 static const EVP_CIPHER aes_128_wrap = {
3951     NID_id_aes128_wrap,
3952     8, 16, 8, WRAP_FLAGS,
3953     aes_wrap_init_key, aes_wrap_cipher,
3954     NULL,
3955     sizeof(EVP_AES_WRAP_CTX),
3956     NULL, NULL, NULL, NULL
3957 };
3958
3959 const EVP_CIPHER *EVP_aes_128_wrap(void)
3960 {
3961     return &aes_128_wrap;
3962 }
3963
3964 static const EVP_CIPHER aes_192_wrap = {
3965     NID_id_aes192_wrap,
3966     8, 24, 8, WRAP_FLAGS,
3967     aes_wrap_init_key, aes_wrap_cipher,
3968     NULL,
3969     sizeof(EVP_AES_WRAP_CTX),
3970     NULL, NULL, NULL, NULL
3971 };
3972
3973 const EVP_CIPHER *EVP_aes_192_wrap(void)
3974 {
3975     return &aes_192_wrap;
3976 }
3977
3978 static const EVP_CIPHER aes_256_wrap = {
3979     NID_id_aes256_wrap,
3980     8, 32, 8, WRAP_FLAGS,
3981     aes_wrap_init_key, aes_wrap_cipher,
3982     NULL,
3983     sizeof(EVP_AES_WRAP_CTX),
3984     NULL, NULL, NULL, NULL
3985 };
3986
3987 const EVP_CIPHER *EVP_aes_256_wrap(void)
3988 {
3989     return &aes_256_wrap;
3990 }
3991
3992 static const EVP_CIPHER aes_128_wrap_pad = {
3993     NID_id_aes128_wrap_pad,
3994     8, 16, 4, WRAP_FLAGS,
3995     aes_wrap_init_key, aes_wrap_cipher,
3996     NULL,
3997     sizeof(EVP_AES_WRAP_CTX),
3998     NULL, NULL, NULL, NULL
3999 };
4000
4001 const EVP_CIPHER *EVP_aes_128_wrap_pad(void)
4002 {
4003     return &aes_128_wrap_pad;
4004 }
4005
4006 static const EVP_CIPHER aes_192_wrap_pad = {
4007     NID_id_aes192_wrap_pad,
4008     8, 24, 4, WRAP_FLAGS,
4009     aes_wrap_init_key, aes_wrap_cipher,
4010     NULL,
4011     sizeof(EVP_AES_WRAP_CTX),
4012     NULL, NULL, NULL, NULL
4013 };
4014
4015 const EVP_CIPHER *EVP_aes_192_wrap_pad(void)
4016 {
4017     return &aes_192_wrap_pad;
4018 }
4019
4020 static const EVP_CIPHER aes_256_wrap_pad = {
4021     NID_id_aes256_wrap_pad,
4022     8, 32, 4, WRAP_FLAGS,
4023     aes_wrap_init_key, aes_wrap_cipher,
4024     NULL,
4025     sizeof(EVP_AES_WRAP_CTX),
4026     NULL, NULL, NULL, NULL
4027 };
4028
4029 const EVP_CIPHER *EVP_aes_256_wrap_pad(void)
4030 {
4031     return &aes_256_wrap_pad;
4032 }
4033
4034 #ifndef OPENSSL_NO_OCB
4035 static int aes_ocb_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
4036 {
4037     EVP_AES_OCB_CTX *octx = EVP_C_DATA(EVP_AES_OCB_CTX,c);
4038     EVP_CIPHER_CTX *newc;
4039     EVP_AES_OCB_CTX *new_octx;
4040
4041     switch (type) {
4042     case EVP_CTRL_INIT:
4043         octx->key_set = 0;
4044         octx->iv_set = 0;
4045         octx->ivlen = EVP_CIPHER_CTX_iv_length(c);
4046         octx->iv = EVP_CIPHER_CTX_iv_noconst(c);
4047         octx->taglen = 16;
4048         octx->data_buf_len = 0;
4049         octx->aad_buf_len = 0;
4050         return 1;
4051
4052     case EVP_CTRL_AEAD_SET_IVLEN:
4053         /* IV len must be 1 to 15 */
4054         if (arg <= 0 || arg > 15)
4055             return 0;
4056
4057         octx->ivlen = arg;
4058         return 1;
4059
4060     case EVP_CTRL_AEAD_SET_TAG:
4061         if (!ptr) {
4062             /* Tag len must be 0 to 16 */
4063             if (arg < 0 || arg > 16)
4064                 return 0;
4065
4066             octx->taglen = arg;
4067             return 1;
4068         }
4069         if (arg != octx->taglen || EVP_CIPHER_CTX_encrypting(c))
4070             return 0;
4071         memcpy(octx->tag, ptr, arg);
4072         return 1;
4073
4074     case EVP_CTRL_AEAD_GET_TAG:
4075         if (arg != octx->taglen || !EVP_CIPHER_CTX_encrypting(c))
4076             return 0;
4077
4078         memcpy(ptr, octx->tag, arg);
4079         return 1;
4080
4081     case EVP_CTRL_COPY:
4082         newc = (EVP_CIPHER_CTX *)ptr;
4083         new_octx = EVP_C_DATA(EVP_AES_OCB_CTX,newc);
4084         return CRYPTO_ocb128_copy_ctx(&new_octx->ocb, &octx->ocb,
4085                                       &new_octx->ksenc.ks,
4086                                       &new_octx->ksdec.ks);
4087
4088     default:
4089         return -1;
4090
4091     }
4092 }
4093
4094 # ifdef HWAES_CAPABLE
4095 #  ifdef HWAES_ocb_encrypt
4096 void HWAES_ocb_encrypt(const unsigned char *in, unsigned char *out,
4097                        size_t blocks, const void *key,
4098                        size_t start_block_num,
4099                        unsigned char offset_i[16],
4100                        const unsigned char L_[][16],
4101                        unsigned char checksum[16]);
4102 #  else
4103 #    define HWAES_ocb_encrypt ((ocb128_f)NULL)
4104 #  endif
4105 #  ifdef HWAES_ocb_decrypt
4106 void HWAES_ocb_decrypt(const unsigned char *in, unsigned char *out,
4107                        size_t blocks, const void *key,
4108                        size_t start_block_num,
4109                        unsigned char offset_i[16],
4110                        const unsigned char L_[][16],
4111                        unsigned char checksum[16]);
4112 #  else
4113 #    define HWAES_ocb_decrypt ((ocb128_f)NULL)
4114 #  endif
4115 # endif
4116
4117 static int aes_ocb_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
4118                             const unsigned char *iv, int enc)
4119 {
4120     EVP_AES_OCB_CTX *octx = EVP_C_DATA(EVP_AES_OCB_CTX,ctx);
4121     if (!iv && !key)
4122         return 1;
4123     if (key) {
4124         do {
4125             /*
4126              * We set both the encrypt and decrypt key here because decrypt
4127              * needs both. We could possibly optimise to remove setting the
4128              * decrypt for an encryption operation.
4129              */
4130 # ifdef HWAES_CAPABLE
4131             if (HWAES_CAPABLE) {
4132                 HWAES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
4133                                       &octx->ksenc.ks);
4134                 HWAES_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
4135                                       &octx->ksdec.ks);
4136                 if (!CRYPTO_ocb128_init(&octx->ocb,
4137                                         &octx->ksenc.ks, &octx->ksdec.ks,
4138                                         (block128_f) HWAES_encrypt,
4139                                         (block128_f) HWAES_decrypt,
4140                                         enc ? HWAES_ocb_encrypt
4141                                             : HWAES_ocb_decrypt))
4142                     return 0;
4143                 break;
4144             }
4145 # endif
4146 # ifdef VPAES_CAPABLE
4147             if (VPAES_CAPABLE) {
4148                 vpaes_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
4149                                       &octx->ksenc.ks);
4150                 vpaes_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
4151                                       &octx->ksdec.ks);
4152                 if (!CRYPTO_ocb128_init(&octx->ocb,
4153                                         &octx->ksenc.ks, &octx->ksdec.ks,
4154                                         (block128_f) vpaes_encrypt,
4155                                         (block128_f) vpaes_decrypt,
4156                                         NULL))
4157                     return 0;
4158                 break;
4159             }
4160 # endif
4161             AES_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
4162                                 &octx->ksenc.ks);
4163             AES_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
4164                                 &octx->ksdec.ks);
4165             if (!CRYPTO_ocb128_init(&octx->ocb,
4166                                     &octx->ksenc.ks, &octx->ksdec.ks,
4167                                     (block128_f) AES_encrypt,
4168                                     (block128_f) AES_decrypt,
4169                                     NULL))
4170                 return 0;
4171         }
4172         while (0);
4173
4174         /*
4175          * If we have an iv we can set it directly, otherwise use saved IV.
4176          */
4177         if (iv == NULL && octx->iv_set)
4178             iv = octx->iv;
4179         if (iv) {
4180             if (CRYPTO_ocb128_setiv(&octx->ocb, iv, octx->ivlen, octx->taglen)
4181                 != 1)
4182                 return 0;
4183             octx->iv_set = 1;
4184         }
4185         octx->key_set = 1;
4186     } else {
4187         /* If key set use IV, otherwise copy */
4188         if (octx->key_set)
4189             CRYPTO_ocb128_setiv(&octx->ocb, iv, octx->ivlen, octx->taglen);
4190         else
4191             memcpy(octx->iv, iv, octx->ivlen);
4192         octx->iv_set = 1;
4193     }
4194     return 1;
4195 }
4196
4197 static int aes_ocb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
4198                           const unsigned char *in, size_t len)
4199 {
4200     unsigned char *buf;
4201     int *buf_len;
4202     int written_len = 0;
4203     size_t trailing_len;
4204     EVP_AES_OCB_CTX *octx = EVP_C_DATA(EVP_AES_OCB_CTX,ctx);
4205
4206     /* If IV or Key not set then return error */
4207     if (!octx->iv_set)
4208         return -1;
4209
4210     if (!octx->key_set)
4211         return -1;
4212
4213     if (in != NULL) {
4214         /*
4215          * Need to ensure we are only passing full blocks to low level OCB
4216          * routines. We do it here rather than in EVP_EncryptUpdate/
4217          * EVP_DecryptUpdate because we need to pass full blocks of AAD too
4218          * and those routines don't support that
4219          */
4220
4221         /* Are we dealing with AAD or normal data here? */
4222         if (out == NULL) {
4223             buf = octx->aad_buf;
4224             buf_len = &(octx->aad_buf_len);
4225         } else {
4226             buf = octx->data_buf;
4227             buf_len = &(octx->data_buf_len);
4228
4229             if (is_partially_overlapping(out + *buf_len, in, len)) {
4230                 EVPerr(EVP_F_AES_OCB_CIPHER, EVP_R_PARTIALLY_OVERLAPPING);
4231                 return 0;
4232             }
4233         }
4234
4235         /*
4236          * If we've got a partially filled buffer from a previous call then
4237          * use that data first
4238          */
4239         if (*buf_len > 0) {
4240             unsigned int remaining;
4241
4242             remaining = AES_BLOCK_SIZE - (*buf_len);
4243             if (remaining > len) {
4244                 memcpy(buf + (*buf_len), in, len);
4245                 *(buf_len) += len;
4246                 return 0;
4247             }
4248             memcpy(buf + (*buf_len), in, remaining);
4249
4250             /*
4251              * If we get here we've filled the buffer, so process it
4252              */
4253             len -= remaining;
4254             in += remaining;
4255             if (out == NULL) {
4256                 if (!CRYPTO_ocb128_aad(&octx->ocb, buf, AES_BLOCK_SIZE))
4257                     return -1;
4258             } else if (EVP_CIPHER_CTX_encrypting(ctx)) {
4259                 if (!CRYPTO_ocb128_encrypt(&octx->ocb, buf, out,
4260                                            AES_BLOCK_SIZE))
4261                     return -1;
4262             } else {
4263                 if (!CRYPTO_ocb128_decrypt(&octx->ocb, buf, out,
4264                                            AES_BLOCK_SIZE))
4265                     return -1;
4266             }
4267             written_len = AES_BLOCK_SIZE;
4268             *buf_len = 0;
4269             if (out != NULL)
4270                 out += AES_BLOCK_SIZE;
4271         }
4272
4273         /* Do we have a partial block to handle at the end? */
4274         trailing_len = len % AES_BLOCK_SIZE;
4275
4276         /*
4277          * If we've got some full blocks to handle, then process these first
4278          */
4279         if (len != trailing_len) {
4280             if (out == NULL) {
4281                 if (!CRYPTO_ocb128_aad(&octx->ocb, in, len - trailing_len))
4282                     return -1;
4283             } else if (EVP_CIPHER_CTX_encrypting(ctx)) {
4284                 if (!CRYPTO_ocb128_encrypt
4285                     (&octx->ocb, in, out, len - trailing_len))
4286                     return -1;
4287             } else {
4288                 if (!CRYPTO_ocb128_decrypt
4289                     (&octx->ocb, in, out, len - trailing_len))
4290                     return -1;
4291             }
4292             written_len += len - trailing_len;
4293             in += len - trailing_len;
4294         }
4295
4296         /* Handle any trailing partial block */
4297         if (trailing_len > 0) {
4298             memcpy(buf, in, trailing_len);
4299             *buf_len = trailing_len;
4300         }
4301
4302         return written_len;
4303     } else {
4304         /*
4305          * First of all empty the buffer of any partial block that we might
4306          * have been provided - both for data and AAD
4307          */
4308         if (octx->data_buf_len > 0) {
4309             if (EVP_CIPHER_CTX_encrypting(ctx)) {
4310                 if (!CRYPTO_ocb128_encrypt(&octx->ocb, octx->data_buf, out,
4311                                            octx->data_buf_len))
4312                     return -1;
4313             } else {
4314                 if (!CRYPTO_ocb128_decrypt(&octx->ocb, octx->data_buf, out,
4315                                            octx->data_buf_len))
4316                     return -1;
4317             }
4318             written_len = octx->data_buf_len;
4319             octx->data_buf_len = 0;
4320         }
4321         if (octx->aad_buf_len > 0) {
4322             if (!CRYPTO_ocb128_aad
4323                 (&octx->ocb, octx->aad_buf, octx->aad_buf_len))
4324                 return -1;
4325             octx->aad_buf_len = 0;
4326         }
4327         /* If decrypting then verify */
4328         if (!EVP_CIPHER_CTX_encrypting(ctx)) {
4329             if (octx->taglen < 0)
4330                 return -1;
4331             if (CRYPTO_ocb128_finish(&octx->ocb,
4332                                      octx->tag, octx->taglen) != 0)
4333                 return -1;
4334             octx->iv_set = 0;
4335             return written_len;
4336         }
4337         /* If encrypting then just get the tag */
4338         if (CRYPTO_ocb128_tag(&octx->ocb, octx->tag, 16) != 1)
4339             return -1;
4340         /* Don't reuse the IV */
4341         octx->iv_set = 0;
4342         return written_len;
4343     }
4344 }
4345
4346 static int aes_ocb_cleanup(EVP_CIPHER_CTX *c)
4347 {
4348     EVP_AES_OCB_CTX *octx = EVP_C_DATA(EVP_AES_OCB_CTX,c);
4349     CRYPTO_ocb128_cleanup(&octx->ocb);
4350     return 1;
4351 }
4352
4353 BLOCK_CIPHER_custom(NID_aes, 128, 16, 12, ocb, OCB,
4354                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
4355 BLOCK_CIPHER_custom(NID_aes, 192, 16, 12, ocb, OCB,
4356                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
4357 BLOCK_CIPHER_custom(NID_aes, 256, 16, 12, ocb, OCB,
4358                     EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS)
4359 #endif                         /* OPENSSL_NO_OCB */
4360
4361 /* AES-SIV mode */
4362 #ifndef OPENSSL_NO_SIV
4363
4364 typedef SIV128_CONTEXT EVP_AES_SIV_CTX;
4365
4366 #define aesni_siv_init_key aes_siv_init_key
4367 static int aes_siv_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
4368                             const unsigned char *iv, int enc)
4369 {
4370     const EVP_CIPHER *ctr;
4371     const EVP_CIPHER *cbc;
4372     SIV128_CONTEXT *sctx = EVP_C_DATA(SIV128_CONTEXT, ctx);
4373     int klen = EVP_CIPHER_CTX_key_length(ctx) / 2;
4374
4375     if (key == NULL)
4376         return 1;
4377
4378     switch (klen) {
4379     case 16:
4380         cbc = EVP_aes_128_cbc();
4381         ctr = EVP_aes_128_ctr();
4382         break;
4383     case 24:
4384         cbc = EVP_aes_192_cbc();
4385         ctr = EVP_aes_192_ctr();
4386         break;
4387     case 32:
4388         cbc = EVP_aes_256_cbc();
4389         ctr = EVP_aes_256_ctr();
4390         break;
4391     default:
4392         return 0;
4393     }
4394
4395     /* klen is the length of the underlying cipher, not the input key,
4396        which should be twice as long */
4397     return CRYPTO_siv128_init(sctx, key, klen, cbc, ctr);
4398 }
4399
4400 #define aesni_siv_cipher aes_siv_cipher
4401 static int aes_siv_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
4402                           const unsigned char *in, size_t len)
4403 {
4404     SIV128_CONTEXT *sctx = EVP_C_DATA(SIV128_CONTEXT, ctx);
4405
4406     /* EncryptFinal or DecryptFinal */
4407     if (in == NULL)
4408         return CRYPTO_siv128_finish(sctx);
4409
4410     /* Deal with associated data */
4411     if (out == NULL)
4412         return CRYPTO_siv128_aad(sctx, in, len);
4413
4414     if (EVP_CIPHER_CTX_encrypting(ctx))
4415         return CRYPTO_siv128_encrypt(sctx, in, out, len);
4416
4417     return CRYPTO_siv128_decrypt(sctx, in, out, len);
4418 }
4419
4420 #define aesni_siv_cleanup aes_siv_cleanup
4421 static int aes_siv_cleanup(EVP_CIPHER_CTX *c)
4422 {
4423     SIV128_CONTEXT *sctx = EVP_C_DATA(SIV128_CONTEXT, c);
4424
4425     return CRYPTO_siv128_cleanup(sctx);
4426 }
4427
4428
4429 #define aesni_siv_ctrl aes_siv_ctrl
4430 static int aes_siv_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
4431 {
4432     SIV128_CONTEXT *sctx = EVP_C_DATA(SIV128_CONTEXT, c);
4433     SIV128_CONTEXT *sctx_out;
4434
4435     switch (type) {
4436     case EVP_CTRL_INIT:
4437         return CRYPTO_siv128_cleanup(sctx);
4438
4439     case EVP_CTRL_SET_SPEED:
4440         return CRYPTO_siv128_speed(sctx, arg);
4441
4442     case EVP_CTRL_AEAD_SET_TAG:
4443         if (!EVP_CIPHER_CTX_encrypting(c))
4444             return CRYPTO_siv128_set_tag(sctx, ptr, arg);
4445         return 1;
4446
4447     case EVP_CTRL_AEAD_GET_TAG:
4448         if (!EVP_CIPHER_CTX_encrypting(c))
4449             return 0;
4450         return CRYPTO_siv128_get_tag(sctx, ptr, arg);
4451
4452     case EVP_CTRL_COPY:
4453         sctx_out = EVP_C_DATA(SIV128_CONTEXT, (EVP_CIPHER_CTX*)ptr);
4454         return CRYPTO_siv128_copy_ctx(sctx_out, sctx);
4455
4456     default:
4457         return -1;
4458
4459     }
4460 }
4461
4462 #define SIV_FLAGS    (EVP_CIPH_FLAG_AEAD_CIPHER | EVP_CIPH_FLAG_DEFAULT_ASN1 \
4463                       | EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER \
4464                       | EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CUSTOM_COPY \
4465                       | EVP_CIPH_CTRL_INIT)
4466
4467 BLOCK_CIPHER_custom(NID_aes, 128, 1, 0, siv, SIV, SIV_FLAGS)
4468 BLOCK_CIPHER_custom(NID_aes, 192, 1, 0, siv, SIV, SIV_FLAGS)
4469 BLOCK_CIPHER_custom(NID_aes, 256, 1, 0, siv, SIV, SIV_FLAGS)
4470 #endif