e46762212c46a92946b27e3b5af7679d4a0b151a
[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(size_t keylen) \
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(size_t keylen) \
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 /* Convert key size to function code: [16,24,32] -> [18,19,20]. */
372 # define S390X_AES_FC(keylen)  (S390X_AES_128 + ((((keylen) << 3) - 128) >> 6))
373
374 /* Most modes of operation need km for partial block processing. */
375 # define S390X_aes_128_CAPABLE (OPENSSL_s390xcap_P.km[0] &      \
376                                 S390X_CAPBIT(S390X_AES_128))
377 # define S390X_aes_192_CAPABLE (OPENSSL_s390xcap_P.km[0] &      \
378                                 S390X_CAPBIT(S390X_AES_192))
379 # define S390X_aes_256_CAPABLE (OPENSSL_s390xcap_P.km[0] &      \
380                                 S390X_CAPBIT(S390X_AES_256))
381
382 # define s390x_aes_init_key aes_init_key
383 static int s390x_aes_init_key(PROV_AES_KEY *dat, const unsigned char *key,
384                               size_t keylen);
385
386 # define S390X_aes_128_cbc_CAPABLE  1   /* checked by callee */
387 # define S390X_aes_192_cbc_CAPABLE  1
388 # define S390X_aes_256_cbc_CAPABLE  1
389 # define S390X_AES_CBC_CTX          PROV_AES_KEY
390
391 # define s390x_aes_cbc_init_key aes_init_key
392
393 # define s390x_aes_cbc_cipher aes_cbc_cipher
394 static int s390x_aes_cbc_cipher(PROV_AES_KEY *dat, unsigned char *out,
395                                 const unsigned char *in, size_t len);
396
397 # define S390X_aes_128_ecb_CAPABLE  S390X_aes_128_CAPABLE
398 # define S390X_aes_192_ecb_CAPABLE  S390X_aes_192_CAPABLE
399 # define S390X_aes_256_ecb_CAPABLE  S390X_aes_256_CAPABLE
400
401 static int s390x_aes_ecb_init_key(PROV_AES_KEY *dat, const unsigned char *key,
402                                   size_t keylen)
403 {
404     dat->plat.s390x.fc = S390X_AES_FC(keylen);
405     if (!dat->enc)
406         dat->plat.s390x.fc |= S390X_DECRYPT;
407
408     memcpy(dat->plat.s390x.param.km.k, key, keylen);
409     return 1;
410 }
411
412 static int s390x_aes_ecb_cipher(PROV_AES_KEY *dat, unsigned char *out,
413                                 const unsigned char *in, size_t len)
414 {
415     s390x_km(in, len, out, dat->plat.s390x.fc,
416              &dat->plat.s390x.param.km);
417     return 1;
418 }
419
420 # define S390X_aes_128_ofb_CAPABLE (S390X_aes_128_CAPABLE &&        \
421                                     (OPENSSL_s390xcap_P.kmo[0] &    \
422                                      S390X_CAPBIT(S390X_AES_128)))
423 # define S390X_aes_192_ofb_CAPABLE (S390X_aes_192_CAPABLE &&        \
424                                     (OPENSSL_s390xcap_P.kmo[0] &    \
425                                      S390X_CAPBIT(S390X_AES_192)))
426 # define S390X_aes_256_ofb_CAPABLE (S390X_aes_256_CAPABLE &&        \
427                                     (OPENSSL_s390xcap_P.kmo[0] &    \
428                                      S390X_CAPBIT(S390X_AES_256)))
429
430 static int s390x_aes_ofb_init_key(PROV_AES_KEY *dat, const unsigned char *key,
431                                   size_t keylen)
432 {
433     memcpy(dat->plat.s390x.param.kmo_kmf.cv, dat->iv, AES_BLOCK_SIZE);
434     memcpy(dat->plat.s390x.param.kmo_kmf.k, key, keylen);
435     dat->plat.s390x.fc = S390X_AES_FC(keylen);
436     dat->plat.s390x.res = 0;
437     return 1;
438 }
439
440 static int s390x_aes_ofb_cipher(PROV_AES_KEY *dat, unsigned char *out,
441                                 const unsigned char *in, size_t len)
442 {
443     int n = dat->plat.s390x.res;
444     int rem;
445
446     while (n && len) {
447         *out = *in ^ dat->plat.s390x.param.kmo_kmf.cv[n];
448         n = (n + 1) & 0xf;
449         --len;
450         ++in;
451         ++out;
452     }
453
454     rem = len & 0xf;
455
456     len &= ~(size_t)0xf;
457     if (len) {
458         s390x_kmo(in, len, out, dat->plat.s390x.fc,
459                   &dat->plat.s390x.param.kmo_kmf);
460
461         out += len;
462         in += len;
463     }
464
465     if (rem) {
466         s390x_km(dat->plat.s390x.param.kmo_kmf.cv, 16,
467                  dat->plat.s390x.param.kmo_kmf.cv, dat->plat.s390x.fc,
468                  dat->plat.s390x.param.kmo_kmf.k);
469
470         while (rem--) {
471             out[n] = in[n] ^ dat->plat.s390x.param.kmo_kmf.cv[n];
472             ++n;
473         }
474     }
475
476     dat->plat.s390x.res = n;
477     return 1;
478 }
479
480 # define S390X_aes_128_cfb_CAPABLE (S390X_aes_128_CAPABLE &&        \
481                                     (OPENSSL_s390xcap_P.kmf[0] &    \
482                                      S390X_CAPBIT(S390X_AES_128)))
483 # define S390X_aes_192_cfb_CAPABLE (S390X_aes_192_CAPABLE &&        \
484                                     (OPENSSL_s390xcap_P.kmf[0] &    \
485                                      S390X_CAPBIT(S390X_AES_192)))
486 # define S390X_aes_256_cfb_CAPABLE (S390X_aes_256_CAPABLE &&        \
487                                     (OPENSSL_s390xcap_P.kmf[0] &    \
488                                      S390X_CAPBIT(S390X_AES_256)))
489
490 static int s390x_aes_cfb_init_key(PROV_AES_KEY *dat, const unsigned char *key,
491                                   size_t keylen)
492 {
493     dat->plat.s390x.fc = S390X_AES_FC(keylen);
494     dat->plat.s390x.fc |= 16 << 24;   /* 16 bytes cipher feedback */
495     if (!dat->enc)
496         dat->plat.s390x.fc |= S390X_DECRYPT;
497
498     dat->plat.s390x.res = 0;
499     memcpy(dat->plat.s390x.param.kmo_kmf.cv, dat->iv, AES_BLOCK_SIZE);
500     memcpy(dat->plat.s390x.param.kmo_kmf.k, key, keylen);
501     return 1;
502 }
503
504 static int s390x_aes_cfb_cipher(PROV_AES_KEY *dat, unsigned char *out,
505                                 const unsigned char *in, size_t len)
506 {
507     int n = dat->plat.s390x.res;
508     int rem;
509     unsigned char tmp;
510
511     while (n && len) {
512         tmp = *in;
513         *out = dat->plat.s390x.param.kmo_kmf.cv[n] ^ tmp;
514         dat->plat.s390x.param.kmo_kmf.cv[n] = dat->enc ? *out : tmp;
515         n = (n + 1) & 0xf;
516         --len;
517         ++in;
518         ++out;
519     }
520
521     rem = len & 0xf;
522
523     len &= ~(size_t)0xf;
524     if (len) {
525         s390x_kmf(in, len, out, dat->plat.s390x.fc,
526                   &dat->plat.s390x.param.kmo_kmf);
527
528         out += len;
529         in += len;
530     }
531
532     if (rem) {
533         s390x_km(dat->plat.s390x.param.kmo_kmf.cv, 16,
534                  dat->plat.s390x.param.kmo_kmf.cv,
535                  S390X_AES_FC(dat->keylen), dat->plat.s390x.param.kmo_kmf.k);
536
537         while (rem--) {
538             tmp = in[n];
539             out[n] = dat->plat.s390x.param.kmo_kmf.cv[n] ^ tmp;
540             dat->plat.s390x.param.kmo_kmf.cv[n] = dat->enc ? out[n] : tmp;
541             ++n;
542         }
543     }
544
545     dat->plat.s390x.res = n;
546     return 1;
547 }
548
549 # define S390X_aes_128_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] &    \
550                                      S390X_CAPBIT(S390X_AES_128))
551 # define S390X_aes_192_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] &    \
552                                      S390X_CAPBIT(S390X_AES_192))
553 # define S390X_aes_256_cfb8_CAPABLE (OPENSSL_s390xcap_P.kmf[0] &    \
554                                      S390X_CAPBIT(S390X_AES_256))
555
556 static int s390x_aes_cfb8_init_key(PROV_AES_KEY *dat, const unsigned char *key,
557                                   size_t keylen)
558 {
559     dat->plat.s390x.fc = S390X_AES_FC(keylen);
560     dat->plat.s390x.fc |= 1 << 24;   /* 1 byte cipher feedback */
561     if (!dat->enc)
562         dat->plat.s390x.fc |= S390X_DECRYPT;
563
564     memcpy(dat->plat.s390x.param.kmo_kmf.cv, dat->iv, AES_BLOCK_SIZE);
565     memcpy(dat->plat.s390x.param.kmo_kmf.k, key, keylen);
566     return 1;
567 }
568
569 static int s390x_aes_cfb8_cipher(PROV_AES_KEY *dat, unsigned char *out,
570                                  const unsigned char *in, size_t len)
571 {
572     s390x_kmf(in, len, out, dat->plat.s390x.fc,
573               &dat->plat.s390x.param.kmo_kmf);
574     return 1;
575 }
576
577 # define S390X_aes_128_cfb1_CAPABLE 0
578 # define S390X_aes_192_cfb1_CAPABLE 0
579 # define S390X_aes_256_cfb1_CAPABLE 0
580
581 # define s390x_aes_cfb1_init_key aes_init_key
582
583 # define s390x_aes_cfb1_cipher aes_cfb1_cipher
584 static int s390x_aes_cfb1_cipher(PROV_AES_KEY *dat, unsigned char *out,
585                                  const unsigned char *in, size_t len);
586
587 # define S390X_aes_128_ctr_CAPABLE  1   /* checked by callee */
588 # define S390X_aes_192_ctr_CAPABLE  1
589 # define S390X_aes_256_ctr_CAPABLE  1
590 # define S390X_AES_CTR_CTX          PROV_AES_KEY
591
592 # define s390x_aes_ctr_init_key aes_init_key
593
594 # define s390x_aes_ctr_cipher aes_ctr_cipher
595 static int s390x_aes_ctr_cipher(PROV_AES_KEY *dat, unsigned char *out,
596                                 const unsigned char *in, size_t len);
597
598 # define BLOCK_CIPHER_generic_prov(mode) \
599 static const PROV_AES_CIPHER s390x_aes_##mode = { \
600         s390x_aes_##mode##_init_key,    \
601         s390x_aes_##mode##_cipher       \
602 };  \
603 static const PROV_AES_CIPHER aes_##mode = { \
604         aes_init_key,           \
605         aes_##mode##_cipher     \
606 }; \
607 const PROV_AES_CIPHER *PROV_AES_CIPHER_##mode(size_t keylen) \
608 {   \
609     if ((keylen == 128 && S390X_aes_128_##mode##_CAPABLE)           \
610             || (keylen == 192 && S390X_aes_192_##mode##_CAPABLE)    \
611             || (keylen == 256 && S390X_aes_256_##mode##_CAPABLE))   \
612         return &s390x_aes_##mode;   \
613     \
614     return &aes_##mode; \
615 }
616
617 #else
618
619 # define BLOCK_CIPHER_generic_prov(mode) \
620 static const PROV_AES_CIPHER aes_##mode = { \
621         aes_init_key,                   \
622         aes_##mode##_cipher}; \
623 const PROV_AES_CIPHER *PROV_AES_CIPHER_##mode(size_t keylen) \
624 { return &aes_##mode; }
625
626 #endif
627
628 #if defined(OPENSSL_CPUID_OBJ) && (defined(__arm__) || defined(__arm) || defined(__aarch64__))
629 # include "arm_arch.h"
630 # if __ARM_MAX_ARCH__>=7
631 #  if defined(BSAES_ASM)
632 #   define BSAES_CAPABLE (OPENSSL_armcap_P & ARMV7_NEON)
633 #  endif
634 #  if defined(VPAES_ASM)
635 #   define VPAES_CAPABLE (OPENSSL_armcap_P & ARMV7_NEON)
636 #  endif
637 #  define HWAES_CAPABLE (OPENSSL_armcap_P & ARMV8_AES)
638 #  define HWAES_set_encrypt_key aes_v8_set_encrypt_key
639 #  define HWAES_set_decrypt_key aes_v8_set_decrypt_key
640 #  define HWAES_encrypt aes_v8_encrypt
641 #  define HWAES_decrypt aes_v8_decrypt
642 #  define HWAES_cbc_encrypt aes_v8_cbc_encrypt
643 #  define HWAES_ctr32_encrypt_blocks aes_v8_ctr32_encrypt_blocks
644 # endif
645 #endif
646
647 #if defined(HWAES_CAPABLE)
648 int HWAES_set_encrypt_key(const unsigned char *userKey, const int bits,
649                           AES_KEY *key);
650 int HWAES_set_decrypt_key(const unsigned char *userKey, const int bits,
651                           AES_KEY *key);
652 void HWAES_encrypt(const unsigned char *in, unsigned char *out,
653                    const AES_KEY *key);
654 void HWAES_decrypt(const unsigned char *in, unsigned char *out,
655                    const AES_KEY *key);
656 void HWAES_cbc_encrypt(const unsigned char *in, unsigned char *out,
657                        size_t length, const AES_KEY *key,
658                        unsigned char *ivec, const int enc);
659 void HWAES_ctr32_encrypt_blocks(const unsigned char *in, unsigned char *out,
660                                 size_t len, const AES_KEY *key,
661                                 const unsigned char ivec[16]);
662 #endif
663
664 static int aes_init_key(PROV_AES_KEY *dat, const unsigned char *key,
665                         size_t keylen)
666 {
667     int ret;
668
669     if ((dat->mode == EVP_CIPH_ECB_MODE || dat->mode == EVP_CIPH_CBC_MODE)
670         && !dat->enc) {
671 #ifdef HWAES_CAPABLE
672         if (HWAES_CAPABLE) {
673             ret = HWAES_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
674             dat->block = (block128_f)HWAES_decrypt;
675             dat->stream.cbc = NULL;
676 # ifdef HWAES_cbc_encrypt
677             if (dat->mode == EVP_CIPH_CBC_MODE)
678                 dat->stream.cbc = (cbc128_f)HWAES_cbc_encrypt;
679 # endif
680         } else
681 #endif
682 #ifdef BSAES_CAPABLE
683         if (BSAES_CAPABLE && dat->mode == EVP_CIPH_CBC_MODE) {
684             ret = AES_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
685             dat->block = (block128_f)AES_decrypt;
686             dat->stream.cbc = (cbc128_f)bsaes_cbc_encrypt;
687         } else
688 #endif
689 #ifdef VPAES_CAPABLE
690         if (VPAES_CAPABLE) {
691             ret = vpaes_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
692             dat->block = (block128_f)vpaes_decrypt;
693             dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
694                               ?(cbc128_f)vpaes_cbc_encrypt : NULL;
695         } else
696 #endif
697         {
698             ret = AES_set_decrypt_key(key, keylen * 8, &dat->ks.ks);
699             dat->block = (block128_f)AES_decrypt;
700             dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
701                               ? (cbc128_f)AES_cbc_encrypt : NULL;
702         }
703     } else
704 #ifdef HWAES_CAPABLE
705     if (HWAES_CAPABLE) {
706         ret = HWAES_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
707         dat->block = (block128_f)HWAES_encrypt;
708         dat->stream.cbc = NULL;
709 # ifdef HWAES_cbc_encrypt
710         if (dat->mode == EVP_CIPH_CBC_MODE)
711             dat->stream.cbc = (cbc128_f)HWAES_cbc_encrypt;
712         else
713 # endif
714 # ifdef HWAES_ctr32_encrypt_blocks
715         if (dat->mode == EVP_CIPH_CTR_MODE)
716             dat->stream.ctr = (ctr128_f)HWAES_ctr32_encrypt_blocks;
717         else
718 # endif
719             (void)0;            /* terminate potentially open 'else' */
720     } else
721 #endif
722 #ifdef BSAES_CAPABLE
723     if (BSAES_CAPABLE && dat->mode == EVP_CIPH_CTR_MODE) {
724         ret = AES_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
725         dat->block = (block128_f)AES_encrypt;
726         dat->stream.ctr = (ctr128_f)bsaes_ctr32_encrypt_blocks;
727     } else
728 #endif
729 #ifdef VPAES_CAPABLE
730     if (VPAES_CAPABLE) {
731         ret = vpaes_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
732         dat->block = (block128_f)vpaes_encrypt;
733         dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
734                           ? (cbc128_f)vpaes_cbc_encrypt : NULL;
735     } else
736 #endif
737     {
738         ret = AES_set_encrypt_key(key, keylen * 8, &dat->ks.ks);
739         dat->block = (block128_f)AES_encrypt;
740         dat->stream.cbc = (dat->mode == EVP_CIPH_CBC_MODE)
741                           ? (cbc128_f)AES_cbc_encrypt : NULL;
742 #ifdef AES_CTR_ASM
743         if (dat->mode == EVP_CIPH_CTR_MODE)
744             dat->stream.ctr = (ctr128_f)AES_ctr32_encrypt;
745 #endif
746     }
747
748     if (ret < 0) {
749         EVPerr(EVP_F_AES_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
750         return 0;
751     }
752
753     return 1;
754 }
755
756 static int aes_cbc_cipher(PROV_AES_KEY *dat, unsigned char *out,
757                           const unsigned char *in, size_t len)
758 {
759     if (dat->stream.cbc)
760         (*dat->stream.cbc) (in, out, len, &dat->ks, dat->iv, dat->enc);
761     else if (dat->enc)
762         CRYPTO_cbc128_encrypt(in, out, len, &dat->ks, dat->iv, dat->block);
763     else
764         CRYPTO_cbc128_decrypt(in, out, len, &dat->ks, dat->iv, dat->block);
765
766     return 1;
767 }
768
769 static int aes_ecb_cipher(PROV_AES_KEY *dat, unsigned char *out,
770                           const unsigned char *in, size_t len)
771 {
772     size_t i;
773
774     if (len < AES_BLOCK_SIZE)
775         return 1;
776
777     for (i = 0, len -= AES_BLOCK_SIZE; i <= len; i += AES_BLOCK_SIZE)
778         (*dat->block) (in + i, out + i, &dat->ks);
779
780     return 1;
781 }
782
783 static int aes_ofb_cipher(PROV_AES_KEY *dat, unsigned char *out,
784                           const unsigned char *in, size_t len)
785 {
786     int num = dat->num;
787     CRYPTO_ofb128_encrypt(in, out, len, &dat->ks, dat->iv, &num, dat->block);
788     dat->num = num;
789
790     return 1;
791 }
792
793 static int aes_cfb_cipher(PROV_AES_KEY *dat, unsigned char *out,
794                           const unsigned char *in, size_t len)
795 {
796     int num = dat->num;
797     CRYPTO_cfb128_encrypt(in, out, len, &dat->ks, dat->iv, &num, dat->enc,
798                           dat->block);
799     dat->num = num;
800
801     return 1;
802 }
803
804 static int aes_cfb8_cipher(PROV_AES_KEY *dat, unsigned char *out,
805                            const unsigned char *in, size_t len)
806 {
807     int num = dat->num;
808     CRYPTO_cfb128_8_encrypt(in, out, len, &dat->ks, dat->iv, &num, dat->enc,
809                             dat->block);
810     dat->num = num;
811
812     return 1;
813 }
814
815 static int aes_cfb1_cipher(PROV_AES_KEY *dat, unsigned char *out,
816                            const unsigned char *in, size_t len)
817 {
818     int num = dat->num;
819
820     if ((dat->flags & EVP_CIPH_FLAG_LENGTH_BITS) != 0) {
821         CRYPTO_cfb128_1_encrypt(in, out, len, &dat->ks, dat->iv, &num,
822                                 dat->enc, dat->block);
823         dat->num = num;
824         return 1;
825     }
826
827     while (len >= MAXBITCHUNK) {
828         CRYPTO_cfb128_1_encrypt(in, out, MAXBITCHUNK * 8, &dat->ks,
829                                 dat->iv, &num, dat->enc, dat->block);
830         len -= MAXBITCHUNK;
831         out += MAXBITCHUNK;
832         in  += MAXBITCHUNK;
833     }
834     if (len)
835         CRYPTO_cfb128_1_encrypt(in, out, len * 8, &dat->ks, dat->iv, &num,
836                                 dat->enc, dat->block);
837
838     dat->num = num;
839
840     return 1;
841 }
842
843 static int aes_ctr_cipher(PROV_AES_KEY *dat, unsigned char *out,
844                           const unsigned char *in, size_t len)
845 {
846     unsigned int num = dat->num;
847
848     if (dat->stream.ctr)
849         CRYPTO_ctr128_encrypt_ctr32(in, out, len, &dat->ks, dat->iv, dat->buf,
850                                     &num, dat->stream.ctr);
851     else
852         CRYPTO_ctr128_encrypt(in, out, len, &dat->ks, dat->iv, dat->buf,
853                               &num, dat->block);
854     dat->num = num;
855
856     return 1;
857 }
858
859 BLOCK_CIPHER_generic_prov(cbc)
860 BLOCK_CIPHER_generic_prov(ecb)
861 BLOCK_CIPHER_generic_prov(ofb)
862 BLOCK_CIPHER_generic_prov(cfb)
863 BLOCK_CIPHER_generic_prov(cfb1)
864 BLOCK_CIPHER_generic_prov(cfb8)
865 BLOCK_CIPHER_generic_prov(ctr)
866