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