providers/common/ciphers/aes_basic.c

   1 /*
   2  * Copyright 2001-2018 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 <openssl/rand.h>
  19 #include <openssl/cmac.h>
  20 #include "ciphers_locl.h"
  21
  22 #define MAXBITCHUNK     ((size_t)1 << (sizeof(size_t) * 8 - 4))
  23
  24 #ifdef VPAES_ASM
  25 int vpaes_set_encrypt_key(const unsigned char *userKey, int bits,
  26                           AES_KEY *key);
  27 int vpaes_set_decrypt_key(const unsigned char *userKey, int bits,
  28                           AES_KEY *key);
  29
  30 void vpaes_encrypt(const unsigned char *in, unsigned char *out,
  31                    const AES_KEY *key);
  32 void vpaes_decrypt(const unsigned char *in, unsigned char *out,
  33                    const AES_KEY *key);
  34
  35 void vpaes_cbc_encrypt(const unsigned char *in,
  36                        unsigned char *out,
  37                        size_t length,
  38                        const AES_KEY *key, unsigned char *ivec, int enc);
  39 #endif
  40 #ifdef BSAES_ASM
  41 void bsaes_cbc_encrypt(const unsigned char *in, unsigned char *out,
  42                        size_t length, const AES_KEY *key,
  43                        unsigned char ivec[16], int enc);
  44 void bsaes_ctr32_encrypt_blocks(const unsigned char *in, unsigned char *out,
  45                                 size_t len, const AES_KEY *key,
  46                                 const unsigned char ivec[16]);
  47 #endif
  48 #ifdef AES_CTR_ASM
  49 void AES_ctr32_encrypt(const unsigned char *in, unsigned char *out,
  50                        size_t blocks, const AES_KEY *key,
  51                        const unsigned char ivec[AES_BLOCK_SIZE]);
  52 #endif
  53
  54
  55 #if defined(OPENSSL_CPUID_OBJ) && (defined(__powerpc__) || defined(__ppc__) || defined(_ARCH_PPC))
  56 # include "ppc_arch.h"
  57 # ifdef VPAES_ASM
  58 #  define VPAES_CAPABLE (OPENSSL_ppccap_P & PPC_ALTIVEC)
  59 # endif
  60 # define HWAES_CAPABLE  (OPENSSL_ppccap_P & PPC_CRYPTO207)
  61 # define HWAES_set_encrypt_key aes_p8_set_encrypt_key
  62 # define HWAES_set_decrypt_key aes_p8_set_decrypt_key
  63 # define HWAES_encrypt aes_p8_encrypt
  64 # define HWAES_decrypt aes_p8_decrypt
  65 # define HWAES_cbc_encrypt aes_p8_cbc_encrypt
  66 # define HWAES_ctr32_encrypt_blocks aes_p8_ctr32_encrypt_blocks
  67 # define HWAES_xts_encrypt aes_p8_xts_encrypt
  68 # define HWAES_xts_decrypt aes_p8_xts_decrypt
  69 #endif
  70
  71 #if     defined(AES_ASM) && !defined(I386_ONLY) &&      (  \
  72         ((defined(__i386)       || defined(__i386__)    || \
  73           defined(_M_IX86)) && defined(OPENSSL_IA32_SSE2))|| \
  74         defined(__x86_64)       || defined(__x86_64__)  || \
  75         defined(_M_AMD64)       || defined(_M_X64)      )
  76
  77 extern unsigned int OPENSSL_ia32cap_P[];
  78
  79 # ifdef VPAES_ASM
  80 #  define VPAES_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(41-32)))
  81 # endif
  82 # ifdef BSAES_ASM
  83 #  define BSAES_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(41-32)))
  84 # endif
  85 /*
  86  * AES-NI section
  87  */
  88 # define AESNI_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(57-32)))
  89
  90 int aesni_set_encrypt_key(const unsigned char *userKey, int bits,
  91                           AES_KEY *key);
  92 int aesni_set_decrypt_key(const unsigned char *userKey, int bits,
  93                           AES_KEY *key);
  94
  95 void aesni_encrypt(const unsigned char *in, unsigned char *out,
  96                    const AES_KEY *key);
  97 void aesni_decrypt(const unsigned char *in, unsigned char *out,
  98                    const AES_KEY *key);
  99
 100 void aesni_ecb_encrypt(const unsigned char *in,
 101                        unsigned char *out,
 102                        size_t length, const AES_KEY *key, int enc);
 103 void aesni_cbc_encrypt(const unsigned char *in,
 104                        unsigned char *out,
 105                        size_t length,
 106                        const AES_KEY *key, unsigned char *ivec, int enc);
 107
 108 void aesni_ctr32_encrypt_blocks(const unsigned char *in,
 109                                 unsigned char *out,
 110                                 size_t blocks,
 111                                 const void *key, const unsigned char *ivec);
 112
 113 static int aesni_init_key(PROV_AES_KEY *dat, const unsigned char *key,
 114                           size_t keylen)
 115 {
 116     int ret;
 117
 118     if ((dat->mode == EVP_CIPH_ECB_MODE || dat->mode == EVP_CIPH_CBC_MODE)
 119         && !dat->enc) {
 120         ret = aesni_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
 121         dat->block = (block128_f) aesni_decrypt;
 122         dat->stream.cbc = dat->mode == EVP_CIPH_CBC_MODE ?
 123             (cbc128_f) aesni_cbc_encrypt : NULL;
 124     } else {
 125         ret = aesni_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
 126         dat->block = (block128_f) aesni_encrypt;
 127         if (dat->mode == EVP_CIPH_CBC_MODE)
 128             dat->stream.cbc = (cbc128_f) aesni_cbc_encrypt;
 129         else if (dat->mode == EVP_CIPH_CTR_MODE)
 130             dat->stream.ctr = (ctr128_f) aesni_ctr32_encrypt_blocks;
 131         else
 132             dat->stream.cbc = NULL;
 133     }
 134
 135     if (ret < 0) {
 136         EVPerr(EVP_F_AESNI_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
 137         return 0;
 138     }
 139
 140     return 1;
 141 }
 142
 143 static int aesni_cbc_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 144                             const unsigned char *in, size_t len)
 145 {
 146     aesni_cbc_encrypt(in, out, len, &ctx->ks.ks, ctx->iv, ctx->enc);
 147
 148     return 1;
 149 }
 150
 151 static int aesni_ecb_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 152                             const unsigned char *in, size_t len)
 153 {
 154     if (len < AES_BLOCK_SIZE)
 155         return 1;
 156
 157     aesni_ecb_encrypt(in, out, len, &ctx->ks.ks, ctx->enc);
 158
 159     return 1;
 160 }
 161
 162 # define aesni_ofb_cipher aes_ofb_cipher
 163 static int aesni_ofb_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 164                             const unsigned char *in, size_t len);
 165
 166 # define aesni_cfb_cipher aes_cfb_cipher
 167 static int aesni_cfb_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 168                             const unsigned char *in, size_t len);
 169
 170 # define aesni_cfb8_cipher aes_cfb8_cipher
 171 static int aesni_cfb8_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 172                              const unsigned char *in, size_t len);
 173
 174 # define aesni_cfb1_cipher aes_cfb1_cipher
 175 static int aesni_cfb1_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 176                              const unsigned char *in, size_t len);
 177
 178 # define aesni_ctr_cipher aes_ctr_cipher
 179 static int aesni_ctr_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 180                             const unsigned char *in, size_t len);
 181
 182 # define BLOCK_CIPHER_generic_prov(mode) \
 183 static const PROV_AES_CIPHER aesni_##mode = { \
 184         aesni_init_key,                 \
 185         aesni_##mode##_cipher};         \
 186 static const PROV_AES_CIPHER aes_##mode = { \
 187         aes_init_key,                   \
 188         aes_##mode##_cipher}; \
 189 const PROV_AES_CIPHER *PROV_AES_CIPHER_##mode(void) \
 190 { return AESNI_CAPABLE?&aesni_##mode:&aes_##mode; }
 191
 192
 193 #elif   defined(AES_ASM) && (defined(__sparc) || defined(__sparc__))
 194
 195 # include "sparc_arch.h"
 196
 197 extern unsigned int OPENSSL_sparcv9cap_P[];
 198
 199 /*
 200  * Fujitsu SPARC64 X support
 201  */
 202 # define HWAES_CAPABLE           (OPENSSL_sparcv9cap_P[0] & SPARCV9_FJAESX)
 203 # define HWAES_set_encrypt_key aes_fx_set_encrypt_key
 204 # define HWAES_set_decrypt_key aes_fx_set_decrypt_key
 205 # define HWAES_encrypt aes_fx_encrypt
 206 # define HWAES_decrypt aes_fx_decrypt
 207 # define HWAES_cbc_encrypt aes_fx_cbc_encrypt
 208 # define HWAES_ctr32_encrypt_blocks aes_fx_ctr32_encrypt_blocks
 209
 210 # define SPARC_AES_CAPABLE       (OPENSSL_sparcv9cap_P[1] & CFR_AES)
 211
 212 void aes_t4_set_encrypt_key(const unsigned char *key, int bits, AES_KEY *ks);
 213 void aes_t4_set_decrypt_key(const unsigned char *key, int bits, AES_KEY *ks);
 214 void aes_t4_encrypt(const unsigned char *in, unsigned char *out,
 215                     const AES_KEY *key);
 216 void aes_t4_decrypt(const unsigned char *in, unsigned char *out,
 217                     const AES_KEY *key);
 218 /*
 219  * Key-length specific subroutines were chosen for following reason.
 220  * Each SPARC T4 core can execute up to 8 threads which share core's
 221  * resources. Loading as much key material to registers allows to
 222  * minimize references to shared memory interface, as well as amount
 223  * of instructions in inner loops [much needed on T4]. But then having
 224  * non-key-length specific routines would require conditional branches
 225  * either in inner loops or on subroutines' entries. Former is hardly
 226  * acceptable, while latter means code size increase to size occupied
 227  * by multiple key-length specific subroutines, so why fight?
 228  */
 229 void aes128_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
 230                            size_t len, const AES_KEY *key,
 231                            unsigned char *ivec);
 232 void aes128_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
 233                            size_t len, const AES_KEY *key,
 234                            unsigned char *ivec);
 235 void aes192_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
 236                            size_t len, const AES_KEY *key,
 237                            unsigned char *ivec);
 238 void aes192_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
 239                            size_t len, const AES_KEY *key,
 240                            unsigned char *ivec);
 241 void aes256_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
 242                            size_t len, const AES_KEY *key,
 243                            unsigned char *ivec);
 244 void aes256_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
 245                            size_t len, const AES_KEY *key,
 246                            unsigned char *ivec);
 247 void aes128_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 248                              size_t blocks, const AES_KEY *key,
 249                              unsigned char *ivec);
 250 void aes192_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 251                              size_t blocks, const AES_KEY *key,
 252                              unsigned char *ivec);
 253 void aes256_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 254                              size_t blocks, const AES_KEY *key,
 255                              unsigned char *ivec);
 256
 257 static int aes_t4_init_key(PROV_AES_KEY *dat, const unsigned char *key,
 258                            size_t keylen)
 259 {
 260     int ret, bits;
 261
 262     bits = keylen * 8;
 263     if ((dat->mode == EVP_CIPH_ECB_MODE || dat->mode == EVP_CIPH_CBC_MODE)
 264         && !dat->enc) {
 265         ret = 0;
 266         aes_t4_set_decrypt_key(key, bits, &dat->ks.ks);
 267         dat->block = (block128_f) aes_t4_decrypt;
 268         switch (bits) {
 269         case 128:
 270             dat->stream.cbc = dat->mode == EVP_CIPH_CBC_MODE ?
 271                 (cbc128_f) aes128_t4_cbc_decrypt : NULL;
 272             break;
 273         case 192:
 274             dat->stream.cbc = dat->mode == EVP_CIPH_CBC_MODE ?
 275                 (cbc128_f) aes192_t4_cbc_decrypt : NULL;
 276             break;
 277         case 256:
 278             dat->stream.cbc = dat->mode == EVP_CIPH_CBC_MODE ?
 279                 (cbc128_f) aes256_t4_cbc_decrypt : NULL;
 280             break;
 281         default:
 282             ret = -1;
 283         }
 284     } else {
 285         ret = 0;
 286         aes_t4_set_encrypt_key(key, bits, &dat->ks.ks);
 287         dat->block = (block128_f)aes_t4_encrypt;
 288         switch (bits) {
 289         case 128:
 290             if (dat->mode == EVP_CIPH_CBC_MODE)
 291                 dat->stream.cbc = (cbc128_f)aes128_t4_cbc_encrypt;
 292             else if (dat->mode == EVP_CIPH_CTR_MODE)
 293                 dat->stream.ctr = (ctr128_f)aes128_t4_ctr32_encrypt;
 294             else
 295                 dat->stream.cbc = NULL;
 296             break;
 297         case 192:
 298             if (dat->mode == EVP_CIPH_CBC_MODE)
 299                 dat->stream.cbc = (cbc128_f)aes192_t4_cbc_encrypt;
 300             else if (dat->mode == EVP_CIPH_CTR_MODE)
 301                 dat->stream.ctr = (ctr128_f)aes192_t4_ctr32_encrypt;
 302             else
 303                 dat->stream.cbc = NULL;
 304             break;
 305         case 256:
 306             if (dat->mode == EVP_CIPH_CBC_MODE)
 307                 dat->stream.cbc = (cbc128_f)aes256_t4_cbc_encrypt;
 308             else if (dat->mode == EVP_CIPH_CTR_MODE)
 309                 dat->stream.ctr = (ctr128_f)aes256_t4_ctr32_encrypt;
 310             else
 311                 dat->stream.cbc = NULL;
 312             break;
 313         default:
 314             ret = -1;
 315         }
 316     }
 317
 318     if (ret < 0) {
 319         EVPerr(EVP_F_AES_T4_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
 320         return 0;
 321     }
 322
 323     return 1;
 324 }
 325
 326 # define aes_t4_cbc_cipher aes_cbc_cipher
 327 static int aes_t4_cbc_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 328                              const unsigned char *in, size_t len);
 329
 330 # define aes_t4_ecb_cipher aes_ecb_cipher
 331 static int aes_t4_ecb_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 332                              const unsigned char *in, size_t len);
 333
 334 # define aes_t4_ofb_cipher aes_ofb_cipher
 335 static int aes_t4_ofb_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 336                              const unsigned char *in, size_t len);
 337
 338 # define aes_t4_cfb_cipher aes_cfb_cipher
 339 static int aes_t4_cfb_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 340                              const unsigned char *in, size_t len);
 341
 342 # define aes_t4_cfb8_cipher aes_cfb8_cipher
 343 static int aes_t4_cfb8_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 344                               const unsigned char *in, size_t len);
 345
 346 # define aes_t4_cfb1_cipher aes_cfb1_cipher
 347 static int aes_t4_cfb1_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 348                               const unsigned char *in, size_t len);
 349
 350 # define aes_t4_ctr_cipher aes_ctr_cipher
 351 static int aes_t4_ctr_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 352                              const unsigned char *in, size_t len);
 353
 354 # define BLOCK_CIPHER_generic_prov(mode) \
 355 static const PROV_AES_CIPHER aes_t4_##mode = { \
 356         aes_t4_init_key,                 \
 357         aes_t4_##mode##_cipher};         \
 358 static const PROV_AES_CIPHER aes_##mode = { \
 359         aes_init_key,                   \
 360         aes_##mode##_cipher}; \
 361 const PROV_AES_CIPHER *PROV_AES_CIPHER_##mode(void) \
 362 { return SPARC_AES_CAPABLE?&aes_t4_##mode:&aes_##mode; }
 363
 364
 365 #elif defined(OPENSSL_CPUID_OBJ) && defined(__s390__)
 366 /*
 367  * IBM S390X support
 368  */
 369 # include "s390x_arch.h"
 370
 371 typedef struct {
 372     union {
 373         double align;
 374         /*-
 375          * KM-AES parameter block - begin
 376          * (see z/Architecture Principles of Operation >= SA22-7832-06)
 377          */
 378         struct {
 379             unsigned char k[32];
 380         } param;
 381         /* KM-AES parameter block - end */
 382     } km;
 383     unsigned int fc;
 384 } S390X_AES_ECB_CTX;
 385
 386 typedef struct {
 387     union {
 388         double align;
 389         /*-
 390          * KMO-AES parameter block - begin
 391          * (see z/Architecture Principles of Operation >= SA22-7832-08)
 392          */
 393         struct {
 394             unsigned char cv[16];
 395             unsigned char k[32];
 396         } param;
 397         /* KMO-AES parameter block - end */
 398     } kmo;
 399     unsigned int fc;
 400
 401     int res;
 402 } S390X_AES_OFB_CTX;
 403
 404 typedef struct {
 405     union {
 406         double align;
 407         /*-
 408          * KMF-AES parameter block - begin
 409          * (see z/Architecture Principles of Operation >= SA22-7832-08)
 410          */
 411         struct {
 412             unsigned char cv[16];
 413             unsigned char k[32];
 414         } param;
 415         /* KMF-AES parameter block - end */
 416     } kmf;
 417     unsigned int fc;
 418
 419     int res;
 420 } S390X_AES_CFB_CTX;
 421
 422 /* Convert key size to function code: [16,24,32] -> [18,19,20]. */
 423 # define S390X_AES_FC(keylen)  (S390X_AES_128 + ((((keylen) << 3) - 128) >> 6))
 424
 425 /* Most modes of operation need km for partial block processing. */
 426 # define S390X_aes_128_CAPABLE (OPENSSL_s390xcap_P.km[0] &      \
 427                                 S390X_CAPBIT(S390X_AES_128))
 428 # define S390X_aes_192_CAPABLE (OPENSSL_s390xcap_P.km[0] &      \
 429                                 S390X_CAPBIT(S390X_AES_192))
 430 # define S390X_aes_256_CAPABLE (OPENSSL_s390xcap_P.km[0] &      \
 431                                 S390X_CAPBIT(S390X_AES_256))
 432
 433 # define s390x_aes_init_key aes_init_key
 434 static int s390x_aes_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 435                               const unsigned char *iv, int enc);
 436
 437 # define S390X_aes_128_cbc_CAPABLE      1       /* checked by callee */
 438 # define S390X_aes_192_cbc_CAPABLE      1
 439 # define S390X_aes_256_cbc_CAPABLE      1
 440 # define S390X_AES_CBC_CTX              PROV_AES_KEY
 441
 442 # define s390x_aes_cbc_init_key aes_init_key
 443
 444 # define s390x_aes_cbc_cipher aes_cbc_cipher
 445 static int s390x_aes_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 446                                 const unsigned char *in, size_t len);
 447
 448 # define S390X_aes_128_ecb_CAPABLE      S390X_aes_128_CAPABLE
 449 # define S390X_aes_192_ecb_CAPABLE      S390X_aes_192_CAPABLE
 450 # define S390X_aes_256_ecb_CAPABLE      S390X_aes_256_CAPABLE
 451
 452 static int s390x_aes_ecb_init_key(EVP_CIPHER_CTX *ctx,
 453                                   const unsigned char *key,
 454                                   const unsigned char *iv, int enc)
 455 {
 456     S390X_AES_ECB_CTX *cctx = EVP_C_DATA(S390X_AES_ECB_CTX, ctx);
 457     const int keylen = EVP_CIPHER_CTX_key_length(ctx);
 458
 459     cctx->fc = S390X_AES_FC(keylen);
 460     if (!enc)
 461         cctx->fc |= S390X_DECRYPT;
 462
 463     memcpy(cctx->km.param.k, key, keylen);
 464     return 1;
 465 }
 466
 467 static int s390x_aes_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 468                                 const unsigned char *in, size_t len)
 469 {
 470     S390X_AES_ECB_CTX *cctx = EVP_C_DATA(S390X_AES_ECB_CTX, ctx);
 471
 472     s390x_km(in, len, out, cctx->fc, &cctx->km.param);
 473     return 1;
 474 }
 475
 476 # define S390X_aes_128_ofb_CAPABLE (S390X_aes_128_CAPABLE &&            \
 477                                     (OPENSSL_s390xcap_P.kmo[0] &        \
 478                                      S390X_CAPBIT(S390X_AES_128)))
 479 # define S390X_aes_192_ofb_CAPABLE (S390X_aes_192_CAPABLE &&            \
 480                                     (OPENSSL_s390xcap_P.kmo[0] &        \
 481                                      S390X_CAPBIT(S390X_AES_192)))
 482 # define S390X_aes_256_ofb_CAPABLE (S390X_aes_256_CAPABLE &&            \
 483                                     (OPENSSL_s390xcap_P.kmo[0] &        \
 484                                      S390X_CAPBIT(S390X_AES_256)))
 485
 486 static int s390x_aes_ofb_init_key(EVP_CIPHER_CTX *ctx,
 487                                   const unsigned char *key,
 488                                   const unsigned char *ivec, int enc)
 489 {
 490     S390X_AES_OFB_CTX *cctx = EVP_C_DATA(S390X_AES_OFB_CTX, ctx);
 491     const unsigned char *iv = EVP_CIPHER_CTX_original_iv(ctx);
 492     const int keylen = EVP_CIPHER_CTX_key_length(ctx);
 493     const int ivlen = EVP_CIPHER_CTX_iv_length(ctx);
 494
 495     memcpy(cctx->kmo.param.cv, iv, ivlen);
 496     memcpy(cctx->kmo.param.k, key, keylen);
 497     cctx->fc = S390X_AES_FC(keylen);
 498     cctx->res = 0;
 499     return 1;
 500 }
 501
 502 static int s390x_aes_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 503                                 const unsigned char *in, size_t len)
 504 {
 505     S390X_AES_OFB_CTX *cctx = EVP_C_DATA(S390X_AES_OFB_CTX, ctx);
 506     int n = cctx->res;
 507     int rem;
 508
 509     while (n && len) {
 510         *out = *in ^ cctx->kmo.param.cv[n];
 511         n = (n + 1) & 0xf;
 512         --len;
 513         ++in;
 514         ++out;
 515     }
 516
 517     rem = len & 0xf;
 518
 519     len &= ~(size_t)0xf;
 520     if (len) {
 521         s390x_kmo(in, len, out, cctx->fc, &cctx->kmo.param);
 522
 523         out += len;
 524         in += len;
 525     }
 526
 527     if (rem) {
 528         s390x_km(cctx->kmo.param.cv, 16, cctx->kmo.param.cv, cctx->fc,
 529                  cctx->kmo.param.k);
 530
 531         while (rem--) {
 532             out[n] = in[n] ^ cctx->kmo.param.cv[n];
 533             ++n;
 534         }
 535     }
 536
 537     cctx->res = n;
 538     return 1;
 539 }
 540
 541 # define S390X_aes_128_cfb_CAPABLE (S390X_aes_128_CAPABLE &&            \
 542                                     (OPENSSL_s390xcap_P.kmf[0] &        \
 543                                      S390X_CAPBIT(S390X_AES_128)))
 544 # define S390X_aes_192_cfb_CAPABLE (S390X_aes_192_CAPABLE &&            \
 545                                     (OPENSSL_s390xcap_P.kmf[0] &        \
 546                                      S390X_CAPBIT(S390X_AES_192)))
 547 # define S390X_aes_256_cfb_CAPABLE (S390X_aes_256_CAPABLE &&            \
 548                                     (OPENSSL_s390xcap_P.kmf[0] &        \
 549                                      S390X_CAPBIT(S390X_AES_256)))
 550
 551 static int s390x_aes_cfb_init_key(EVP_CIPHER_CTX *ctx,
 552                                   const unsigned char *key,
 553                                   const unsigned char *ivec, int enc)
 554 {
 555     S390X_AES_CFB_CTX *cctx = EVP_C_DATA(S390X_AES_CFB_CTX, ctx);
 556     const unsigned char *iv = EVP_CIPHER_CTX_original_iv(ctx);
 557     const int keylen = EVP_CIPHER_CTX_key_length(ctx);
 558     const int ivlen = EVP_CIPHER_CTX_iv_length(ctx);
 559
 560     cctx->fc = S390X_AES_FC(keylen);
 561     cctx->fc |= 16 << 24;   /* 16 bytes cipher feedback */
 562     if (!enc)
 563         cctx->fc |= S390X_DECRYPT;
 564
 565     cctx->res = 0;
 566     memcpy(cctx->kmf.param.cv, iv, ivlen);
 567     memcpy(cctx->kmf.param.k, key, keylen);
 568     return 1;
 569 }
 570
 571 static int s390x_aes_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 572                                 const unsigned char *in, size_t len)
 573 {
 574     S390X_AES_CFB_CTX *cctx = EVP_C_DATA(S390X_AES_CFB_CTX, ctx);
 575     const int keylen = EVP_CIPHER_CTX_key_length(ctx);
 576     const int enc = EVP_CIPHER_CTX_encrypting(ctx);
 577     int n = cctx->res;
 578     int rem;
 579     unsigned char tmp;
 580
 581     while (n && len) {
 582         tmp = *in;
 583         *out = cctx->kmf.param.cv[n] ^ tmp;
 584         cctx->kmf.param.cv[n] = enc ? *out : tmp;
 585         n = (n + 1) & 0xf;
 586         --len;
 587         ++in;
 588         ++out;
 589     }
 590
 591     rem = len & 0xf;
 592
 593     len &= ~(size_t)0xf;
 594     if (len) {
 595         s390x_kmf(in, len, out, cctx->fc, &cctx->kmf.param);
 596
 597         out += len;
 598         in += len;
 599     }
 600
 601     if (rem) {
 602         s390x_km(cctx->kmf.param.cv, 16, cctx->kmf.param.cv,
 603                  S390X_AES_FC(keylen), cctx->kmf.param.k);
 604
 605         while (rem--) {
 606             tmp = in[n];
 607             out[n] = cctx->kmf.param.cv[n] ^ tmp;
 608             cctx->kmf.param.cv[n] = enc ? out[n] : tmp;
 609             ++n;
 610         }
 611     }
 612
 613     cctx->res = n;
 614     return 1;
 615 }
 616
 617 # define S390X_aes_128_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] &        \
 618                                      S390X_CAPBIT(S390X_AES_128))
 619 # define S390X_aes_192_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] &        \
 620                                      S390X_CAPBIT(S390X_AES_192))
 621 # define S390X_aes_256_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] &        \
 622                                      S390X_CAPBIT(S390X_AES_256))
 623
 624 static int s390x_aes_cfb8_init_key(EVP_CIPHER_CTX *ctx,
 625                                    const unsigned char *key,
 626                                    const unsigned char *ivec, int enc)
 627 {
 628     S390X_AES_CFB_CTX *cctx = EVP_C_DATA(S390X_AES_CFB_CTX, ctx);
 629     const unsigned char *iv = EVP_CIPHER_CTX_original_iv(ctx);
 630     const int keylen = EVP_CIPHER_CTX_key_length(ctx);
 631     const int ivlen = EVP_CIPHER_CTX_iv_length(ctx);
 632
 633     cctx->fc = S390X_AES_FC(keylen);
 634     cctx->fc |= 1 << 24;   /* 1 byte cipher feedback */
 635     if (!enc)
 636         cctx->fc |= S390X_DECRYPT;
 637
 638     memcpy(cctx->kmf.param.cv, iv, ivlen);
 639     memcpy(cctx->kmf.param.k, key, keylen);
 640     return 1;
 641 }
 642
 643 static int s390x_aes_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 644                                  const unsigned char *in, size_t len)
 645 {
 646     S390X_AES_CFB_CTX *cctx = EVP_C_DATA(S390X_AES_CFB_CTX, ctx);
 647
 648     s390x_kmf(in, len, out, cctx->fc, &cctx->kmf.param);
 649     return 1;
 650 }
 651
 652 # define S390X_aes_128_cfb1_CAPABLE     0
 653 # define S390X_aes_192_cfb1_CAPABLE     0
 654 # define S390X_aes_256_cfb1_CAPABLE     0
 655
 656 # define s390x_aes_cfb1_init_key aes_init_key
 657
 658 # define s390x_aes_cfb1_cipher aes_cfb1_cipher
 659 static int s390x_aes_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 660                                  const unsigned char *in, size_t len);
 661
 662 # define S390X_aes_128_ctr_CAPABLE      1       /* checked by callee */
 663 # define S390X_aes_192_ctr_CAPABLE      1
 664 # define S390X_aes_256_ctr_CAPABLE      1
 665 # define S390X_AES_CTR_CTX              PROV_AES_KEY
 666
 667 # define s390x_aes_ctr_init_key aes_init_key
 668
 669 # define s390x_aes_ctr_cipher aes_ctr_cipher
 670 static int s390x_aes_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 671                                 const unsigned char *in, size_t len);
 672
 673
 674 # define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,    \
 675                               MODE,flags)                               \
 676 static const EVP_CIPHER s390x_aes_##keylen##_##mode = {                 \
 677     nid##_##keylen##_##nmode,blocksize,                                 \
 678     keylen / 8,                                                         \
 679     ivlen,                                                              \
 680     flags | EVP_CIPH_##MODE##_MODE,                                     \
 681     s390x_aes_##mode##_init_key,                                        \
 682     s390x_aes_##mode##_cipher,                                          \
 683     NULL,                                                               \
 684     sizeof(S390X_AES_##MODE##_CTX),                                     \
 685     NULL,                                                               \
 686     NULL,                                                               \
 687     NULL,                                                               \
 688     NULL                                                                \
 689 };                                                                      \
 690 static const EVP_CIPHER aes_##keylen##_##mode = {                       \
 691     nid##_##keylen##_##nmode,                                           \
 692     blocksize,                                                          \
 693     keylen / 8,                                                         \
 694     ivlen,                                                              \
 695     flags | EVP_CIPH_##MODE##_MODE,                                     \
 696     aes_init_key,                                                       \
 697     aes_##mode##_cipher,                                                \
 698     NULL,                                                               \
 699     sizeof(PROV_AES_KEY),                                               \
 700     NULL,                                                               \
 701     NULL,                                                               \
 702     NULL,                                                               \
 703     NULL                                                                \
 704 };                                                                      \
 705 const EVP_CIPHER *EVP_aes_##keylen##_##mode(void)                       \
 706 {                                                                       \
 707     return S390X_aes_##keylen##_##mode##_CAPABLE ?                      \
 708            &s390x_aes_##keylen##_##mode : &aes_##keylen##_##mode;       \
 709 }
 710
 711 #else
 712
 713 # define BLOCK_CIPHER_generic_prov(mode) \
 714 static const PROV_AES_CIPHER aes_##mode = { \
 715         aes_init_key,                   \
 716         aes_##mode##_cipher}; \
 717 const PROV_AES_CIPHER *PROV_AES_CIPHER_##mode(void) \
 718 { return &aes_##mode; }
 719
 720 #endif
 721
 722 #if defined(OPENSSL_CPUID_OBJ) && (defined(__arm__) || defined(__arm) || defined(__aarch64__))
 723 # include "arm_arch.h"
 724 # if __ARM_MAX_ARCH__>=7
 725 #  if defined(BSAES_ASM)
 726 #   define BSAES_CAPABLE (OPENSSL_armcap_P & ARMV7_NEON)
 727 #  endif
 728 #  if defined(VPAES_ASM)
 729 #   define VPAES_CAPABLE (OPENSSL_armcap_P & ARMV7_NEON)
 730 #  endif
 731 #  define HWAES_CAPABLE (OPENSSL_armcap_P & ARMV8_AES)
 732 #  define HWAES_set_encrypt_key aes_v8_set_encrypt_key
 733 #  define HWAES_set_decrypt_key aes_v8_set_decrypt_key
 734 #  define HWAES_encrypt aes_v8_encrypt
 735 #  define HWAES_decrypt aes_v8_decrypt
 736 #  define HWAES_cbc_encrypt aes_v8_cbc_encrypt
 737 #  define HWAES_ctr32_encrypt_blocks aes_v8_ctr32_encrypt_blocks
 738 # endif
 739 #endif
 740
 741 #if defined(HWAES_CAPABLE)
 742 int HWAES_set_encrypt_key(const unsigned char *userKey, const int bits,
 743                           AES_KEY *key);
 744 int HWAES_set_decrypt_key(const unsigned char *userKey, const int bits,
 745                           AES_KEY *key);
 746 void HWAES_encrypt(const unsigned char *in, unsigned char *out,
 747                    const AES_KEY *key);
 748 void HWAES_decrypt(const unsigned char *in, unsigned char *out,
 749                    const AES_KEY *key);
 750 void HWAES_cbc_encrypt(const unsigned char *in, unsigned char *out,
 751                        size_t length, const AES_KEY *key,
 752                        unsigned char *ivec, const int enc);
 753 void HWAES_ctr32_encrypt_blocks(const unsigned char *in, unsigned char *out,
 754                                 size_t len, const AES_KEY *key,
 755                                 const unsigned char ivec[16]);
 756 #endif
 757
 758 static int aes_init_key(PROV_AES_KEY *dat, const unsigned char *key,
 759                         size_t keylen)
 760 {
 761     int ret;
 762
 763     if ((dat->mode == EVP_CIPH_ECB_MODE || dat->mode == EVP_CIPH_CBC_MODE)
 764         && !dat->enc) {
 765 #ifdef HWAES_CAPABLE
 766         if (HWAES_CAPABLE) {
 767             ret = HWAES_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
 768             dat->block = (block128_f)HWAES_decrypt;
 769             dat->stream.cbc = NULL;
 770 # ifdef HWAES_cbc_encrypt
 771             if (dat->mode == EVP_CIPH_CBC_MODE)
 772                 dat->stream.cbc = (cbc128_f)HWAES_cbc_encrypt;
 773 # endif
 774         } else
 775 #endif
 776 #ifdef BSAES_CAPABLE
 777         if (BSAES_CAPABLE && dat->mode == EVP_CIPH_CBC_MODE) {
 778             ret = AES_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
 779             dat->block = (block128_f)AES_decrypt;
 780             dat->stream.cbc = (cbc128_f)bsaes_cbc_encrypt;
 781         } else
 782 #endif
 783 #ifdef VPAES_CAPABLE
 784         if (VPAES_CAPABLE) {
 785             ret = vpaes_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
 786             dat->block = (block128_f)vpaes_decrypt;
 787             dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
 788                               ?(cbc128_f)vpaes_cbc_encrypt : NULL;
 789         } else
 790 #endif
 791         {
 792             ret = AES_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
 793             dat->block = (block128_f)AES_decrypt;
 794             dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
 795                               ? (cbc128_f)AES_cbc_encrypt : NULL;
 796         }
 797     } else
 798 #ifdef HWAES_CAPABLE
 799     if (HWAES_CAPABLE) {
 800         ret = HWAES_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
 801         dat->block = (block128_f)HWAES_encrypt;
 802         dat->stream.cbc = NULL;
 803 # ifdef HWAES_cbc_encrypt
 804         if (dat->mode == EVP_CIPH_CBC_MODE)
 805             dat->stream.cbc = (cbc128_f)HWAES_cbc_encrypt;
 806         else
 807 # endif
 808 # ifdef HWAES_ctr32_encrypt_blocks
 809         if (dat->mode == EVP_CIPH_CTR_MODE)
 810             dat->stream.ctr = (ctr128_f)HWAES_ctr32_encrypt_blocks;
 811         else
 812 # endif
 813             (void)0;            /* terminate potentially open 'else' */
 814     } else
 815 #endif
 816 #ifdef BSAES_CAPABLE
 817     if (BSAES_CAPABLE && dat->mode == EVP_CIPH_CTR_MODE) {
 818         ret = AES_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
 819         dat->block = (block128_f)AES_encrypt;
 820         dat->stream.ctr = (ctr128_f)bsaes_ctr32_encrypt_blocks;
 821     } else
 822 #endif
 823 #ifdef VPAES_CAPABLE
 824     if (VPAES_CAPABLE) {
 825         ret = vpaes_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
 826         dat->block = (block128_f)vpaes_encrypt;
 827         dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
 828                           ? (cbc128_f)vpaes_cbc_encrypt : NULL;
 829     } else
 830 #endif
 831     {
 832         ret = AES_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
 833         dat->block = (block128_f)AES_encrypt;
 834         dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
 835                           ? (cbc128_f)AES_cbc_encrypt : NULL;
 836 #ifdef AES_CTR_ASM
 837         if (dat->mode == EVP_CIPH_CTR_MODE)
 838             dat->stream.ctr = (ctr128_f)AES_ctr32_encrypt;
 839 #endif
 840     }
 841
 842     if (ret < 0) {
 843         EVPerr(EVP_F_AES_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
 844         return 0;
 845     }
 846
 847     return 1;
 848 }
 849
 850 static int aes_cbc_cipher(PROV_AES_KEY *dat, unsigned char *out,
 851                           const unsigned char *in, size_t len)
 852 {
 853     if (dat->stream.cbc)
 854         (*dat->stream.cbc) (in, out, len, &dat->ks, dat->iv, dat->enc);
 855     else if (dat->enc)
 856         CRYPTO_cbc128_encrypt(in, out, len, &dat->ks, dat->iv, dat->block);
 857     else
 858         CRYPTO_cbc128_decrypt(in, out, len, &dat->ks, dat->iv, dat->block);
 859
 860     return 1;
 861 }
 862
 863 static int aes_ecb_cipher(PROV_AES_KEY *dat, unsigned char *out,
 864                           const unsigned char *in, size_t len)
 865 {
 866     size_t i;
 867
 868     if (len < AES_BLOCK_SIZE)
 869         return 1;
 870
 871     for (i = 0, len -= AES_BLOCK_SIZE; i <= len; i += AES_BLOCK_SIZE)
 872         (*dat->block) (in + i, out + i, &dat->ks);
 873
 874     return 1;
 875 }
 876
 877 static int aes_ofb_cipher(PROV_AES_KEY *dat, unsigned char *out,
 878                           const unsigned char *in, size_t len)
 879 {
 880     int num = dat->num;
 881     CRYPTO_ofb128_encrypt(in, out, len, &dat->ks, dat->iv, &num, dat->block);
 882     dat->num = num;
 883
 884     return 1;
 885 }
 886
 887 static int aes_cfb_cipher(PROV_AES_KEY *dat, unsigned char *out,
 888                           const unsigned char *in, size_t len)
 889 {
 890     int num = dat->num;
 891     CRYPTO_cfb128_encrypt(in, out, len, &dat->ks, dat->iv, &num, dat->enc,
 892                           dat->block);
 893     dat->num = num;
 894
 895     return 1;
 896 }
 897
 898 static int aes_cfb8_cipher(PROV_AES_KEY *dat, unsigned char *out,
 899                            const unsigned char *in, size_t len)
 900 {
 901     int num = dat->num;
 902     CRYPTO_cfb128_8_encrypt(in, out, len, &dat->ks, dat->iv, &num, dat->enc,
 903                             dat->block);
 904     dat->num = num;
 905
 906     return 1;
 907 }
 908
 909 static int aes_cfb1_cipher(PROV_AES_KEY *dat, unsigned char *out,
 910                            const unsigned char *in, size_t len)
 911 {
 912     int num = dat->num;
 913
 914     if ((dat->flags & EVP_CIPH_FLAG_LENGTH_BITS) != 0) {
 915         CRYPTO_cfb128_1_encrypt(in, out, len, &dat->ks, dat->iv, &num,
 916                                 dat->enc, dat->block);
 917         dat->num = num;
 918         return 1;
 919     }
 920
 921     while (len >= MAXBITCHUNK) {
 922         CRYPTO_cfb128_1_encrypt(in, out, MAXBITCHUNK * 8, &dat->ks,
 923                                 dat->iv, &num, dat->enc, dat->block);
 924         len -= MAXBITCHUNK;
 925         out += MAXBITCHUNK;
 926         in  += MAXBITCHUNK;
 927     }
 928     if (len)
 929         CRYPTO_cfb128_1_encrypt(in, out, len * 8, &dat->ks, dat->iv, &num,
 930                                 dat->enc, dat->block);
 931
 932     dat->num = num;
 933
 934     return 1;
 935 }
 936
 937 static int aes_ctr_cipher(PROV_AES_KEY *dat, unsigned char *out,
 938                           const unsigned char *in, size_t len)
 939 {
 940     unsigned int num = dat->num;
 941
 942     if (dat->stream.ctr)
 943         CRYPTO_ctr128_encrypt_ctr32(in, out, len, &dat->ks, dat->iv, dat->buf,
 944                                     &num, dat->stream.ctr);
 945     else
 946         CRYPTO_ctr128_encrypt(in, out, len, &dat->ks, dat->iv, dat->buf,
 947                               &num, dat->block);
 948     dat->num = num;
 949
 950     return 1;
 951 }
 952
 953 BLOCK_CIPHER_generic_prov(cbc)
 954 BLOCK_CIPHER_generic_prov(ecb)
 955 BLOCK_CIPHER_generic_prov(ofb)
 956 BLOCK_CIPHER_generic_prov(cfb)
 957 BLOCK_CIPHER_generic_prov(cfb1)
 958 BLOCK_CIPHER_generic_prov(cfb8)
 959 BLOCK_CIPHER_generic_prov(ctr)
 960