Add gcm ciphers (aes and aria) to providers.
[openssl.git] / 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