providers/common/ciphers/aes_basic.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 #include <string.h>
  10 #include <assert.h>
  11 #include <openssl/opensslconf.h>
  12 #include <openssl/crypto.h>
  13 #include <openssl/err.h>
  14 #include <openssl/aes.h>
  15 #include <openssl/rand.h>
  16 #include <openssl/cmac.h>
  17 #include "ciphers_locl.h"
  18 #include "internal/evp_int.h"
  19 #include "internal/providercommonerr.h"
  20 #include "internal/aes_platform.h"
  21
  22 #define MAXBITCHUNK     ((size_t)1 << (sizeof(size_t) * 8 - 4))
  23
  24 #if defined(AESNI_CAPABLE)
  25
  26 /* AES-NI section. */
  27
  28 static int aesni_init_key(PROV_AES_KEY *dat, const unsigned char *key,
  29                           size_t keylen)
  30 {
  31     int ret;
  32
  33     if ((dat->mode == EVP_CIPH_ECB_MODE || dat->mode == EVP_CIPH_CBC_MODE)
  34         && !dat->enc) {
  35         ret = aesni_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
  36         dat->block = (block128_f) aesni_decrypt;
  37         dat->stream.cbc = dat->mode == EVP_CIPH_CBC_MODE ?
  38             (cbc128_f) aesni_cbc_encrypt : NULL;
  39     } else {
  40         ret = aesni_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
  41         dat->block = (block128_f) aesni_encrypt;
  42         if (dat->mode == EVP_CIPH_CBC_MODE)
  43             dat->stream.cbc = (cbc128_f) aesni_cbc_encrypt;
  44         else if (dat->mode == EVP_CIPH_CTR_MODE)
  45             dat->stream.ctr = (ctr128_f) aesni_ctr32_encrypt_blocks;
  46         else
  47             dat->stream.cbc = NULL;
  48     }
  49
  50     if (ret < 0) {
  51         PROVerr(PROV_F_AESNI_INIT_KEY, PROV_R_AES_KEY_SETUP_FAILED);
  52         return 0;
  53     }
  54
  55     return 1;
  56 }
  57
  58 static int aesni_cbc_cipher(PROV_AES_KEY *ctx, unsigned char *out,
  59                             const unsigned char *in, size_t len)
  60 {
  61     aesni_cbc_encrypt(in, out, len, &ctx->ks.ks, ctx->iv, ctx->enc);
  62
  63     return 1;
  64 }
  65
  66 static int aesni_ecb_cipher(PROV_AES_KEY *ctx, unsigned char *out,
  67                             const unsigned char *in, size_t len)
  68 {
  69     if (len < AES_BLOCK_SIZE)
  70         return 1;
  71
  72     aesni_ecb_encrypt(in, out, len, &ctx->ks.ks, ctx->enc);
  73
  74     return 1;
  75 }
  76
  77 # define aesni_ofb_cipher aes_ofb_cipher
  78 static int aesni_ofb_cipher(PROV_AES_KEY *ctx, unsigned char *out,
  79                             const unsigned char *in, size_t len);
  80
  81 # define aesni_cfb_cipher aes_cfb_cipher
  82 static int aesni_cfb_cipher(PROV_AES_KEY *ctx, unsigned char *out,
  83                             const unsigned char *in, size_t len);
  84
  85 # define aesni_cfb8_cipher aes_cfb8_cipher
  86 static int aesni_cfb8_cipher(PROV_AES_KEY *ctx, unsigned char *out,
  87                              const unsigned char *in, size_t len);
  88
  89 # define aesni_cfb1_cipher aes_cfb1_cipher
  90 static int aesni_cfb1_cipher(PROV_AES_KEY *ctx, unsigned char *out,
  91                              const unsigned char *in, size_t len);
  92
  93 # define aesni_ctr_cipher aes_ctr_cipher
  94 static int aesni_ctr_cipher(PROV_AES_KEY *ctx, unsigned char *out,
  95                             const unsigned char *in, size_t len);
  96
  97 # define BLOCK_CIPHER_generic_prov(mode) \
  98 static const PROV_AES_CIPHER aesni_##mode = { \
  99         aesni_init_key,                 \
 100         aesni_##mode##_cipher};         \
 101 static const PROV_AES_CIPHER aes_##mode = { \
 102         aes_init_key,                   \
 103         aes_##mode##_cipher}; \
 104 const PROV_AES_CIPHER *PROV_AES_CIPHER_##mode(size_t keylen) \
 105 { return AESNI_CAPABLE?&aesni_##mode:&aes_##mode; }
 106
 107
 108 #elif defined(SPARC_AES_CAPABLE)
 109
 110 static int aes_t4_init_key(PROV_AES_KEY *dat, const unsigned char *key,
 111                            size_t keylen)
 112 {
 113     int ret, bits;
 114
 115     bits = keylen * 8;
 116     if ((dat->mode == EVP_CIPH_ECB_MODE || dat->mode == EVP_CIPH_CBC_MODE)
 117         && !dat->enc) {
 118         ret = 0;
 119         aes_t4_set_decrypt_key(key, bits, &dat->ks.ks);
 120         dat->block = (block128_f) aes_t4_decrypt;
 121         switch (bits) {
 122         case 128:
 123             dat->stream.cbc = dat->mode == EVP_CIPH_CBC_MODE ?
 124                 (cbc128_f) aes128_t4_cbc_decrypt : NULL;
 125             break;
 126         case 192:
 127             dat->stream.cbc = dat->mode == EVP_CIPH_CBC_MODE ?
 128                 (cbc128_f) aes192_t4_cbc_decrypt : NULL;
 129             break;
 130         case 256:
 131             dat->stream.cbc = dat->mode == EVP_CIPH_CBC_MODE ?
 132                 (cbc128_f) aes256_t4_cbc_decrypt : NULL;
 133             break;
 134         default:
 135             ret = -1;
 136         }
 137     } else {
 138         ret = 0;
 139         aes_t4_set_encrypt_key(key, bits, &dat->ks.ks);
 140         dat->block = (block128_f)aes_t4_encrypt;
 141         switch (bits) {
 142         case 128:
 143             if (dat->mode == EVP_CIPH_CBC_MODE)
 144                 dat->stream.cbc = (cbc128_f)aes128_t4_cbc_encrypt;
 145             else if (dat->mode == EVP_CIPH_CTR_MODE)
 146                 dat->stream.ctr = (ctr128_f)aes128_t4_ctr32_encrypt;
 147             else
 148                 dat->stream.cbc = NULL;
 149             break;
 150         case 192:
 151             if (dat->mode == EVP_CIPH_CBC_MODE)
 152                 dat->stream.cbc = (cbc128_f)aes192_t4_cbc_encrypt;
 153             else if (dat->mode == EVP_CIPH_CTR_MODE)
 154                 dat->stream.ctr = (ctr128_f)aes192_t4_ctr32_encrypt;
 155             else
 156                 dat->stream.cbc = NULL;
 157             break;
 158         case 256:
 159             if (dat->mode == EVP_CIPH_CBC_MODE)
 160                 dat->stream.cbc = (cbc128_f)aes256_t4_cbc_encrypt;
 161             else if (dat->mode == EVP_CIPH_CTR_MODE)
 162                 dat->stream.ctr = (ctr128_f)aes256_t4_ctr32_encrypt;
 163             else
 164                 dat->stream.cbc = NULL;
 165             break;
 166         default:
 167             ret = -1;
 168         }
 169     }
 170
 171     if (ret < 0) {
 172         PROVerr(PROV_F_AES_T4_INIT_KEY, PROV_R_AES_KEY_SETUP_FAILED);
 173         return 0;
 174     }
 175
 176     return 1;
 177 }
 178
 179 # define aes_t4_cbc_cipher aes_cbc_cipher
 180 static int aes_t4_cbc_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 181                              const unsigned char *in, size_t len);
 182
 183 # define aes_t4_ecb_cipher aes_ecb_cipher
 184 static int aes_t4_ecb_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 185                              const unsigned char *in, size_t len);
 186
 187 # define aes_t4_ofb_cipher aes_ofb_cipher
 188 static int aes_t4_ofb_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 189                              const unsigned char *in, size_t len);
 190
 191 # define aes_t4_cfb_cipher aes_cfb_cipher
 192 static int aes_t4_cfb_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 193                              const unsigned char *in, size_t len);
 194
 195 # define aes_t4_cfb8_cipher aes_cfb8_cipher
 196 static int aes_t4_cfb8_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 197                               const unsigned char *in, size_t len);
 198
 199 # define aes_t4_cfb1_cipher aes_cfb1_cipher
 200 static int aes_t4_cfb1_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 201                               const unsigned char *in, size_t len);
 202
 203 # define aes_t4_ctr_cipher aes_ctr_cipher
 204 static int aes_t4_ctr_cipher(PROV_AES_KEY *ctx, unsigned char *out,
 205                              const unsigned char *in, size_t len);
 206
 207 # define BLOCK_CIPHER_generic_prov(mode) \
 208 static const PROV_AES_CIPHER aes_t4_##mode = { \
 209         aes_t4_init_key,                 \
 210         aes_t4_##mode##_cipher};         \
 211 static const PROV_AES_CIPHER aes_##mode = { \
 212         aes_init_key,                   \
 213         aes_##mode##_cipher}; \
 214 const PROV_AES_CIPHER *PROV_AES_CIPHER_##mode(size_t keylen) \
 215 { return SPARC_AES_CAPABLE?&aes_t4_##mode:&aes_##mode; }
 216
 217
 218 #elif defined(S390X_aes_128_CAPABLE)
 219 /*
 220  * IBM S390X support
 221  */
 222 # include "s390x_arch.h"
 223
 224 # define s390x_aes_init_key aes_init_key
 225 static int s390x_aes_init_key(PROV_AES_KEY *dat, const unsigned char *key,
 226                               size_t keylen);
 227 # define S390X_AES_CBC_CTX          PROV_AES_KEY
 228
 229 # define s390x_aes_cbc_init_key aes_init_key
 230
 231 # define s390x_aes_cbc_cipher aes_cbc_cipher
 232 static int s390x_aes_cbc_cipher(PROV_AES_KEY *dat, unsigned char *out,
 233                                 const unsigned char *in, size_t len);
 234
 235 static int s390x_aes_ecb_init_key(PROV_AES_KEY *dat, const unsigned char *key,
 236                                   size_t keylen)
 237 {
 238     dat->plat.s390x.fc = S390X_AES_FC(keylen);
 239     if (!dat->enc)
 240         dat->plat.s390x.fc |= S390X_DECRYPT;
 241
 242     memcpy(dat->plat.s390x.param.km.k, key, keylen);
 243     return 1;
 244 }
 245
 246 static int s390x_aes_ecb_cipher(PROV_AES_KEY *dat, unsigned char *out,
 247                                 const unsigned char *in, size_t len)
 248 {
 249     s390x_km(in, len, out, dat->plat.s390x.fc,
 250              &dat->plat.s390x.param.km);
 251     return 1;
 252 }
 253
 254 static int s390x_aes_ofb_init_key(PROV_AES_KEY *dat, const unsigned char *key,
 255                                   size_t keylen)
 256 {
 257     memcpy(dat->plat.s390x.param.kmo_kmf.cv, dat->iv, AES_BLOCK_SIZE);
 258     memcpy(dat->plat.s390x.param.kmo_kmf.k, key, keylen);
 259     dat->plat.s390x.fc = S390X_AES_FC(keylen);
 260     dat->plat.s390x.res = 0;
 261     return 1;
 262 }
 263
 264 static int s390x_aes_ofb_cipher(PROV_AES_KEY *dat, unsigned char *out,
 265                                 const unsigned char *in, size_t len)
 266 {
 267     int n = dat->plat.s390x.res;
 268     int rem;
 269
 270     while (n && len) {
 271         *out = *in ^ dat->plat.s390x.param.kmo_kmf.cv[n];
 272         n = (n + 1) & 0xf;
 273         --len;
 274         ++in;
 275         ++out;
 276     }
 277
 278     rem = len & 0xf;
 279
 280     len &= ~(size_t)0xf;
 281     if (len) {
 282         s390x_kmo(in, len, out, dat->plat.s390x.fc,
 283                   &dat->plat.s390x.param.kmo_kmf);
 284
 285         out += len;
 286         in += len;
 287     }
 288
 289     if (rem) {
 290         s390x_km(dat->plat.s390x.param.kmo_kmf.cv, 16,
 291                  dat->plat.s390x.param.kmo_kmf.cv, dat->plat.s390x.fc,
 292                  dat->plat.s390x.param.kmo_kmf.k);
 293
 294         while (rem--) {
 295             out[n] = in[n] ^ dat->plat.s390x.param.kmo_kmf.cv[n];
 296             ++n;
 297         }
 298     }
 299
 300     dat->plat.s390x.res = n;
 301     return 1;
 302 }
 303
 304 static int s390x_aes_cfb_init_key(PROV_AES_KEY *dat, const unsigned char *key,
 305                                   size_t keylen)
 306 {
 307     dat->plat.s390x.fc = S390X_AES_FC(keylen);
 308     dat->plat.s390x.fc |= 16 << 24;   /* 16 bytes cipher feedback */
 309     if (!dat->enc)
 310         dat->plat.s390x.fc |= S390X_DECRYPT;
 311
 312     dat->plat.s390x.res = 0;
 313     memcpy(dat->plat.s390x.param.kmo_kmf.cv, dat->iv, AES_BLOCK_SIZE);
 314     memcpy(dat->plat.s390x.param.kmo_kmf.k, key, keylen);
 315     return 1;
 316 }
 317
 318 static int s390x_aes_cfb_cipher(PROV_AES_KEY *dat, unsigned char *out,
 319                                 const unsigned char *in, size_t len)
 320 {
 321     int n = dat->plat.s390x.res;
 322     int rem;
 323     unsigned char tmp;
 324
 325     while (n && len) {
 326         tmp = *in;
 327         *out = dat->plat.s390x.param.kmo_kmf.cv[n] ^ tmp;
 328         dat->plat.s390x.param.kmo_kmf.cv[n] = dat->enc ? *out : tmp;
 329         n = (n + 1) & 0xf;
 330         --len;
 331         ++in;
 332         ++out;
 333     }
 334
 335     rem = len & 0xf;
 336
 337     len &= ~(size_t)0xf;
 338     if (len) {
 339         s390x_kmf(in, len, out, dat->plat.s390x.fc,
 340                   &dat->plat.s390x.param.kmo_kmf);
 341
 342         out += len;
 343         in += len;
 344     }
 345
 346     if (rem) {
 347         s390x_km(dat->plat.s390x.param.kmo_kmf.cv, 16,
 348                  dat->plat.s390x.param.kmo_kmf.cv,
 349                  S390X_AES_FC(dat->keylen), dat->plat.s390x.param.kmo_kmf.k);
 350
 351         while (rem--) {
 352             tmp = in[n];
 353             out[n] = dat->plat.s390x.param.kmo_kmf.cv[n] ^ tmp;
 354             dat->plat.s390x.param.kmo_kmf.cv[n] = dat->enc ? out[n] : tmp;
 355             ++n;
 356         }
 357     }
 358
 359     dat->plat.s390x.res = n;
 360     return 1;
 361 }
 362
 363 static int s390x_aes_cfb8_init_key(PROV_AES_KEY *dat, const unsigned char *key,
 364                                   size_t keylen)
 365 {
 366     dat->plat.s390x.fc = S390X_AES_FC(keylen);
 367     dat->plat.s390x.fc |= 1 << 24;   /* 1 byte cipher feedback */
 368     if (!dat->enc)
 369         dat->plat.s390x.fc |= S390X_DECRYPT;
 370
 371     memcpy(dat->plat.s390x.param.kmo_kmf.cv, dat->iv, AES_BLOCK_SIZE);
 372     memcpy(dat->plat.s390x.param.kmo_kmf.k, key, keylen);
 373     return 1;
 374 }
 375
 376 static int s390x_aes_cfb8_cipher(PROV_AES_KEY *dat, unsigned char *out,
 377                                  const unsigned char *in, size_t len)
 378 {
 379     s390x_kmf(in, len, out, dat->plat.s390x.fc,
 380               &dat->plat.s390x.param.kmo_kmf);
 381     return 1;
 382 }
 383
 384 # define s390x_aes_cfb1_init_key aes_init_key
 385
 386 # define s390x_aes_cfb1_cipher aes_cfb1_cipher
 387 static int s390x_aes_cfb1_cipher(PROV_AES_KEY *dat, unsigned char *out,
 388                                  const unsigned char *in, size_t len);
 389 # define S390X_AES_CTR_CTX          PROV_AES_KEY
 390
 391 # define s390x_aes_ctr_init_key aes_init_key
 392
 393 # define s390x_aes_ctr_cipher aes_ctr_cipher
 394 static int s390x_aes_ctr_cipher(PROV_AES_KEY *dat, unsigned char *out,
 395                                 const unsigned char *in, size_t len);
 396
 397 # define BLOCK_CIPHER_generic_prov(mode) \
 398 static const PROV_AES_CIPHER s390x_aes_##mode = { \
 399         s390x_aes_##mode##_init_key,    \
 400         s390x_aes_##mode##_cipher       \
 401 };  \
 402 static const PROV_AES_CIPHER aes_##mode = { \
 403         aes_init_key,           \
 404         aes_##mode##_cipher     \
 405 }; \
 406 const PROV_AES_CIPHER *PROV_AES_CIPHER_##mode(size_t keylen) \
 407 {   \
 408     if ((keylen == 16 && S390X_aes_128_##mode##_CAPABLE)           \
 409             || (keylen == 24 && S390X_aes_192_##mode##_CAPABLE)    \
 410             || (keylen == 32 && S390X_aes_256_##mode##_CAPABLE))   \
 411         return &s390x_aes_##mode;   \
 412     \
 413     return &aes_##mode; \
 414 }
 415
 416 #else
 417 /* The generic case */
 418 # define BLOCK_CIPHER_generic_prov(mode) \
 419 static const PROV_AES_CIPHER aes_##mode = { \
 420         aes_init_key,                   \
 421         aes_##mode##_cipher}; \
 422 const PROV_AES_CIPHER *PROV_AES_CIPHER_##mode(size_t keylen) \
 423 { return &aes_##mode; }
 424
 425 #endif
 426
 427 static int aes_init_key(PROV_AES_KEY *dat, const unsigned char *key,
 428                         size_t keylen)
 429 {
 430     int ret;
 431
 432     if ((dat->mode == EVP_CIPH_ECB_MODE || dat->mode == EVP_CIPH_CBC_MODE)
 433         && !dat->enc) {
 434 #ifdef HWAES_CAPABLE
 435         if (HWAES_CAPABLE) {
 436             ret = HWAES_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
 437             dat->block = (block128_f)HWAES_decrypt;
 438             dat->stream.cbc = NULL;
 439 # ifdef HWAES_cbc_encrypt
 440             if (dat->mode == EVP_CIPH_CBC_MODE)
 441                 dat->stream.cbc = (cbc128_f)HWAES_cbc_encrypt;
 442 # endif
 443         } else
 444 #endif
 445 #ifdef BSAES_CAPABLE
 446         if (BSAES_CAPABLE && dat->mode == EVP_CIPH_CBC_MODE) {
 447             ret = AES_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
 448             dat->block = (block128_f)AES_decrypt;
 449             dat->stream.cbc = (cbc128_f)bsaes_cbc_encrypt;
 450         } else
 451 #endif
 452 #ifdef VPAES_CAPABLE
 453         if (VPAES_CAPABLE) {
 454             ret = vpaes_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
 455             dat->block = (block128_f)vpaes_decrypt;
 456             dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
 457                               ?(cbc128_f)vpaes_cbc_encrypt : NULL;
 458         } else
 459 #endif
 460         {
 461             ret = AES_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
 462             dat->block = (block128_f)AES_decrypt;
 463             dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
 464                               ? (cbc128_f)AES_cbc_encrypt : NULL;
 465         }
 466     } else
 467 #ifdef HWAES_CAPABLE
 468     if (HWAES_CAPABLE) {
 469         ret = HWAES_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
 470         dat->block = (block128_f)HWAES_encrypt;
 471         dat->stream.cbc = NULL;
 472 # ifdef HWAES_cbc_encrypt
 473         if (dat->mode == EVP_CIPH_CBC_MODE)
 474             dat->stream.cbc = (cbc128_f)HWAES_cbc_encrypt;
 475         else
 476 # endif
 477 # ifdef HWAES_ctr32_encrypt_blocks
 478         if (dat->mode == EVP_CIPH_CTR_MODE)
 479             dat->stream.ctr = (ctr128_f)HWAES_ctr32_encrypt_blocks;
 480         else
 481 # endif
 482             (void)0;            /* terminate potentially open 'else' */
 483     } else
 484 #endif
 485 #ifdef BSAES_CAPABLE
 486     if (BSAES_CAPABLE && dat->mode == EVP_CIPH_CTR_MODE) {
 487         ret = AES_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
 488         dat->block = (block128_f)AES_encrypt;
 489         dat->stream.ctr = (ctr128_f)bsaes_ctr32_encrypt_blocks;
 490     } else
 491 #endif
 492 #ifdef VPAES_CAPABLE
 493     if (VPAES_CAPABLE) {
 494         ret = vpaes_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
 495         dat->block = (block128_f)vpaes_encrypt;
 496         dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
 497                           ? (cbc128_f)vpaes_cbc_encrypt : NULL;
 498     } else
 499 #endif
 500     {
 501         ret = AES_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
 502         dat->block = (block128_f)AES_encrypt;
 503         dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
 504                           ? (cbc128_f)AES_cbc_encrypt : NULL;
 505 #ifdef AES_CTR_ASM
 506         if (dat->mode == EVP_CIPH_CTR_MODE)
 507             dat->stream.ctr = (ctr128_f)AES_ctr32_encrypt;
 508 #endif
 509     }
 510
 511     if (ret < 0) {
 512         PROVerr(PROV_F_AES_INIT_KEY, PROV_R_AES_KEY_SETUP_FAILED);
 513         return 0;
 514     }
 515
 516     return 1;
 517 }
 518
 519 static int aes_cbc_cipher(PROV_AES_KEY *dat, unsigned char *out,
 520                           const unsigned char *in, size_t len)
 521 {
 522     if (dat->stream.cbc)
 523         (*dat->stream.cbc) (in, out, len, &dat->ks, dat->iv, dat->enc);
 524     else if (dat->enc)
 525         CRYPTO_cbc128_encrypt(in, out, len, &dat->ks, dat->iv, dat->block);
 526     else
 527         CRYPTO_cbc128_decrypt(in, out, len, &dat->ks, dat->iv, dat->block);
 528
 529     return 1;
 530 }
 531
 532 static int aes_ecb_cipher(PROV_AES_KEY *dat, unsigned char *out,
 533                           const unsigned char *in, size_t len)
 534 {
 535     size_t i;
 536
 537     if (len < AES_BLOCK_SIZE)
 538         return 1;
 539
 540     for (i = 0, len -= AES_BLOCK_SIZE; i <= len; i += AES_BLOCK_SIZE)
 541         (*dat->block) (in + i, out + i, &dat->ks);
 542
 543     return 1;
 544 }
 545
 546 static int aes_ofb_cipher(PROV_AES_KEY *dat, unsigned char *out,
 547                           const unsigned char *in, size_t len)
 548 {
 549     int num = dat->num;
 550     CRYPTO_ofb128_encrypt(in, out, len, &dat->ks, dat->iv, &num, dat->block);
 551     dat->num = num;
 552
 553     return 1;
 554 }
 555
 556 static int aes_cfb_cipher(PROV_AES_KEY *dat, unsigned char *out,
 557                           const unsigned char *in, size_t len)
 558 {
 559     int num = dat->num;
 560     CRYPTO_cfb128_encrypt(in, out, len, &dat->ks, dat->iv, &num, dat->enc,
 561                           dat->block);
 562     dat->num = num;
 563
 564     return 1;
 565 }
 566
 567 static int aes_cfb8_cipher(PROV_AES_KEY *dat, unsigned char *out,
 568                            const unsigned char *in, size_t len)
 569 {
 570     int num = dat->num;
 571     CRYPTO_cfb128_8_encrypt(in, out, len, &dat->ks, dat->iv, &num, dat->enc,
 572                             dat->block);
 573     dat->num = num;
 574
 575     return 1;
 576 }
 577
 578 static int aes_cfb1_cipher(PROV_AES_KEY *dat, unsigned char *out,
 579                            const unsigned char *in, size_t len)
 580 {
 581     int num = dat->num;
 582
 583     if ((dat->flags & EVP_CIPH_FLAG_LENGTH_BITS) != 0) {
 584         CRYPTO_cfb128_1_encrypt(in, out, len, &dat->ks, dat->iv, &num,
 585                                 dat->enc, dat->block);
 586         dat->num = num;
 587         return 1;
 588     }
 589
 590     while (len >= MAXBITCHUNK) {
 591         CRYPTO_cfb128_1_encrypt(in, out, MAXBITCHUNK * 8, &dat->ks,
 592                                 dat->iv, &num, dat->enc, dat->block);
 593         len -= MAXBITCHUNK;
 594         out += MAXBITCHUNK;
 595         in  += MAXBITCHUNK;
 596     }
 597     if (len)
 598         CRYPTO_cfb128_1_encrypt(in, out, len * 8, &dat->ks, dat->iv, &num,
 599                                 dat->enc, dat->block);
 600
 601     dat->num = num;
 602
 603     return 1;
 604 }
 605
 606 static int aes_ctr_cipher(PROV_AES_KEY *dat, unsigned char *out,
 607                           const unsigned char *in, size_t len)
 608 {
 609     unsigned int num = dat->num;
 610
 611     if (dat->stream.ctr)
 612         CRYPTO_ctr128_encrypt_ctr32(in, out, len, &dat->ks, dat->iv, dat->buf,
 613                                     &num, dat->stream.ctr);
 614     else
 615         CRYPTO_ctr128_encrypt(in, out, len, &dat->ks, dat->iv, dat->buf,
 616                               &num, dat->block);
 617     dat->num = num;
 618
 619     return 1;
 620 }
 621
 622 BLOCK_CIPHER_generic_prov(cbc)
 623 BLOCK_CIPHER_generic_prov(ecb)
 624 BLOCK_CIPHER_generic_prov(ofb)
 625 BLOCK_CIPHER_generic_prov(cfb)
 626 BLOCK_CIPHER_generic_prov(cfb1)
 627 BLOCK_CIPHER_generic_prov(cfb8)
 628 BLOCK_CIPHER_generic_prov(ctr)
 629