Implement support for AES-256-ECB in the default provider
[openssl.git] / 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