← Back to branch summary

~mmach/netext73/isl

« back to all changes in this revision

Viewing changes to crypto/evp/e_aes.c

  • Committer: mmach
  • Date: 2019-05-14 07:37:06 UTC
  • Revision ID: netbit73@gmail.com-20190514073706-nt6iq2m3597se19c
0.21

Show diffs side-by-side

added added

removed removed

Lines of Context:
crypto/evp/e_aes.c
 
1
/* ====================================================================
 
2
 * Copyright (c) 2001-2011 The OpenSSL Project.  All rights reserved.
 
3
 *
 
4
 * Redistribution and use in source and binary forms, with or without
 
5
 * modification, are permitted provided that the following conditions
 
6
 * are met:
 
7
 *
 
8
 * 1. Redistributions of source code must retain the above copyright
 
9
 *    notice, this list of conditions and the following disclaimer.
 
10
 *
 
11
 * 2. Redistributions in binary form must reproduce the above copyright
 
12
 *    notice, this list of conditions and the following disclaimer in
 
13
 *    the documentation and/or other materials provided with the
 
14
 *    distribution.
 
15
 *
 
16
 * 3. All advertising materials mentioning features or use of this
 
17
 *    software must display the following acknowledgment:
 
18
 *    "This product includes software developed by the OpenSSL Project
 
19
 *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
 
20
 *
 
21
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 
22
 *    endorse or promote products derived from this software without
 
23
 *    prior written permission. For written permission, please contact
 
24
 *    openssl-core@openssl.org.
 
25
 *
 
26
 * 5. Products derived from this software may not be called "OpenSSL"
 
27
 *    nor may "OpenSSL" appear in their names without prior written
 
28
 *    permission of the OpenSSL Project.
 
29
 *
 
30
 * 6. Redistributions of any form whatsoever must retain the following
 
31
 *    acknowledgment:
 
32
 *    "This product includes software developed by the OpenSSL Project
 
33
 *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
 
34
 *
 
35
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 
36
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
37
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
38
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 
39
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
40
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
41
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 
42
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
43
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 
44
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 
45
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 
46
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 
47
 * ====================================================================
 
48
 *
 
49
 */
 
50
 
 
51
#include <openssl/opensslconf.h>
 
52
#ifndef OPENSSL_NO_AES
 
53
#include <openssl/crypto.h>
 
54
# include <openssl/evp.h>
 
55
# include <openssl/err.h>
 
56
# include <string.h>
 
57
# include <assert.h>
 
58
# include <openssl/aes.h>
 
59
# include "evp_locl.h"
 
60
# include "modes_lcl.h"
 
61
# include <openssl/rand.h>
 
62
 
 
63
# undef EVP_CIPH_FLAG_FIPS
 
64
# define EVP_CIPH_FLAG_FIPS 0
 
65
 
 
66
typedef struct {
 
67
    union {
 
68
        double align;
 
69
        AES_KEY ks;
 
70
    } ks;
 
71
    block128_f block;
 
72
    union {
 
73
        cbc128_f cbc;
 
74
        ctr128_f ctr;
 
75
    } stream;
 
76
} EVP_AES_KEY;
 
77
 
 
78
typedef struct {
 
79
    union {
 
80
        double align;
 
81
        AES_KEY ks;
 
82
    } ks;                       /* AES key schedule to use */
 
83
    int key_set;                /* Set if key initialised */
 
84
    int iv_set;                 /* Set if an iv is set */
 
85
    GCM128_CONTEXT gcm;
 
86
    unsigned char *iv;          /* Temporary IV store */
 
87
    int ivlen;                  /* IV length */
 
88
    int taglen;
 
89
    int iv_gen;                 /* It is OK to generate IVs */
 
90
    int tls_aad_len;            /* TLS AAD length */
 
91
    ctr128_f ctr;
 
92
} EVP_AES_GCM_CTX;
 
93
 
 
94
typedef struct {
 
95
    union {
 
96
        double align;
 
97
        AES_KEY ks;
 
98
    } ks1, ks2;                 /* AES key schedules to use */
 
99
    XTS128_CONTEXT xts;
 
100
    void (*stream) (const unsigned char *in,
 
101
                    unsigned char *out, size_t length,
 
102
                    const AES_KEY *key1, const AES_KEY *key2,
 
103
                    const unsigned char iv[16]);
 
104
} EVP_AES_XTS_CTX;
 
105
 
 
106
typedef struct {
 
107
    union {
 
108
        double align;
 
109
        AES_KEY ks;
 
110
    } ks;                       /* AES key schedule to use */
 
111
    int key_set;                /* Set if key initialised */
 
112
    int iv_set;                 /* Set if an iv is set */
 
113
    int tag_set;                /* Set if tag is valid */
 
114
    int len_set;                /* Set if message length set */
 
115
    int L, M;                   /* L and M parameters from RFC3610 */
 
116
    CCM128_CONTEXT ccm;
 
117
    ccm128_f str;
 
118
} EVP_AES_CCM_CTX;
 
119
 
 
120
# define MAXBITCHUNK     ((size_t)1<<(sizeof(size_t)*8-4))
 
121
 
 
122
# ifdef VPAES_ASM
 
123
int vpaes_set_encrypt_key(const unsigned char *userKey, int bits,
 
124
                          AES_KEY *key);
 
125
int vpaes_set_decrypt_key(const unsigned char *userKey, int bits,
 
126
                          AES_KEY *key);
 
127
 
 
128
void vpaes_encrypt(const unsigned char *in, unsigned char *out,
 
129
                   const AES_KEY *key);
 
130
void vpaes_decrypt(const unsigned char *in, unsigned char *out,
 
131
                   const AES_KEY *key);
 
132
 
 
133
void vpaes_cbc_encrypt(const unsigned char *in,
 
134
                       unsigned char *out,
 
135
                       size_t length,
 
136
                       const AES_KEY *key, unsigned char *ivec, int enc);
 
137
# endif
 
138
# ifdef BSAES_ASM
 
139
void bsaes_cbc_encrypt(const unsigned char *in, unsigned char *out,
 
140
                       size_t length, const AES_KEY *key,
 
141
                       unsigned char ivec[16], int enc);
 
142
void bsaes_ctr32_encrypt_blocks(const unsigned char *in, unsigned char *out,
 
143
                                size_t len, const AES_KEY *key,
 
144
                                const unsigned char ivec[16]);
 
145
void bsaes_xts_encrypt(const unsigned char *inp, unsigned char *out,
 
146
                       size_t len, const AES_KEY *key1,
 
147
                       const AES_KEY *key2, const unsigned char iv[16]);
 
148
void bsaes_xts_decrypt(const unsigned char *inp, unsigned char *out,
 
149
                       size_t len, const AES_KEY *key1,
 
150
                       const AES_KEY *key2, const unsigned char iv[16]);
 
151
# endif
 
152
# ifdef AES_CTR_ASM
 
153
void AES_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 
154
                       size_t blocks, const AES_KEY *key,
 
155
                       const unsigned char ivec[AES_BLOCK_SIZE]);
 
156
# endif
 
157
# ifdef AES_XTS_ASM
 
158
void AES_xts_encrypt(const unsigned char *inp, unsigned char *out, size_t len,
 
159
                     const AES_KEY *key1, const AES_KEY *key2,
 
160
                     const unsigned char iv[16]);
 
161
void AES_xts_decrypt(const unsigned char *inp, unsigned char *out, size_t len,
 
162
                     const AES_KEY *key1, const AES_KEY *key2,
 
163
                     const unsigned char iv[16]);
 
164
# endif
 
165
 
 
166
# if     defined(OPENSSL_CPUID_OBJ) && (defined(__powerpc__) || defined(__ppc__) || defined(_ARCH_PPC))
 
167
#  include "ppc_arch.h"
 
168
#  ifdef VPAES_ASM
 
169
#   define VPAES_CAPABLE (OPENSSL_ppccap_P & PPC_ALTIVEC)
 
170
#  endif
 
171
#  define HWAES_CAPABLE  (OPENSSL_ppccap_P & PPC_CRYPTO207)
 
172
#  define HWAES_set_encrypt_key aes_p8_set_encrypt_key
 
173
#  define HWAES_set_decrypt_key aes_p8_set_decrypt_key
 
174
#  define HWAES_encrypt aes_p8_encrypt
 
175
#  define HWAES_decrypt aes_p8_decrypt
 
176
#  define HWAES_cbc_encrypt aes_p8_cbc_encrypt
 
177
#  define HWAES_ctr32_encrypt_blocks aes_p8_ctr32_encrypt_blocks
 
178
# endif
 
179
 
 
180
# if     defined(AES_ASM) && !defined(I386_ONLY) &&      (  \
 
181
        ((defined(__i386)       || defined(__i386__)    || \
 
182
          defined(_M_IX86)) && defined(OPENSSL_IA32_SSE2))|| \
 
183
        defined(__x86_64)       || defined(__x86_64__)  || \
 
184
        defined(_M_AMD64)       || defined(_M_X64)      || \
 
185
        defined(__INTEL__)                              )
 
186
 
 
187
extern unsigned int OPENSSL_ia32cap_P[];
 
188
 
 
189
#  ifdef VPAES_ASM
 
190
#   define VPAES_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(41-32)))
 
191
#  endif
 
192
#  ifdef BSAES_ASM
 
193
#   define BSAES_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(41-32)))
 
194
#  endif
 
195
/*
 
196
 * AES-NI section
 
197
 */
 
198
#  define AESNI_CAPABLE   (OPENSSL_ia32cap_P[1]&(1<<(57-32)))
 
199
 
 
200
int aesni_set_encrypt_key(const unsigned char *userKey, int bits,
 
201
                          AES_KEY *key);
 
202
int aesni_set_decrypt_key(const unsigned char *userKey, int bits,
 
203
                          AES_KEY *key);
 
204
 
 
205
void aesni_encrypt(const unsigned char *in, unsigned char *out,
 
206
                   const AES_KEY *key);
 
207
void aesni_decrypt(const unsigned char *in, unsigned char *out,
 
208
                   const AES_KEY *key);
 
209
 
 
210
void aesni_ecb_encrypt(const unsigned char *in,
 
211
                       unsigned char *out,
 
212
                       size_t length, const AES_KEY *key, int enc);
 
213
void aesni_cbc_encrypt(const unsigned char *in,
 
214
                       unsigned char *out,
 
215
                       size_t length,
 
216
                       const AES_KEY *key, unsigned char *ivec, int enc);
 
217
 
 
218
void aesni_ctr32_encrypt_blocks(const unsigned char *in,
 
219
                                unsigned char *out,
 
220
                                size_t blocks,
 
221
                                const void *key, const unsigned char *ivec);
 
222
 
 
223
void aesni_xts_encrypt(const unsigned char *in,
 
224
                       unsigned char *out,
 
225
                       size_t length,
 
226
                       const AES_KEY *key1, const AES_KEY *key2,
 
227
                       const unsigned char iv[16]);
 
228
 
 
229
void aesni_xts_decrypt(const unsigned char *in,
 
230
                       unsigned char *out,
 
231
                       size_t length,
 
232
                       const AES_KEY *key1, const AES_KEY *key2,
 
233
                       const unsigned char iv[16]);
 
234
 
 
235
void aesni_ccm64_encrypt_blocks(const unsigned char *in,
 
236
                                unsigned char *out,
 
237
                                size_t blocks,
 
238
                                const void *key,
 
239
                                const unsigned char ivec[16],
 
240
                                unsigned char cmac[16]);
 
241
 
 
242
void aesni_ccm64_decrypt_blocks(const unsigned char *in,
 
243
                                unsigned char *out,
 
244
                                size_t blocks,
 
245
                                const void *key,
 
246
                                const unsigned char ivec[16],
 
247
                                unsigned char cmac[16]);
 
248
 
 
249
#  if defined(__x86_64) || defined(__x86_64__) || defined(_M_AMD64) || defined(_M_X64)
 
250
size_t aesni_gcm_encrypt(const unsigned char *in,
 
251
                         unsigned char *out,
 
252
                         size_t len,
 
253
                         const void *key, unsigned char ivec[16], u64 *Xi);
 
254
#   define AES_gcm_encrypt aesni_gcm_encrypt
 
255
size_t aesni_gcm_decrypt(const unsigned char *in,
 
256
                         unsigned char *out,
 
257
                         size_t len,
 
258
                         const void *key, unsigned char ivec[16], u64 *Xi);
 
259
#   define AES_gcm_decrypt aesni_gcm_decrypt
 
260
void gcm_ghash_avx(u64 Xi[2], const u128 Htable[16], const u8 *in,
 
261
                   size_t len);
 
262
#   define AES_GCM_ASM(gctx)       (gctx->ctr==aesni_ctr32_encrypt_blocks && \
 
263
                                 gctx->gcm.ghash==gcm_ghash_avx)
 
264
#   define AES_GCM_ASM2(gctx)      (gctx->gcm.block==(block128_f)aesni_encrypt && \
 
265
                                 gctx->gcm.ghash==gcm_ghash_avx)
 
266
#   undef AES_GCM_ASM2          /* minor size optimization */
 
267
#  endif
 
268
 
 
269
static int aesni_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
270
                          const unsigned char *iv, int enc)
 
271
{
 
272
    int ret, mode;
 
273
    EVP_AES_KEY *dat = (EVP_AES_KEY *) ctx->cipher_data;
 
274
 
 
275
    mode = ctx->cipher->flags & EVP_CIPH_MODE;
 
276
    if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
 
277
        && !enc) {
 
278
        ret = aesni_set_decrypt_key(key, ctx->key_len * 8, ctx->cipher_data);
 
279
        dat->block = (block128_f) aesni_decrypt;
 
280
        dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 
281
            (cbc128_f) aesni_cbc_encrypt : NULL;
 
282
    } else {
 
283
        ret = aesni_set_encrypt_key(key, ctx->key_len * 8, ctx->cipher_data);
 
284
        dat->block = (block128_f) aesni_encrypt;
 
285
        if (mode == EVP_CIPH_CBC_MODE)
 
286
            dat->stream.cbc = (cbc128_f) aesni_cbc_encrypt;
 
287
        else if (mode == EVP_CIPH_CTR_MODE)
 
288
            dat->stream.ctr = (ctr128_f) aesni_ctr32_encrypt_blocks;
 
289
        else
 
290
            dat->stream.cbc = NULL;
 
291
    }
 
292
 
 
293
    if (ret < 0) {
 
294
        EVPerr(EVP_F_AESNI_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
 
295
        return 0;
 
296
    }
 
297
 
 
298
    return 1;
 
299
}
 
300
 
 
301
static int aesni_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
302
                            const unsigned char *in, size_t len)
 
303
{
 
304
    aesni_cbc_encrypt(in, out, len, ctx->cipher_data, ctx->iv, ctx->encrypt);
 
305
 
 
306
    return 1;
 
307
}
 
308
 
 
309
static int aesni_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
310
                            const unsigned char *in, size_t len)
 
311
{
 
312
    size_t bl = ctx->cipher->block_size;
 
313
 
 
314
    if (len < bl)
 
315
        return 1;
 
316
 
 
317
    aesni_ecb_encrypt(in, out, len, ctx->cipher_data, ctx->encrypt);
 
318
 
 
319
    return 1;
 
320
}
 
321
 
 
322
#  define aesni_ofb_cipher aes_ofb_cipher
 
323
static int aesni_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
324
                            const unsigned char *in, size_t len);
 
325
 
 
326
#  define aesni_cfb_cipher aes_cfb_cipher
 
327
static int aesni_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
328
                            const unsigned char *in, size_t len);
 
329
 
 
330
#  define aesni_cfb8_cipher aes_cfb8_cipher
 
331
static int aesni_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
332
                             const unsigned char *in, size_t len);
 
333
 
 
334
#  define aesni_cfb1_cipher aes_cfb1_cipher
 
335
static int aesni_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
336
                             const unsigned char *in, size_t len);
 
337
 
 
338
#  define aesni_ctr_cipher aes_ctr_cipher
 
339
static int aesni_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
340
                            const unsigned char *in, size_t len);
 
341
 
 
342
static int aesni_gcm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
343
                              const unsigned char *iv, int enc)
 
344
{
 
345
    EVP_AES_GCM_CTX *gctx = ctx->cipher_data;
 
346
    if (!iv && !key)
 
347
        return 1;
 
348
    if (key) {
 
349
        aesni_set_encrypt_key(key, ctx->key_len * 8, &gctx->ks.ks);
 
350
        CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks, (block128_f) aesni_encrypt);
 
351
        gctx->ctr = (ctr128_f) aesni_ctr32_encrypt_blocks;
 
352
        /*
 
353
         * If we have an iv can set it directly, otherwise use saved IV.
 
354
         */
 
355
        if (iv == NULL && gctx->iv_set)
 
356
            iv = gctx->iv;
 
357
        if (iv) {
 
358
            CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 
359
            gctx->iv_set = 1;
 
360
        }
 
361
        gctx->key_set = 1;
 
362
    } else {
 
363
        /* If key set use IV, otherwise copy */
 
364
        if (gctx->key_set)
 
365
            CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 
366
        else
 
367
            memcpy(gctx->iv, iv, gctx->ivlen);
 
368
        gctx->iv_set = 1;
 
369
        gctx->iv_gen = 0;
 
370
    }
 
371
    return 1;
 
372
}
 
373
 
 
374
#  define aesni_gcm_cipher aes_gcm_cipher
 
375
static int aesni_gcm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
376
                            const unsigned char *in, size_t len);
 
377
 
 
378
static int aesni_xts_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
379
                              const unsigned char *iv, int enc)
 
380
{
 
381
    EVP_AES_XTS_CTX *xctx = ctx->cipher_data;
 
382
    if (!iv && !key)
 
383
        return 1;
 
384
 
 
385
    if (key) {
 
386
        /* key_len is two AES keys */
 
387
        if (enc) {
 
388
            aesni_set_encrypt_key(key, ctx->key_len * 4, &xctx->ks1.ks);
 
389
            xctx->xts.block1 = (block128_f) aesni_encrypt;
 
390
            xctx->stream = aesni_xts_encrypt;
 
391
        } else {
 
392
            aesni_set_decrypt_key(key, ctx->key_len * 4, &xctx->ks1.ks);
 
393
            xctx->xts.block1 = (block128_f) aesni_decrypt;
 
394
            xctx->stream = aesni_xts_decrypt;
 
395
        }
 
396
 
 
397
        aesni_set_encrypt_key(key + ctx->key_len / 2,
 
398
                              ctx->key_len * 4, &xctx->ks2.ks);
 
399
        xctx->xts.block2 = (block128_f) aesni_encrypt;
 
400
 
 
401
        xctx->xts.key1 = &xctx->ks1;
 
402
    }
 
403
 
 
404
    if (iv) {
 
405
        xctx->xts.key2 = &xctx->ks2;
 
406
        memcpy(ctx->iv, iv, 16);
 
407
    }
 
408
 
 
409
    return 1;
 
410
}
 
411
 
 
412
#  define aesni_xts_cipher aes_xts_cipher
 
413
static int aesni_xts_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
414
                            const unsigned char *in, size_t len);
 
415
 
 
416
static int aesni_ccm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
417
                              const unsigned char *iv, int enc)
 
418
{
 
419
    EVP_AES_CCM_CTX *cctx = ctx->cipher_data;
 
420
    if (!iv && !key)
 
421
        return 1;
 
422
    if (key) {
 
423
        aesni_set_encrypt_key(key, ctx->key_len * 8, &cctx->ks.ks);
 
424
        CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
 
425
                           &cctx->ks, (block128_f) aesni_encrypt);
 
426
        cctx->str = enc ? (ccm128_f) aesni_ccm64_encrypt_blocks :
 
427
            (ccm128_f) aesni_ccm64_decrypt_blocks;
 
428
        cctx->key_set = 1;
 
429
    }
 
430
    if (iv) {
 
431
        memcpy(ctx->iv, iv, 15 - cctx->L);
 
432
        cctx->iv_set = 1;
 
433
    }
 
434
    return 1;
 
435
}
 
436
 
 
437
#  define aesni_ccm_cipher aes_ccm_cipher
 
438
static int aesni_ccm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
439
                            const unsigned char *in, size_t len);
 
440
 
 
441
#  define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \
 
442
static const EVP_CIPHER aesni_##keylen##_##mode = { \
 
443
        nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \
 
444
        flags|EVP_CIPH_##MODE##_MODE,   \
 
445
        aesni_init_key,                 \
 
446
        aesni_##mode##_cipher,          \
 
447
        NULL,                           \
 
448
        sizeof(EVP_AES_KEY),            \
 
449
        NULL,NULL,NULL,NULL }; \
 
450
static const EVP_CIPHER aes_##keylen##_##mode = { \
 
451
        nid##_##keylen##_##nmode,blocksize,     \
 
452
        keylen/8,ivlen, \
 
453
        flags|EVP_CIPH_##MODE##_MODE,   \
 
454
        aes_init_key,                   \
 
455
        aes_##mode##_cipher,            \
 
456
        NULL,                           \
 
457
        sizeof(EVP_AES_KEY),            \
 
458
        NULL,NULL,NULL,NULL }; \
 
459
const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 
460
{ return AESNI_CAPABLE?&aesni_##keylen##_##mode:&aes_##keylen##_##mode; }
 
461
 
 
462
#  define BLOCK_CIPHER_custom(nid,keylen,blocksize,ivlen,mode,MODE,flags) \
 
463
static const EVP_CIPHER aesni_##keylen##_##mode = { \
 
464
        nid##_##keylen##_##mode,blocksize, \
 
465
        (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE?2:1)*keylen/8, ivlen, \
 
466
        flags|EVP_CIPH_##MODE##_MODE,   \
 
467
        aesni_##mode##_init_key,        \
 
468
        aesni_##mode##_cipher,          \
 
469
        aes_##mode##_cleanup,           \
 
470
        sizeof(EVP_AES_##MODE##_CTX),   \
 
471
        NULL,NULL,aes_##mode##_ctrl,NULL }; \
 
472
static const EVP_CIPHER aes_##keylen##_##mode = { \
 
473
        nid##_##keylen##_##mode,blocksize, \
 
474
        (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE?2:1)*keylen/8, ivlen, \
 
475
        flags|EVP_CIPH_##MODE##_MODE,   \
 
476
        aes_##mode##_init_key,          \
 
477
        aes_##mode##_cipher,            \
 
478
        aes_##mode##_cleanup,           \
 
479
        sizeof(EVP_AES_##MODE##_CTX),   \
 
480
        NULL,NULL,aes_##mode##_ctrl,NULL }; \
 
481
const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 
482
{ return AESNI_CAPABLE?&aesni_##keylen##_##mode:&aes_##keylen##_##mode; }
 
483
 
 
484
# elif   defined(AES_ASM) && (defined(__sparc) || defined(__sparc__))
 
485
 
 
486
#  include "sparc_arch.h"
 
487
 
 
488
extern unsigned int OPENSSL_sparcv9cap_P[];
 
489
 
 
490
#  define SPARC_AES_CAPABLE       (OPENSSL_sparcv9cap_P[1] & CFR_AES)
 
491
 
 
492
void aes_t4_set_encrypt_key(const unsigned char *key, int bits, AES_KEY *ks);
 
493
void aes_t4_set_decrypt_key(const unsigned char *key, int bits, AES_KEY *ks);
 
494
void aes_t4_encrypt(const unsigned char *in, unsigned char *out,
 
495
                    const AES_KEY *key);
 
496
void aes_t4_decrypt(const unsigned char *in, unsigned char *out,
 
497
                    const AES_KEY *key);
 
498
/*
 
499
 * Key-length specific subroutines were chosen for following reason.
 
500
 * Each SPARC T4 core can execute up to 8 threads which share core's
 
501
 * resources. Loading as much key material to registers allows to
 
502
 * minimize references to shared memory interface, as well as amount
 
503
 * of instructions in inner loops [much needed on T4]. But then having
 
504
 * non-key-length specific routines would require conditional branches
 
505
 * either in inner loops or on subroutines' entries. Former is hardly
 
506
 * acceptable, while latter means code size increase to size occupied
 
507
 * by multiple key-length specfic subroutines, so why fight?
 
508
 */
 
509
void aes128_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
 
510
                           size_t len, const AES_KEY *key,
 
511
                           unsigned char *ivec);
 
512
void aes128_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
 
513
                           size_t len, const AES_KEY *key,
 
514
                           unsigned char *ivec);
 
515
void aes192_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
 
516
                           size_t len, const AES_KEY *key,
 
517
                           unsigned char *ivec);
 
518
void aes192_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
 
519
                           size_t len, const AES_KEY *key,
 
520
                           unsigned char *ivec);
 
521
void aes256_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
 
522
                           size_t len, const AES_KEY *key,
 
523
                           unsigned char *ivec);
 
524
void aes256_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
 
525
                           size_t len, const AES_KEY *key,
 
526
                           unsigned char *ivec);
 
527
void aes128_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 
528
                             size_t blocks, const AES_KEY *key,
 
529
                             unsigned char *ivec);
 
530
void aes192_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 
531
                             size_t blocks, const AES_KEY *key,
 
532
                             unsigned char *ivec);
 
533
void aes256_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
 
534
                             size_t blocks, const AES_KEY *key,
 
535
                             unsigned char *ivec);
 
536
void aes128_t4_xts_encrypt(const unsigned char *in, unsigned char *out,
 
537
                           size_t blocks, const AES_KEY *key1,
 
538
                           const AES_KEY *key2, const unsigned char *ivec);
 
539
void aes128_t4_xts_decrypt(const unsigned char *in, unsigned char *out,
 
540
                           size_t blocks, const AES_KEY *key1,
 
541
                           const AES_KEY *key2, const unsigned char *ivec);
 
542
void aes256_t4_xts_encrypt(const unsigned char *in, unsigned char *out,
 
543
                           size_t blocks, const AES_KEY *key1,
 
544
                           const AES_KEY *key2, const unsigned char *ivec);
 
545
void aes256_t4_xts_decrypt(const unsigned char *in, unsigned char *out,
 
546
                           size_t blocks, const AES_KEY *key1,
 
547
                           const AES_KEY *key2, const unsigned char *ivec);
 
548
 
 
549
static int aes_t4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
550
                           const unsigned char *iv, int enc)
 
551
{
 
552
    int ret, mode, bits;
 
553
    EVP_AES_KEY *dat = (EVP_AES_KEY *) ctx->cipher_data;
 
554
 
 
555
    mode = ctx->cipher->flags & EVP_CIPH_MODE;
 
556
    bits = ctx->key_len * 8;
 
557
    if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
 
558
        && !enc) {
 
559
        ret = 0;
 
560
        aes_t4_set_decrypt_key(key, bits, ctx->cipher_data);
 
561
        dat->block = (block128_f) aes_t4_decrypt;
 
562
        switch (bits) {
 
563
        case 128:
 
564
            dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 
565
                (cbc128_f) aes128_t4_cbc_decrypt : NULL;
 
566
            break;
 
567
        case 192:
 
568
            dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 
569
                (cbc128_f) aes192_t4_cbc_decrypt : NULL;
 
570
            break;
 
571
        case 256:
 
572
            dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 
573
                (cbc128_f) aes256_t4_cbc_decrypt : NULL;
 
574
            break;
 
575
        default:
 
576
            ret = -1;
 
577
        }
 
578
    } else {
 
579
        ret = 0;
 
580
        aes_t4_set_encrypt_key(key, bits, ctx->cipher_data);
 
581
        dat->block = (block128_f) aes_t4_encrypt;
 
582
        switch (bits) {
 
583
        case 128:
 
584
            if (mode == EVP_CIPH_CBC_MODE)
 
585
                dat->stream.cbc = (cbc128_f) aes128_t4_cbc_encrypt;
 
586
            else if (mode == EVP_CIPH_CTR_MODE)
 
587
                dat->stream.ctr = (ctr128_f) aes128_t4_ctr32_encrypt;
 
588
            else
 
589
                dat->stream.cbc = NULL;
 
590
            break;
 
591
        case 192:
 
592
            if (mode == EVP_CIPH_CBC_MODE)
 
593
                dat->stream.cbc = (cbc128_f) aes192_t4_cbc_encrypt;
 
594
            else if (mode == EVP_CIPH_CTR_MODE)
 
595
                dat->stream.ctr = (ctr128_f) aes192_t4_ctr32_encrypt;
 
596
            else
 
597
                dat->stream.cbc = NULL;
 
598
            break;
 
599
        case 256:
 
600
            if (mode == EVP_CIPH_CBC_MODE)
 
601
                dat->stream.cbc = (cbc128_f) aes256_t4_cbc_encrypt;
 
602
            else if (mode == EVP_CIPH_CTR_MODE)
 
603
                dat->stream.ctr = (ctr128_f) aes256_t4_ctr32_encrypt;
 
604
            else
 
605
                dat->stream.cbc = NULL;
 
606
            break;
 
607
        default:
 
608
            ret = -1;
 
609
        }
 
610
    }
 
611
 
 
612
    if (ret < 0) {
 
613
        EVPerr(EVP_F_AES_T4_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
 
614
        return 0;
 
615
    }
 
616
 
 
617
    return 1;
 
618
}
 
619
 
 
620
#  define aes_t4_cbc_cipher aes_cbc_cipher
 
621
static int aes_t4_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
622
                             const unsigned char *in, size_t len);
 
623
 
 
624
#  define aes_t4_ecb_cipher aes_ecb_cipher
 
625
static int aes_t4_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
626
                             const unsigned char *in, size_t len);
 
627
 
 
628
#  define aes_t4_ofb_cipher aes_ofb_cipher
 
629
static int aes_t4_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
630
                             const unsigned char *in, size_t len);
 
631
 
 
632
#  define aes_t4_cfb_cipher aes_cfb_cipher
 
633
static int aes_t4_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
634
                             const unsigned char *in, size_t len);
 
635
 
 
636
#  define aes_t4_cfb8_cipher aes_cfb8_cipher
 
637
static int aes_t4_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
638
                              const unsigned char *in, size_t len);
 
639
 
 
640
#  define aes_t4_cfb1_cipher aes_cfb1_cipher
 
641
static int aes_t4_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
642
                              const unsigned char *in, size_t len);
 
643
 
 
644
#  define aes_t4_ctr_cipher aes_ctr_cipher
 
645
static int aes_t4_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
646
                             const unsigned char *in, size_t len);
 
647
 
 
648
static int aes_t4_gcm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
649
                               const unsigned char *iv, int enc)
 
650
{
 
651
    EVP_AES_GCM_CTX *gctx = ctx->cipher_data;
 
652
    if (!iv && !key)
 
653
        return 1;
 
654
    if (key) {
 
655
        int bits = ctx->key_len * 8;
 
656
        aes_t4_set_encrypt_key(key, bits, &gctx->ks.ks);
 
657
        CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
 
658
                           (block128_f) aes_t4_encrypt);
 
659
        switch (bits) {
 
660
        case 128:
 
661
            gctx->ctr = (ctr128_f) aes128_t4_ctr32_encrypt;
 
662
            break;
 
663
        case 192:
 
664
            gctx->ctr = (ctr128_f) aes192_t4_ctr32_encrypt;
 
665
            break;
 
666
        case 256:
 
667
            gctx->ctr = (ctr128_f) aes256_t4_ctr32_encrypt;
 
668
            break;
 
669
        default:
 
670
            return 0;
 
671
        }
 
672
        /*
 
673
         * If we have an iv can set it directly, otherwise use saved IV.
 
674
         */
 
675
        if (iv == NULL && gctx->iv_set)
 
676
            iv = gctx->iv;
 
677
        if (iv) {
 
678
            CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 
679
            gctx->iv_set = 1;
 
680
        }
 
681
        gctx->key_set = 1;
 
682
    } else {
 
683
        /* If key set use IV, otherwise copy */
 
684
        if (gctx->key_set)
 
685
            CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 
686
        else
 
687
            memcpy(gctx->iv, iv, gctx->ivlen);
 
688
        gctx->iv_set = 1;
 
689
        gctx->iv_gen = 0;
 
690
    }
 
691
    return 1;
 
692
}
 
693
 
 
694
#  define aes_t4_gcm_cipher aes_gcm_cipher
 
695
static int aes_t4_gcm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
696
                             const unsigned char *in, size_t len);
 
697
 
 
698
static int aes_t4_xts_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
699
                               const unsigned char *iv, int enc)
 
700
{
 
701
    EVP_AES_XTS_CTX *xctx = ctx->cipher_data;
 
702
    if (!iv && !key)
 
703
        return 1;
 
704
 
 
705
    if (key) {
 
706
        int bits = ctx->key_len * 4;
 
707
        xctx->stream = NULL;
 
708
        /* key_len is two AES keys */
 
709
        if (enc) {
 
710
            aes_t4_set_encrypt_key(key, bits, &xctx->ks1.ks);
 
711
            xctx->xts.block1 = (block128_f) aes_t4_encrypt;
 
712
            switch (bits) {
 
713
            case 128:
 
714
                xctx->stream = aes128_t4_xts_encrypt;
 
715
                break;
 
716
#  if 0                         /* not yet */
 
717
            case 192:
 
718
                xctx->stream = aes192_t4_xts_encrypt;
 
719
                break;
 
720
#  endif
 
721
            case 256:
 
722
                xctx->stream = aes256_t4_xts_encrypt;
 
723
                break;
 
724
            default:
 
725
                return 0;
 
726
            }
 
727
        } else {
 
728
            aes_t4_set_decrypt_key(key, ctx->key_len * 4, &xctx->ks1.ks);
 
729
            xctx->xts.block1 = (block128_f) aes_t4_decrypt;
 
730
            switch (bits) {
 
731
            case 128:
 
732
                xctx->stream = aes128_t4_xts_decrypt;
 
733
                break;
 
734
#  if 0                         /* not yet */
 
735
            case 192:
 
736
                xctx->stream = aes192_t4_xts_decrypt;
 
737
                break;
 
738
#  endif
 
739
            case 256:
 
740
                xctx->stream = aes256_t4_xts_decrypt;
 
741
                break;
 
742
            default:
 
743
                return 0;
 
744
            }
 
745
        }
 
746
 
 
747
        aes_t4_set_encrypt_key(key + ctx->key_len / 2,
 
748
                               ctx->key_len * 4, &xctx->ks2.ks);
 
749
        xctx->xts.block2 = (block128_f) aes_t4_encrypt;
 
750
 
 
751
        xctx->xts.key1 = &xctx->ks1;
 
752
    }
 
753
 
 
754
    if (iv) {
 
755
        xctx->xts.key2 = &xctx->ks2;
 
756
        memcpy(ctx->iv, iv, 16);
 
757
    }
 
758
 
 
759
    return 1;
 
760
}
 
761
 
 
762
#  define aes_t4_xts_cipher aes_xts_cipher
 
763
static int aes_t4_xts_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
764
                             const unsigned char *in, size_t len);
 
765
 
 
766
static int aes_t4_ccm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
767
                               const unsigned char *iv, int enc)
 
768
{
 
769
    EVP_AES_CCM_CTX *cctx = ctx->cipher_data;
 
770
    if (!iv && !key)
 
771
        return 1;
 
772
    if (key) {
 
773
        int bits = ctx->key_len * 8;
 
774
        aes_t4_set_encrypt_key(key, bits, &cctx->ks.ks);
 
775
        CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
 
776
                           &cctx->ks, (block128_f) aes_t4_encrypt);
 
777
#  if 0                         /* not yet */
 
778
        switch (bits) {
 
779
        case 128:
 
780
            cctx->str = enc ? (ccm128_f) aes128_t4_ccm64_encrypt :
 
781
                (ccm128_f) ae128_t4_ccm64_decrypt;
 
782
            break;
 
783
        case 192:
 
784
            cctx->str = enc ? (ccm128_f) aes192_t4_ccm64_encrypt :
 
785
                (ccm128_f) ae192_t4_ccm64_decrypt;
 
786
            break;
 
787
        case 256:
 
788
            cctx->str = enc ? (ccm128_f) aes256_t4_ccm64_encrypt :
 
789
                (ccm128_f) ae256_t4_ccm64_decrypt;
 
790
            break;
 
791
        default:
 
792
            return 0;
 
793
        }
 
794
#  else
 
795
        cctx->str = NULL;
 
796
#  endif
 
797
        cctx->key_set = 1;
 
798
    }
 
799
    if (iv) {
 
800
        memcpy(ctx->iv, iv, 15 - cctx->L);
 
801
        cctx->iv_set = 1;
 
802
    }
 
803
    return 1;
 
804
}
 
805
 
 
806
#  define aes_t4_ccm_cipher aes_ccm_cipher
 
807
static int aes_t4_ccm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
808
                             const unsigned char *in, size_t len);
 
809
 
 
810
#  define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \
 
811
static const EVP_CIPHER aes_t4_##keylen##_##mode = { \
 
812
        nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \
 
813
        flags|EVP_CIPH_##MODE##_MODE,   \
 
814
        aes_t4_init_key,                \
 
815
        aes_t4_##mode##_cipher,         \
 
816
        NULL,                           \
 
817
        sizeof(EVP_AES_KEY),            \
 
818
        NULL,NULL,NULL,NULL }; \
 
819
static const EVP_CIPHER aes_##keylen##_##mode = { \
 
820
        nid##_##keylen##_##nmode,blocksize,     \
 
821
        keylen/8,ivlen, \
 
822
        flags|EVP_CIPH_##MODE##_MODE,   \
 
823
        aes_init_key,                   \
 
824
        aes_##mode##_cipher,            \
 
825
        NULL,                           \
 
826
        sizeof(EVP_AES_KEY),            \
 
827
        NULL,NULL,NULL,NULL }; \
 
828
const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 
829
{ return SPARC_AES_CAPABLE?&aes_t4_##keylen##_##mode:&aes_##keylen##_##mode; }
 
830
 
 
831
#  define BLOCK_CIPHER_custom(nid,keylen,blocksize,ivlen,mode,MODE,flags) \
 
832
static const EVP_CIPHER aes_t4_##keylen##_##mode = { \
 
833
        nid##_##keylen##_##mode,blocksize, \
 
834
        (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE?2:1)*keylen/8, ivlen, \
 
835
        flags|EVP_CIPH_##MODE##_MODE,   \
 
836
        aes_t4_##mode##_init_key,       \
 
837
        aes_t4_##mode##_cipher,         \
 
838
        aes_##mode##_cleanup,           \
 
839
        sizeof(EVP_AES_##MODE##_CTX),   \
 
840
        NULL,NULL,aes_##mode##_ctrl,NULL }; \
 
841
static const EVP_CIPHER aes_##keylen##_##mode = { \
 
842
        nid##_##keylen##_##mode,blocksize, \
 
843
        (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE?2:1)*keylen/8, ivlen, \
 
844
        flags|EVP_CIPH_##MODE##_MODE,   \
 
845
        aes_##mode##_init_key,          \
 
846
        aes_##mode##_cipher,            \
 
847
        aes_##mode##_cleanup,           \
 
848
        sizeof(EVP_AES_##MODE##_CTX),   \
 
849
        NULL,NULL,aes_##mode##_ctrl,NULL }; \
 
850
const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 
851
{ return SPARC_AES_CAPABLE?&aes_t4_##keylen##_##mode:&aes_##keylen##_##mode; }
 
852
 
 
853
#elif defined(OPENSSL_CPUID_OBJ) && defined(__s390__)
 
854
/*
 
855
 * IBM S390X support
 
856
 */
 
857
# include "s390x_arch.h"
 
858
 
 
859
typedef struct {
 
860
    union {
 
861
        double align;
 
862
        /*-
 
863
         * KMA-GCM-AES parameter block
 
864
         * (see z/Architecture Principles of Operation SA22-7832-11)
 
865
         */
 
866
        struct {
 
867
            unsigned char reserved[12];
 
868
            union {
 
869
                unsigned int w;
 
870
                unsigned char b[4];
 
871
            } cv;
 
872
            union {
 
873
                unsigned long long g[2];
 
874
                unsigned char b[16];
 
875
            } t;
 
876
            unsigned char h[16];
 
877
            unsigned long long taadl;
 
878
            unsigned long long tpcl;
 
879
            union {
 
880
                unsigned long long g[2];
 
881
                unsigned int w[4];
 
882
            } j0;
 
883
            unsigned char k[32];
 
884
        } param;
 
885
    } kma;
 
886
    unsigned int fc;
 
887
    int key_set;
 
888
 
 
889
    unsigned char *iv;
 
890
    int ivlen;
 
891
    int iv_set;
 
892
    int iv_gen;
 
893
 
 
894
    int taglen;
 
895
 
 
896
    unsigned char ares[16];
 
897
    unsigned char mres[16];
 
898
    unsigned char kres[16];
 
899
    int areslen;
 
900
    int mreslen;
 
901
    int kreslen;
 
902
 
 
903
    int tls_aad_len;
 
904
} S390X_AES_GCM_CTX;
 
905
 
 
906
# define S390X_aes_128_CAPABLE ((OPENSSL_s390xcap_P.km[0] &     \
 
907
                                 S390X_CAPBIT(S390X_AES_128)) &&\
 
908
                                (OPENSSL_s390xcap_P.kmc[0] &    \
 
909
                                 S390X_CAPBIT(S390X_AES_128)))
 
910
# define S390X_aes_192_CAPABLE ((OPENSSL_s390xcap_P.km[0] &     \
 
911
                                 S390X_CAPBIT(S390X_AES_192)) &&\
 
912
                                (OPENSSL_s390xcap_P.kmc[0] &    \
 
913
                                 S390X_CAPBIT(S390X_AES_192)))
 
914
# define S390X_aes_256_CAPABLE ((OPENSSL_s390xcap_P.km[0] &     \
 
915
                                 S390X_CAPBIT(S390X_AES_256)) &&\
 
916
                                (OPENSSL_s390xcap_P.kmc[0] &    \
 
917
                                 S390X_CAPBIT(S390X_AES_256)))
 
918
 
 
919
# define s390x_aes_init_key aes_init_key
 
920
static int s390x_aes_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
921
                              const unsigned char *iv, int enc);
 
922
 
 
923
# define S390X_aes_128_cbc_CAPABLE      1       /* checked by callee */
 
924
# define S390X_aes_192_cbc_CAPABLE      1
 
925
# define S390X_aes_256_cbc_CAPABLE      1
 
926
 
 
927
# define s390x_aes_cbc_cipher aes_cbc_cipher
 
928
static int s390x_aes_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
929
                                const unsigned char *in, size_t len);
 
930
 
 
931
# define S390X_aes_128_ecb_CAPABLE      0
 
932
# define S390X_aes_192_ecb_CAPABLE      0
 
933
# define S390X_aes_256_ecb_CAPABLE      0
 
934
 
 
935
# define s390x_aes_ecb_cipher aes_ecb_cipher
 
936
static int s390x_aes_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
937
                                const unsigned char *in, size_t len);
 
938
 
 
939
# define S390X_aes_128_ofb_CAPABLE      0
 
940
# define S390X_aes_192_ofb_CAPABLE      0
 
941
# define S390X_aes_256_ofb_CAPABLE      0
 
942
 
 
943
# define s390x_aes_ofb_cipher aes_ofb_cipher
 
944
static int s390x_aes_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
945
                                const unsigned char *in, size_t len);
 
946
 
 
947
# define S390X_aes_128_cfb_CAPABLE      0
 
948
# define S390X_aes_192_cfb_CAPABLE      0
 
949
# define S390X_aes_256_cfb_CAPABLE      0
 
950
 
 
951
# define s390x_aes_cfb_cipher aes_cfb_cipher
 
952
static int s390x_aes_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
953
                                const unsigned char *in, size_t len);
 
954
 
 
955
# define S390X_aes_128_cfb8_CAPABLE     0
 
956
# define S390X_aes_192_cfb8_CAPABLE     0
 
957
# define S390X_aes_256_cfb8_CAPABLE     0
 
958
 
 
959
# define s390x_aes_cfb8_cipher aes_cfb8_cipher
 
960
static int s390x_aes_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
961
                                 const unsigned char *in, size_t len);
 
962
 
 
963
# define S390X_aes_128_cfb1_CAPABLE     0
 
964
# define S390X_aes_192_cfb1_CAPABLE     0
 
965
# define S390X_aes_256_cfb1_CAPABLE     0
 
966
 
 
967
# define s390x_aes_cfb1_cipher aes_cfb1_cipher
 
968
static int s390x_aes_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
969
                                 const unsigned char *in, size_t len);
 
970
 
 
971
# define S390X_aes_128_ctr_CAPABLE      1       /* checked by callee */
 
972
# define S390X_aes_192_ctr_CAPABLE      1
 
973
# define S390X_aes_256_ctr_CAPABLE      1
 
974
 
 
975
# define s390x_aes_ctr_cipher aes_ctr_cipher
 
976
static int s390x_aes_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
977
                                const unsigned char *in, size_t len);
 
978
 
 
979
# define S390X_aes_128_gcm_CAPABLE (S390X_aes_128_CAPABLE &&            \
 
980
                                    (OPENSSL_s390xcap_P.kma[0] &        \
 
981
                                     S390X_CAPBIT(S390X_AES_128)))
 
982
# define S390X_aes_192_gcm_CAPABLE (S390X_aes_192_CAPABLE &&            \
 
983
                                    (OPENSSL_s390xcap_P.kma[0] &        \
 
984
                                     S390X_CAPBIT(S390X_AES_192)))
 
985
# define S390X_aes_256_gcm_CAPABLE (S390X_aes_256_CAPABLE &&            \
 
986
                                    (OPENSSL_s390xcap_P.kma[0] &        \
 
987
                                     S390X_CAPBIT(S390X_AES_256)))
 
988
 
 
989
/* iv + padding length for iv lenghts != 12 */
 
990
# define S390X_gcm_ivpadlen(i)  ((((i) + 15) >> 4 << 4) + 16)
 
991
 
 
992
static int s390x_aes_gcm_aad(S390X_AES_GCM_CTX *ctx, const unsigned char *aad,
 
993
                             size_t len)
 
994
{
 
995
    unsigned long long alen;
 
996
    int n, rem;
 
997
 
 
998
    if (ctx->kma.param.tpcl)
 
999
        return -2;
 
1000
 
 
1001
    alen = ctx->kma.param.taadl + len;
 
1002
    if (alen > (U64(1) << 61) || (sizeof(len) == 8 && alen < len))
 
1003
        return -1;
 
1004
    ctx->kma.param.taadl = alen;
 
1005
 
 
1006
    n = ctx->areslen;
 
1007
    if (n) {
 
1008
        while (n && len) {
 
1009
            ctx->ares[n] = *aad;
 
1010
            n = (n + 1) & 0xf;
 
1011
            ++aad;
 
1012
            --len;
 
1013
        }
 
1014
        /* ctx->ares contains a complete block if offset has wrapped around */
 
1015
        if (!n) {
 
1016
            s390x_kma(ctx->ares, 16, NULL, 0, NULL, ctx->fc, &ctx->kma.param);
 
1017
            ctx->fc |= S390X_KMA_HS;
 
1018
        }
 
1019
        ctx->areslen = n;
 
1020
    }
 
1021
 
 
1022
    rem = len & 0xf;
 
1023
 
 
1024
    len &= ~0xf;
 
1025
    if (len) {
 
1026
        s390x_kma(aad, len, NULL, 0, NULL, ctx->fc, &ctx->kma.param);
 
1027
        aad += len;
 
1028
        ctx->fc |= S390X_KMA_HS;
 
1029
    }
 
1030
 
 
1031
    if (rem) {
 
1032
        ctx->areslen = rem;
 
1033
 
 
1034
        do {
 
1035
            --rem;
 
1036
            ctx->ares[rem] = aad[rem];
 
1037
        } while (rem);
 
1038
    }
 
1039
    return 0;
 
1040
}
 
1041
 
 
1042
static int s390x_aes_gcm(S390X_AES_GCM_CTX *ctx, const unsigned char *in,
 
1043
                         unsigned char *out, size_t len)
 
1044
{
 
1045
    const unsigned char *inptr;
 
1046
    unsigned long long mlen;
 
1047
    union {
 
1048
        unsigned int w[4];
 
1049
        unsigned char b[16];
 
1050
    } buf;
 
1051
    size_t inlen;
 
1052
    int n, rem, i;
 
1053
 
 
1054
    mlen = ctx->kma.param.tpcl + len;
 
1055
    if (mlen > ((U64(1) << 36) - 32) || (sizeof(len) == 8 && mlen < len))
 
1056
        return -1;
 
1057
    ctx->kma.param.tpcl = mlen;
 
1058
 
 
1059
    n = ctx->mreslen;
 
1060
    if (n) {
 
1061
        inptr = in;
 
1062
        inlen = len;
 
1063
        while (n && inlen) {
 
1064
            ctx->mres[n] = *inptr;
 
1065
            n = (n + 1) & 0xf;
 
1066
            ++inptr;
 
1067
            --inlen;
 
1068
        }
 
1069
        /* ctx->mres contains a complete block if offset has wrapped around */
 
1070
        if (!n) {
 
1071
            s390x_kma(ctx->ares, ctx->areslen, ctx->mres, 16, buf.b,
 
1072
                      ctx->fc | S390X_KMA_LAAD, &ctx->kma.param);
 
1073
            ctx->fc |= S390X_KMA_HS;
 
1074
            ctx->areslen = 0;
 
1075
 
 
1076
            /* previous call already encrypted/decrypted its remainder,
 
1077
             * see comment below */
 
1078
            n = ctx->mreslen;
 
1079
            while (n) {
 
1080
                *out = buf.b[n];
 
1081
                n = (n + 1) & 0xf;
 
1082
                ++out;
 
1083
                ++in;
 
1084
                --len;
 
1085
            }
 
1086
            ctx->mreslen = 0;
 
1087
        }
 
1088
    }
 
1089
 
 
1090
    rem = len & 0xf;
 
1091
 
 
1092
    len &= ~0xf;
 
1093
    if (len) {
 
1094
        s390x_kma(ctx->ares, ctx->areslen, in, len, out,
 
1095
                  ctx->fc | S390X_KMA_LAAD, &ctx->kma.param);
 
1096
        in += len;
 
1097
        out += len;
 
1098
        ctx->fc |= S390X_KMA_HS;
 
1099
        ctx->areslen = 0;
 
1100
    }
 
1101
 
 
1102
    /*-
 
1103
     * If there is a remainder, it has to be saved such that it can be
 
1104
     * processed by kma later. However, we also have to do the for-now
 
1105
     * unauthenticated encryption/decryption part here and now...
 
1106
     */
 
1107
    if (rem) {
 
1108
        if (!ctx->mreslen) {
 
1109
            buf.w[0] = ctx->kma.param.j0.w[0];
 
1110
            buf.w[1] = ctx->kma.param.j0.w[1];
 
1111
            buf.w[2] = ctx->kma.param.j0.w[2];
 
1112
            buf.w[3] = ctx->kma.param.cv.w + 1;
 
1113
            s390x_km(buf.b, 16, ctx->kres, ctx->fc & 0x1f, &ctx->kma.param.k);
 
1114
        }
 
1115
 
 
1116
        n = ctx->mreslen;
 
1117
        for (i = 0; i < rem; i++) {
 
1118
            ctx->mres[n + i] = in[i];
 
1119
            out[i] = in[i] ^ ctx->kres[n + i];
 
1120
        }
 
1121
 
 
1122
        ctx->mreslen += rem;
 
1123
    }
 
1124
    return 0;
 
1125
}
 
1126
 
 
1127
static void s390x_aes_gcm_setiv(S390X_AES_GCM_CTX *ctx,
 
1128
                                const unsigned char *iv)
 
1129
{
 
1130
    ctx->kma.param.t.g[0] = 0;
 
1131
    ctx->kma.param.t.g[1] = 0;
 
1132
    ctx->kma.param.tpcl = 0;
 
1133
    ctx->kma.param.taadl = 0;
 
1134
    ctx->mreslen = 0;
 
1135
    ctx->areslen = 0;
 
1136
    ctx->kreslen = 0;
 
1137
 
 
1138
    if (ctx->ivlen == 12) {
 
1139
        memcpy(&ctx->kma.param.j0, iv, ctx->ivlen);
 
1140
        ctx->kma.param.j0.w[3] = 1;
 
1141
        ctx->kma.param.cv.w = 1;
 
1142
    } else {
 
1143
        /* ctx->iv has the right size and is already padded. */
 
1144
        memcpy(ctx->iv, iv, ctx->ivlen);
 
1145
        s390x_kma(ctx->iv, S390X_gcm_ivpadlen(ctx->ivlen), NULL, 0, NULL,
 
1146
                  ctx->fc, &ctx->kma.param);
 
1147
        ctx->fc |= S390X_KMA_HS;
 
1148
 
 
1149
        ctx->kma.param.j0.g[0] = ctx->kma.param.t.g[0];
 
1150
        ctx->kma.param.j0.g[1] = ctx->kma.param.t.g[1];
 
1151
        ctx->kma.param.cv.w = ctx->kma.param.j0.w[3];
 
1152
        ctx->kma.param.t.g[0] = 0;
 
1153
        ctx->kma.param.t.g[1] = 0;
 
1154
    }
 
1155
}
 
1156
 
 
1157
static int s390x_aes_gcm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
 
1158
{
 
1159
    S390X_AES_GCM_CTX *gctx = EVP_C_DATA(S390X_AES_GCM_CTX, c);
 
1160
    S390X_AES_GCM_CTX *gctx_out;
 
1161
    EVP_CIPHER_CTX *out;
 
1162
    unsigned char *buf, *iv;
 
1163
    int ivlen, enc, len;
 
1164
 
 
1165
    switch (type) {
 
1166
    case EVP_CTRL_INIT:
 
1167
        ivlen = c->cipher->iv_len;;
 
1168
        iv = c->iv;
 
1169
        gctx->key_set = 0;
 
1170
        gctx->iv_set = 0;
 
1171
        gctx->ivlen = ivlen;
 
1172
        gctx->iv = iv;
 
1173
        gctx->taglen = -1;
 
1174
        gctx->iv_gen = 0;
 
1175
        gctx->tls_aad_len = -1;
 
1176
        return 1;
 
1177
 
 
1178
    case EVP_CTRL_GCM_SET_IVLEN:
 
1179
        if (arg <= 0)
 
1180
            return 0;
 
1181
 
 
1182
        if (arg != 12) {
 
1183
            iv = c->iv;
 
1184
            len = S390X_gcm_ivpadlen(arg);
 
1185
 
 
1186
            /* Allocate memory for iv if needed. */
 
1187
            if (gctx->ivlen == 12 || len > S390X_gcm_ivpadlen(gctx->ivlen)) {
 
1188
                if (gctx->iv != iv)
 
1189
                    OPENSSL_free(gctx->iv);
 
1190
 
 
1191
                gctx->iv = OPENSSL_malloc(len);
 
1192
                if (gctx->iv == NULL)
 
1193
                    return 0;
 
1194
            }
 
1195
            /* Add padding. */
 
1196
            memset(gctx->iv + arg, 0, len - arg - 8);
 
1197
            *((unsigned long long *)(gctx->iv + len - 8)) = arg << 3;
 
1198
        }
 
1199
        gctx->ivlen = arg;
 
1200
        return 1;
 
1201
 
 
1202
    case EVP_CTRL_GCM_SET_TAG:
 
1203
        buf = c->buf;
 
1204
        enc = c->encrypt;
 
1205
        if (arg <= 0 || arg > 16 || enc)
 
1206
            return 0;
 
1207
 
 
1208
        memcpy(buf, ptr, arg);
 
1209
        gctx->taglen = arg;
 
1210
        return 1;
 
1211
 
 
1212
    case EVP_CTRL_GCM_GET_TAG:
 
1213
        enc = c->encrypt;
 
1214
        if (arg <= 0 || arg > 16 || !enc || gctx->taglen < 0)
 
1215
            return 0;
 
1216
 
 
1217
        memcpy(ptr, gctx->kma.param.t.b, arg);
 
1218
        return 1;
 
1219
 
 
1220
    case EVP_CTRL_GCM_SET_IV_FIXED:
 
1221
        /* Special case: -1 length restores whole iv */
 
1222
        if (arg == -1) {
 
1223
            memcpy(gctx->iv, ptr, gctx->ivlen);
 
1224
            gctx->iv_gen = 1;
 
1225
            return 1;
 
1226
        }
 
1227
        /*
 
1228
         * Fixed field must be at least 4 bytes and invocation field at least
 
1229
         * 8.
 
1230
         */
 
1231
        if ((arg < 4) || (gctx->ivlen - arg) < 8)
 
1232
            return 0;
 
1233
 
 
1234
        if (arg)
 
1235
            memcpy(gctx->iv, ptr, arg);
 
1236
 
 
1237
        enc = c->encrypt;
 
1238
        if (enc && RAND_bytes(gctx->iv + arg, gctx->ivlen - arg) <= 0)
 
1239
            return 0;
 
1240
 
 
1241
        gctx->iv_gen = 1;
 
1242
        return 1;
 
1243
 
 
1244
    case EVP_CTRL_GCM_IV_GEN:
 
1245
        if (gctx->iv_gen == 0 || gctx->key_set == 0)
 
1246
            return 0;
 
1247
 
 
1248
        s390x_aes_gcm_setiv(gctx, gctx->iv);
 
1249
 
 
1250
        if (arg <= 0 || arg > gctx->ivlen)
 
1251
            arg = gctx->ivlen;
 
1252
 
 
1253
        memcpy(ptr, gctx->iv + gctx->ivlen - arg, arg);
 
1254
        /*
 
1255
         * Invocation field will be at least 8 bytes in size and so no need
 
1256
         * to check wrap around or increment more than last 8 bytes.
 
1257
         */
 
1258
        (*(unsigned long long *)(gctx->iv + gctx->ivlen - 8))++;
 
1259
        gctx->iv_set = 1;
 
1260
        return 1;
 
1261
 
 
1262
    case EVP_CTRL_GCM_SET_IV_INV:
 
1263
        enc = c->encrypt;
 
1264
        if (gctx->iv_gen == 0 || gctx->key_set == 0 || enc)
 
1265
            return 0;
 
1266
 
 
1267
        memcpy(gctx->iv + gctx->ivlen - arg, ptr, arg);
 
1268
        s390x_aes_gcm_setiv(gctx, gctx->iv);
 
1269
        gctx->iv_set = 1;
 
1270
        return 1;
 
1271
 
 
1272
    case EVP_CTRL_AEAD_TLS1_AAD:
 
1273
        /* Save the aad for later use. */
 
1274
        if (arg != EVP_AEAD_TLS1_AAD_LEN)
 
1275
            return 0;
 
1276
 
 
1277
        buf = c->buf;
 
1278
        memcpy(buf, ptr, arg);
 
1279
        gctx->tls_aad_len = arg;
 
1280
 
 
1281
        len = buf[arg - 2] << 8 | buf[arg - 1];
 
1282
        /* Correct length for explicit iv. */
 
1283
        if (len < EVP_GCM_TLS_EXPLICIT_IV_LEN)
 
1284
            return 0;
 
1285
        len -= EVP_GCM_TLS_EXPLICIT_IV_LEN;
 
1286
 
 
1287
        /* If decrypting correct for tag too. */
 
1288
        enc = c->encrypt;
 
1289
        if (!enc) {
 
1290
            if (len < EVP_GCM_TLS_TAG_LEN)
 
1291
                return 0;
 
1292
            len -= EVP_GCM_TLS_TAG_LEN;
 
1293
        }
 
1294
        buf[arg - 2] = len >> 8;
 
1295
        buf[arg - 1] = len & 0xff;
 
1296
        /* Extra padding: tag appended to record. */
 
1297
        return EVP_GCM_TLS_TAG_LEN;
 
1298
 
 
1299
    case EVP_CTRL_COPY:
 
1300
        out = ptr;
 
1301
        gctx_out = EVP_C_DATA(S390X_AES_GCM_CTX, out);
 
1302
        iv = c->iv;
 
1303
 
 
1304
        if (gctx->iv == iv) {
 
1305
            gctx_out->iv = out->iv;
 
1306
        } else {
 
1307
            len = S390X_gcm_ivpadlen(gctx->ivlen);
 
1308
 
 
1309
            gctx_out->iv = OPENSSL_malloc(len);
 
1310
            if (gctx_out->iv == NULL)
 
1311
                return 0;
 
1312
 
 
1313
            memcpy(gctx_out->iv, gctx->iv, len);
 
1314
        }
 
1315
        return 1;
 
1316
 
 
1317
    default:
 
1318
        return -1;
 
1319
    }
 
1320
}
 
1321
 
 
1322
static int s390x_aes_gcm_init_key(EVP_CIPHER_CTX *ctx,
 
1323
                                  const unsigned char *key,
 
1324
                                  const unsigned char *iv, int enc)
 
1325
{
 
1326
    S390X_AES_GCM_CTX *gctx = EVP_C_DATA(S390X_AES_GCM_CTX, ctx);
 
1327
    int keylen;
 
1328
 
 
1329
    if (iv == NULL && key == NULL)
 
1330
        return 1;
 
1331
 
 
1332
    if (key != NULL) {
 
1333
        keylen = EVP_CIPHER_CTX_key_length(ctx);
 
1334
        memcpy(&gctx->kma.param.k, key, keylen);
 
1335
 
 
1336
        /* Convert key size to function code. */
 
1337
        gctx->fc = S390X_AES_128 + (((keylen << 3) - 128) >> 6);
 
1338
        if (!enc)
 
1339
            gctx->fc |= S390X_DECRYPT;
 
1340
 
 
1341
        if (iv == NULL && gctx->iv_set)
 
1342
            iv = gctx->iv;
 
1343
 
 
1344
        if (iv != NULL) {
 
1345
            s390x_aes_gcm_setiv(gctx, iv);
 
1346
            gctx->iv_set = 1;
 
1347
        }
 
1348
        gctx->key_set = 1;
 
1349
    } else {
 
1350
        if (gctx->key_set)
 
1351
            s390x_aes_gcm_setiv(gctx, iv);
 
1352
        else
 
1353
            memcpy(gctx->iv, iv, gctx->ivlen);
 
1354
 
 
1355
        gctx->iv_set = 1;
 
1356
        gctx->iv_gen = 0;
 
1357
    }
 
1358
    return 1;
 
1359
}
 
1360
 
 
1361
static int s390x_aes_gcm_tls_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
1362
                                    const unsigned char *in, size_t len)
 
1363
{
 
1364
    S390X_AES_GCM_CTX *gctx = EVP_C_DATA(S390X_AES_GCM_CTX, ctx);
 
1365
    const unsigned char *buf = ctx->buf;
 
1366
    const int enc = ctx->encrypt;
 
1367
    int rv = -1;
 
1368
 
 
1369
    if (out != in || len < (EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN))
 
1370
        return -1;
 
1371
 
 
1372
    if (EVP_CIPHER_CTX_ctrl(ctx, enc ? EVP_CTRL_GCM_IV_GEN
 
1373
                                     : EVP_CTRL_GCM_SET_IV_INV,
 
1374
                            EVP_GCM_TLS_EXPLICIT_IV_LEN, out) <= 0)
 
1375
        goto err;
 
1376
 
 
1377
    in += EVP_GCM_TLS_EXPLICIT_IV_LEN;
 
1378
    out += EVP_GCM_TLS_EXPLICIT_IV_LEN;
 
1379
    len -= EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
 
1380
 
 
1381
    gctx->kma.param.taadl = gctx->tls_aad_len << 3;
 
1382
    gctx->kma.param.tpcl = len << 3;
 
1383
    s390x_kma(buf, gctx->tls_aad_len, in, len, out,
 
1384
              gctx->fc | S390X_KMA_LAAD | S390X_KMA_LPC, &gctx->kma.param);
 
1385
 
 
1386
    if (enc) {
 
1387
        memcpy(out + len, gctx->kma.param.t.b, EVP_GCM_TLS_TAG_LEN);
 
1388
        rv = len + EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
 
1389
    } else {
 
1390
        if (CRYPTO_memcmp(gctx->kma.param.t.b, in + len,
 
1391
                          EVP_GCM_TLS_TAG_LEN)) {
 
1392
            OPENSSL_cleanse(out, len);
 
1393
            goto err;
 
1394
        }
 
1395
        rv = len;
 
1396
    }
 
1397
err:
 
1398
    gctx->iv_set = 0;
 
1399
    gctx->tls_aad_len = -1;
 
1400
    return rv;
 
1401
}
 
1402
 
 
1403
static int s390x_aes_gcm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
1404
                                const unsigned char *in, size_t len)
 
1405
{
 
1406
    S390X_AES_GCM_CTX *gctx = EVP_C_DATA(S390X_AES_GCM_CTX, ctx);
 
1407
    unsigned char *buf, tmp[16];
 
1408
    int enc;
 
1409
 
 
1410
    if (!gctx->key_set)
 
1411
        return -1;
 
1412
 
 
1413
    if (gctx->tls_aad_len >= 0)
 
1414
        return s390x_aes_gcm_tls_cipher(ctx, out, in, len);
 
1415
 
 
1416
    if (!gctx->iv_set)
 
1417
        return -1;
 
1418
 
 
1419
    if (in != NULL) {
 
1420
        if (out == NULL) {
 
1421
            if (s390x_aes_gcm_aad(gctx, in, len))
 
1422
                return -1;
 
1423
        } else {
 
1424
            if (s390x_aes_gcm(gctx, in, out, len))
 
1425
                return -1;
 
1426
        }
 
1427
        return len;
 
1428
    } else {
 
1429
        gctx->kma.param.taadl <<= 3;
 
1430
        gctx->kma.param.tpcl <<= 3;
 
1431
        s390x_kma(gctx->ares, gctx->areslen, gctx->mres, gctx->mreslen, tmp,
 
1432
                  gctx->fc | S390X_KMA_LAAD | S390X_KMA_LPC, &gctx->kma.param);
 
1433
        /* recall that we already did en-/decrypt gctx->mres
 
1434
         * and returned it to caller... */
 
1435
        OPENSSL_cleanse(tmp, gctx->mreslen);
 
1436
        gctx->iv_set = 0;
 
1437
 
 
1438
        enc = ctx->encrypt;
 
1439
        if (enc) {
 
1440
            gctx->taglen = 16;
 
1441
        } else {
 
1442
            if (gctx->taglen < 0)
 
1443
                return -1;
 
1444
 
 
1445
            buf = ctx->buf;
 
1446
            if (CRYPTO_memcmp(buf, gctx->kma.param.t.b, gctx->taglen))
 
1447
                return -1;
 
1448
        }
 
1449
        return 0;
 
1450
    }
 
1451
}
 
1452
 
 
1453
static int s390x_aes_gcm_cleanup(EVP_CIPHER_CTX *c)
 
1454
{
 
1455
    S390X_AES_GCM_CTX *gctx = EVP_C_DATA(S390X_AES_GCM_CTX, c);
 
1456
    const unsigned char *iv;
 
1457
 
 
1458
    if (gctx == NULL)
 
1459
        return 0;
 
1460
 
 
1461
    iv = c->iv;
 
1462
    if (iv != gctx->iv)
 
1463
        OPENSSL_free(gctx->iv);
 
1464
 
 
1465
    OPENSSL_cleanse(gctx, sizeof(*gctx));
 
1466
    return 1;
 
1467
}
 
1468
 
 
1469
# define S390X_AES_XTS_CTX              EVP_AES_XTS_CTX
 
1470
# define S390X_aes_128_xts_CAPABLE      1       /* checked by callee */
 
1471
# define S390X_aes_256_xts_CAPABLE      1
 
1472
 
 
1473
# define s390x_aes_xts_init_key aes_xts_init_key
 
1474
static int s390x_aes_xts_init_key(EVP_CIPHER_CTX *ctx,
 
1475
                                  const unsigned char *key,
 
1476
                                  const unsigned char *iv, int enc);
 
1477
# define s390x_aes_xts_cipher aes_xts_cipher
 
1478
static int s390x_aes_xts_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
1479
                                const unsigned char *in, size_t len);
 
1480
# define s390x_aes_xts_ctrl aes_xts_ctrl
 
1481
static int s390x_aes_xts_ctrl(EVP_CIPHER_CTX *, int type, int arg, void *ptr);
 
1482
# define s390x_aes_xts_cleanup aes_xts_cleanup
 
1483
 
 
1484
# define S390X_AES_CCM_CTX              EVP_AES_CCM_CTX
 
1485
# define S390X_aes_128_ccm_CAPABLE      0
 
1486
# define S390X_aes_192_ccm_CAPABLE      0
 
1487
# define S390X_aes_256_ccm_CAPABLE      0
 
1488
 
 
1489
# define s390x_aes_ccm_init_key aes_ccm_init_key
 
1490
static int s390x_aes_ccm_init_key(EVP_CIPHER_CTX *ctx,
 
1491
                                  const unsigned char *key,
 
1492
                                  const unsigned char *iv, int enc);
 
1493
# define s390x_aes_ccm_cipher aes_ccm_cipher
 
1494
static int s390x_aes_ccm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
1495
                                const unsigned char *in, size_t len);
 
1496
# define s390x_aes_ccm_ctrl aes_ccm_ctrl
 
1497
static int s390x_aes_ccm_ctrl(EVP_CIPHER_CTX *, int type, int arg, void *ptr);
 
1498
# define s390x_aes_ccm_cleanup aes_ccm_cleanup
 
1499
 
 
1500
# define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,    \
 
1501
                              MODE,flags)                               \
 
1502
static const EVP_CIPHER s390x_aes_##keylen##_##mode = {                 \
 
1503
    nid##_##keylen##_##nmode,blocksize,                                 \
 
1504
    keylen / 8,                                                         \
 
1505
    ivlen,                                                              \
 
1506
    flags | EVP_CIPH_##MODE##_MODE,                                     \
 
1507
    s390x_aes_init_key,                                                 \
 
1508
    s390x_aes_##mode##_cipher,                                          \
 
1509
    NULL,                                                               \
 
1510
    sizeof(EVP_AES_KEY),                                                \
 
1511
    NULL,                                                               \
 
1512
    NULL,                                                               \
 
1513
    NULL,                                                               \
 
1514
    NULL                                                                \
 
1515
};                                                                      \
 
1516
static const EVP_CIPHER aes_##keylen##_##mode = {                       \
 
1517
    nid##_##keylen##_##nmode,                                           \
 
1518
    blocksize,                                                          \
 
1519
    keylen / 8,                                                         \
 
1520
    ivlen,                                                              \
 
1521
    flags | EVP_CIPH_##MODE##_MODE,                                     \
 
1522
    aes_init_key,                                                       \
 
1523
    aes_##mode##_cipher,                                                \
 
1524
    NULL,                                                               \
 
1525
    sizeof(EVP_AES_KEY),                                                \
 
1526
    NULL,NULL,NULL,NULL                                                 \
 
1527
};                                                                      \
 
1528
const EVP_CIPHER *EVP_aes_##keylen##_##mode(void)                       \
 
1529
{                                                                       \
 
1530
    return S390X_aes_##keylen##_##mode##_CAPABLE ?                      \
 
1531
           &s390x_aes_##keylen##_##mode : &aes_##keylen##_##mode;       \
 
1532
}
 
1533
 
 
1534
# define BLOCK_CIPHER_custom(nid,keylen,blocksize,ivlen,mode,MODE,flags)\
 
1535
static const EVP_CIPHER s390x_aes_##keylen##_##mode = {                 \
 
1536
    nid##_##keylen##_##mode,                                            \
 
1537
    blocksize,                                                          \
 
1538
    (EVP_CIPH_##MODE##_MODE == EVP_CIPH_XTS_MODE ? 2 : 1) * keylen / 8, \
 
1539
    ivlen,                                                              \
 
1540
    flags | EVP_CIPH_##MODE##_MODE,                                     \
 
1541
    s390x_aes_##mode##_init_key,                                        \
 
1542
    s390x_aes_##mode##_cipher,                                          \
 
1543
    s390x_aes_##mode##_cleanup,                                         \
 
1544
    sizeof(S390X_AES_##MODE##_CTX),                                     \
 
1545
    NULL,                                                               \
 
1546
    NULL,                                                               \
 
1547
    s390x_aes_##mode##_ctrl,                                            \
 
1548
    NULL                                                                \
 
1549
};                                                                      \
 
1550
static const EVP_CIPHER aes_##keylen##_##mode = {                       \
 
1551
    nid##_##keylen##_##mode,blocksize,                                  \
 
1552
    (EVP_CIPH_##MODE##_MODE == EVP_CIPH_XTS_MODE ? 2 : 1) * keylen / 8, \
 
1553
    ivlen,                                                              \
 
1554
    flags | EVP_CIPH_##MODE##_MODE,                                     \
 
1555
    aes_##mode##_init_key,                                              \
 
1556
    aes_##mode##_cipher,                                                \
 
1557
    aes_##mode##_cleanup,                                               \
 
1558
    sizeof(EVP_AES_##MODE##_CTX),                                       \
 
1559
    NULL,                                                               \
 
1560
    NULL,                                                               \
 
1561
    aes_##mode##_ctrl,                                                  \
 
1562
    NULL                                                                \
 
1563
};                                                                      \
 
1564
const EVP_CIPHER *EVP_aes_##keylen##_##mode(void)                       \
 
1565
{                                                                       \
 
1566
    return S390X_aes_##keylen##_##mode##_CAPABLE ?                      \
 
1567
           &s390x_aes_##keylen##_##mode : &aes_##keylen##_##mode;       \
 
1568
}
 
1569
 
 
1570
# else
 
1571
 
 
1572
#  define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \
 
1573
static const EVP_CIPHER aes_##keylen##_##mode = { \
 
1574
        nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \
 
1575
        flags|EVP_CIPH_##MODE##_MODE,   \
 
1576
        aes_init_key,                   \
 
1577
        aes_##mode##_cipher,            \
 
1578
        NULL,                           \
 
1579
        sizeof(EVP_AES_KEY),            \
 
1580
        NULL,NULL,NULL,NULL }; \
 
1581
const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 
1582
{ return &aes_##keylen##_##mode; }
 
1583
 
 
1584
#  define BLOCK_CIPHER_custom(nid,keylen,blocksize,ivlen,mode,MODE,flags) \
 
1585
static const EVP_CIPHER aes_##keylen##_##mode = { \
 
1586
        nid##_##keylen##_##mode,blocksize, \
 
1587
        (EVP_CIPH_##MODE##_MODE==EVP_CIPH_XTS_MODE?2:1)*keylen/8, ivlen, \
 
1588
        flags|EVP_CIPH_##MODE##_MODE,   \
 
1589
        aes_##mode##_init_key,          \
 
1590
        aes_##mode##_cipher,            \
 
1591
        aes_##mode##_cleanup,           \
 
1592
        sizeof(EVP_AES_##MODE##_CTX),   \
 
1593
        NULL,NULL,aes_##mode##_ctrl,NULL }; \
 
1594
const EVP_CIPHER *EVP_aes_##keylen##_##mode(void) \
 
1595
{ return &aes_##keylen##_##mode; }
 
1596
# endif
 
1597
 
 
1598
# if defined(OPENSSL_CPUID_OBJ) && (defined(__arm__) || defined(__arm) || defined(__aarch64__))
 
1599
#  include "arm_arch.h"
 
1600
#  if __ARM_MAX_ARCH__>=7
 
1601
#   if defined(BSAES_ASM)
 
1602
#    define BSAES_CAPABLE (OPENSSL_armcap_P & ARMV7_NEON)
 
1603
#   endif
 
1604
#   define HWAES_CAPABLE (OPENSSL_armcap_P & ARMV8_AES)
 
1605
#   define HWAES_set_encrypt_key aes_v8_set_encrypt_key
 
1606
#   define HWAES_set_decrypt_key aes_v8_set_decrypt_key
 
1607
#   define HWAES_encrypt aes_v8_encrypt
 
1608
#   define HWAES_decrypt aes_v8_decrypt
 
1609
#   define HWAES_cbc_encrypt aes_v8_cbc_encrypt
 
1610
#   define HWAES_ctr32_encrypt_blocks aes_v8_ctr32_encrypt_blocks
 
1611
#  endif
 
1612
# endif
 
1613
 
 
1614
# if defined(HWAES_CAPABLE)
 
1615
int HWAES_set_encrypt_key(const unsigned char *userKey, const int bits,
 
1616
                          AES_KEY *key);
 
1617
int HWAES_set_decrypt_key(const unsigned char *userKey, const int bits,
 
1618
                          AES_KEY *key);
 
1619
void HWAES_encrypt(const unsigned char *in, unsigned char *out,
 
1620
                   const AES_KEY *key);
 
1621
void HWAES_decrypt(const unsigned char *in, unsigned char *out,
 
1622
                   const AES_KEY *key);
 
1623
void HWAES_cbc_encrypt(const unsigned char *in, unsigned char *out,
 
1624
                       size_t length, const AES_KEY *key,
 
1625
                       unsigned char *ivec, const int enc);
 
1626
void HWAES_ctr32_encrypt_blocks(const unsigned char *in, unsigned char *out,
 
1627
                                size_t len, const AES_KEY *key,
 
1628
                                const unsigned char ivec[16]);
 
1629
# endif
 
1630
 
 
1631
# define BLOCK_CIPHER_generic_pack(nid,keylen,flags)             \
 
1632
        BLOCK_CIPHER_generic(nid,keylen,16,16,cbc,cbc,CBC,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)     \
 
1633
        BLOCK_CIPHER_generic(nid,keylen,16,0,ecb,ecb,ECB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)      \
 
1634
        BLOCK_CIPHER_generic(nid,keylen,1,16,ofb128,ofb,OFB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)   \
 
1635
        BLOCK_CIPHER_generic(nid,keylen,1,16,cfb128,cfb,CFB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)   \
 
1636
        BLOCK_CIPHER_generic(nid,keylen,1,16,cfb1,cfb1,CFB,flags)       \
 
1637
        BLOCK_CIPHER_generic(nid,keylen,1,16,cfb8,cfb8,CFB,flags)       \
 
1638
        BLOCK_CIPHER_generic(nid,keylen,1,16,ctr,ctr,CTR,flags)
 
1639
 
 
1640
static int aes_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
1641
                        const unsigned char *iv, int enc)
 
1642
{
 
1643
    int ret, mode;
 
1644
    EVP_AES_KEY *dat = (EVP_AES_KEY *) ctx->cipher_data;
 
1645
 
 
1646
    mode = ctx->cipher->flags & EVP_CIPH_MODE;
 
1647
    if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
 
1648
        && !enc)
 
1649
# ifdef HWAES_CAPABLE
 
1650
        if (HWAES_CAPABLE) {
 
1651
            ret = HWAES_set_decrypt_key(key, ctx->key_len * 8, &dat->ks.ks);
 
1652
            dat->block = (block128_f) HWAES_decrypt;
 
1653
            dat->stream.cbc = NULL;
 
1654
#  ifdef HWAES_cbc_encrypt
 
1655
            if (mode == EVP_CIPH_CBC_MODE)
 
1656
                dat->stream.cbc = (cbc128_f) HWAES_cbc_encrypt;
 
1657
#  endif
 
1658
        } else
 
1659
# endif
 
1660
# ifdef BSAES_CAPABLE
 
1661
        if (BSAES_CAPABLE && mode == EVP_CIPH_CBC_MODE) {
 
1662
            ret = AES_set_decrypt_key(key, ctx->key_len * 8, &dat->ks.ks);
 
1663
            dat->block = (block128_f) AES_decrypt;
 
1664
            dat->stream.cbc = (cbc128_f) bsaes_cbc_encrypt;
 
1665
        } else
 
1666
# endif
 
1667
# ifdef VPAES_CAPABLE
 
1668
        if (VPAES_CAPABLE) {
 
1669
            ret = vpaes_set_decrypt_key(key, ctx->key_len * 8, &dat->ks.ks);
 
1670
            dat->block = (block128_f) vpaes_decrypt;
 
1671
            dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 
1672
                (cbc128_f) vpaes_cbc_encrypt : NULL;
 
1673
        } else
 
1674
# endif
 
1675
        {
 
1676
            ret = AES_set_decrypt_key(key, ctx->key_len * 8, &dat->ks.ks);
 
1677
            dat->block = (block128_f) AES_decrypt;
 
1678
            dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 
1679
                (cbc128_f) AES_cbc_encrypt : NULL;
 
1680
    } else
 
1681
# ifdef HWAES_CAPABLE
 
1682
    if (HWAES_CAPABLE) {
 
1683
        ret = HWAES_set_encrypt_key(key, ctx->key_len * 8, &dat->ks.ks);
 
1684
        dat->block = (block128_f) HWAES_encrypt;
 
1685
        dat->stream.cbc = NULL;
 
1686
#  ifdef HWAES_cbc_encrypt
 
1687
        if (mode == EVP_CIPH_CBC_MODE)
 
1688
            dat->stream.cbc = (cbc128_f) HWAES_cbc_encrypt;
 
1689
        else
 
1690
#  endif
 
1691
#  ifdef HWAES_ctr32_encrypt_blocks
 
1692
        if (mode == EVP_CIPH_CTR_MODE)
 
1693
            dat->stream.ctr = (ctr128_f) HWAES_ctr32_encrypt_blocks;
 
1694
        else
 
1695
#  endif
 
1696
            (void)0;            /* terminate potentially open 'else' */
 
1697
    } else
 
1698
# endif
 
1699
# ifdef BSAES_CAPABLE
 
1700
    if (BSAES_CAPABLE && mode == EVP_CIPH_CTR_MODE) {
 
1701
        ret = AES_set_encrypt_key(key, ctx->key_len * 8, &dat->ks.ks);
 
1702
        dat->block = (block128_f) AES_encrypt;
 
1703
        dat->stream.ctr = (ctr128_f) bsaes_ctr32_encrypt_blocks;
 
1704
    } else
 
1705
# endif
 
1706
# ifdef VPAES_CAPABLE
 
1707
    if (VPAES_CAPABLE) {
 
1708
        ret = vpaes_set_encrypt_key(key, ctx->key_len * 8, &dat->ks.ks);
 
1709
        dat->block = (block128_f) vpaes_encrypt;
 
1710
        dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 
1711
            (cbc128_f) vpaes_cbc_encrypt : NULL;
 
1712
    } else
 
1713
# endif
 
1714
    {
 
1715
        ret = AES_set_encrypt_key(key, ctx->key_len * 8, &dat->ks.ks);
 
1716
        dat->block = (block128_f) AES_encrypt;
 
1717
        dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 
1718
            (cbc128_f) AES_cbc_encrypt : NULL;
 
1719
# ifdef AES_CTR_ASM
 
1720
        if (mode == EVP_CIPH_CTR_MODE)
 
1721
            dat->stream.ctr = (ctr128_f) AES_ctr32_encrypt;
 
1722
# endif
 
1723
    }
 
1724
 
 
1725
    if (ret < 0) {
 
1726
        EVPerr(EVP_F_AES_INIT_KEY, EVP_R_AES_KEY_SETUP_FAILED);
 
1727
        return 0;
 
1728
    }
 
1729
 
 
1730
    return 1;
 
1731
}
 
1732
 
 
1733
static int aes_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
1734
                          const unsigned char *in, size_t len)
 
1735
{
 
1736
    EVP_AES_KEY *dat = (EVP_AES_KEY *) ctx->cipher_data;
 
1737
 
 
1738
    if (dat->stream.cbc)
 
1739
        (*dat->stream.cbc) (in, out, len, &dat->ks, ctx->iv, ctx->encrypt);
 
1740
    else if (ctx->encrypt)
 
1741
        CRYPTO_cbc128_encrypt(in, out, len, &dat->ks, ctx->iv, dat->block);
 
1742
    else
 
1743
        CRYPTO_cbc128_decrypt(in, out, len, &dat->ks, ctx->iv, dat->block);
 
1744
 
 
1745
    return 1;
 
1746
}
 
1747
 
 
1748
static int aes_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
1749
                          const unsigned char *in, size_t len)
 
1750
{
 
1751
    size_t bl = ctx->cipher->block_size;
 
1752
    size_t i;
 
1753
    EVP_AES_KEY *dat = (EVP_AES_KEY *) ctx->cipher_data;
 
1754
 
 
1755
    if (len < bl)
 
1756
        return 1;
 
1757
 
 
1758
    for (i = 0, len -= bl; i <= len; i += bl)
 
1759
        (*dat->block) (in + i, out + i, &dat->ks);
 
1760
 
 
1761
    return 1;
 
1762
}
 
1763
 
 
1764
static int aes_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
1765
                          const unsigned char *in, size_t len)
 
1766
{
 
1767
    EVP_AES_KEY *dat = (EVP_AES_KEY *) ctx->cipher_data;
 
1768
 
 
1769
    CRYPTO_ofb128_encrypt(in, out, len, &dat->ks,
 
1770
                          ctx->iv, &ctx->num, dat->block);
 
1771
    return 1;
 
1772
}
 
1773
 
 
1774
static int aes_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
1775
                          const unsigned char *in, size_t len)
 
1776
{
 
1777
    EVP_AES_KEY *dat = (EVP_AES_KEY *) ctx->cipher_data;
 
1778
 
 
1779
    CRYPTO_cfb128_encrypt(in, out, len, &dat->ks,
 
1780
                          ctx->iv, &ctx->num, ctx->encrypt, dat->block);
 
1781
    return 1;
 
1782
}
 
1783
 
 
1784
static int aes_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
1785
                           const unsigned char *in, size_t len)
 
1786
{
 
1787
    EVP_AES_KEY *dat = (EVP_AES_KEY *) ctx->cipher_data;
 
1788
 
 
1789
    CRYPTO_cfb128_8_encrypt(in, out, len, &dat->ks,
 
1790
                            ctx->iv, &ctx->num, ctx->encrypt, dat->block);
 
1791
    return 1;
 
1792
}
 
1793
 
 
1794
static int aes_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
1795
                           const unsigned char *in, size_t len)
 
1796
{
 
1797
    EVP_AES_KEY *dat = (EVP_AES_KEY *) ctx->cipher_data;
 
1798
 
 
1799
    if (ctx->flags & EVP_CIPH_FLAG_LENGTH_BITS) {
 
1800
        CRYPTO_cfb128_1_encrypt(in, out, len, &dat->ks,
 
1801
                                ctx->iv, &ctx->num, ctx->encrypt, dat->block);
 
1802
        return 1;
 
1803
    }
 
1804
 
 
1805
    while (len >= MAXBITCHUNK) {
 
1806
        CRYPTO_cfb128_1_encrypt(in, out, MAXBITCHUNK * 8, &dat->ks,
 
1807
                                ctx->iv, &ctx->num, ctx->encrypt, dat->block);
 
1808
        len -= MAXBITCHUNK;
 
1809
    }
 
1810
    if (len)
 
1811
        CRYPTO_cfb128_1_encrypt(in, out, len * 8, &dat->ks,
 
1812
                                ctx->iv, &ctx->num, ctx->encrypt, dat->block);
 
1813
 
 
1814
    return 1;
 
1815
}
 
1816
 
 
1817
static int aes_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
1818
                          const unsigned char *in, size_t len)
 
1819
{
 
1820
    unsigned int num = ctx->num;
 
1821
    EVP_AES_KEY *dat = (EVP_AES_KEY *) ctx->cipher_data;
 
1822
 
 
1823
    if (dat->stream.ctr)
 
1824
        CRYPTO_ctr128_encrypt_ctr32(in, out, len, &dat->ks,
 
1825
                                    ctx->iv, ctx->buf, &num, dat->stream.ctr);
 
1826
    else
 
1827
        CRYPTO_ctr128_encrypt(in, out, len, &dat->ks,
 
1828
                              ctx->iv, ctx->buf, &num, dat->block);
 
1829
    ctx->num = (size_t)num;
 
1830
    return 1;
 
1831
}
 
1832
 
 
1833
BLOCK_CIPHER_generic_pack(NID_aes, 128, EVP_CIPH_FLAG_FIPS)
 
1834
    BLOCK_CIPHER_generic_pack(NID_aes, 192, EVP_CIPH_FLAG_FIPS)
 
1835
    BLOCK_CIPHER_generic_pack(NID_aes, 256, EVP_CIPH_FLAG_FIPS)
 
1836
 
 
1837
static int aes_gcm_cleanup(EVP_CIPHER_CTX *c)
 
1838
{
 
1839
    EVP_AES_GCM_CTX *gctx = c->cipher_data;
 
1840
    if (gctx == NULL)
 
1841
        return 0;
 
1842
    OPENSSL_cleanse(&gctx->gcm, sizeof(gctx->gcm));
 
1843
    if (gctx->iv != c->iv)
 
1844
        OPENSSL_free(gctx->iv);
 
1845
    return 1;
 
1846
}
 
1847
 
 
1848
/* increment counter (64-bit int) by 1 */
 
1849
static void ctr64_inc(unsigned char *counter)
 
1850
{
 
1851
    int n = 8;
 
1852
    unsigned char c;
 
1853
 
 
1854
    do {
 
1855
        --n;
 
1856
        c = counter[n];
 
1857
        ++c;
 
1858
        counter[n] = c;
 
1859
        if (c)
 
1860
            return;
 
1861
    } while (n);
 
1862
}
 
1863
 
 
1864
static int aes_gcm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
 
1865
{
 
1866
    EVP_AES_GCM_CTX *gctx = c->cipher_data;
 
1867
    switch (type) {
 
1868
    case EVP_CTRL_INIT:
 
1869
        gctx->key_set = 0;
 
1870
        gctx->iv_set = 0;
 
1871
        gctx->ivlen = c->cipher->iv_len;
 
1872
        gctx->iv = c->iv;
 
1873
        gctx->taglen = -1;
 
1874
        gctx->iv_gen = 0;
 
1875
        gctx->tls_aad_len = -1;
 
1876
        return 1;
 
1877
 
 
1878
    case EVP_CTRL_GCM_SET_IVLEN:
 
1879
        if (arg <= 0)
 
1880
            return 0;
 
1881
        /* Allocate memory for IV if needed */
 
1882
        if ((arg > EVP_MAX_IV_LENGTH) && (arg > gctx->ivlen)) {
 
1883
            if (gctx->iv != c->iv)
 
1884
                OPENSSL_free(gctx->iv);
 
1885
            gctx->iv = OPENSSL_malloc(arg);
 
1886
            if (!gctx->iv)
 
1887
                return 0;
 
1888
        }
 
1889
        gctx->ivlen = arg;
 
1890
        return 1;
 
1891
 
 
1892
    case EVP_CTRL_GCM_SET_TAG:
 
1893
        if (arg <= 0 || arg > 16 || c->encrypt)
 
1894
            return 0;
 
1895
        memcpy(c->buf, ptr, arg);
 
1896
        gctx->taglen = arg;
 
1897
        return 1;
 
1898
 
 
1899
    case EVP_CTRL_GCM_GET_TAG:
 
1900
        if (arg <= 0 || arg > 16 || !c->encrypt || gctx->taglen < 0)
 
1901
            return 0;
 
1902
        memcpy(ptr, c->buf, arg);
 
1903
        return 1;
 
1904
 
 
1905
    case EVP_CTRL_GCM_SET_IV_FIXED:
 
1906
        /* Special case: -1 length restores whole IV */
 
1907
        if (arg == -1) {
 
1908
            memcpy(gctx->iv, ptr, gctx->ivlen);
 
1909
            gctx->iv_gen = 1;
 
1910
            return 1;
 
1911
        }
 
1912
        /*
 
1913
         * Fixed field must be at least 4 bytes and invocation field at least
 
1914
         * 8.
 
1915
         */
 
1916
        if ((arg < 4) || (gctx->ivlen - arg) < 8)
 
1917
            return 0;
 
1918
        if (arg)
 
1919
            memcpy(gctx->iv, ptr, arg);
 
1920
        if (c->encrypt && RAND_bytes(gctx->iv + arg, gctx->ivlen - arg) <= 0)
 
1921
            return 0;
 
1922
        gctx->iv_gen = 1;
 
1923
        return 1;
 
1924
 
 
1925
    case EVP_CTRL_GCM_IV_GEN:
 
1926
        if (gctx->iv_gen == 0 || gctx->key_set == 0)
 
1927
            return 0;
 
1928
        CRYPTO_gcm128_setiv(&gctx->gcm, gctx->iv, gctx->ivlen);
 
1929
        if (arg <= 0 || arg > gctx->ivlen)
 
1930
            arg = gctx->ivlen;
 
1931
        memcpy(ptr, gctx->iv + gctx->ivlen - arg, arg);
 
1932
        /*
 
1933
         * Invocation field will be at least 8 bytes in size and so no need
 
1934
         * to check wrap around or increment more than last 8 bytes.
 
1935
         */
 
1936
        ctr64_inc(gctx->iv + gctx->ivlen - 8);
 
1937
        gctx->iv_set = 1;
 
1938
        return 1;
 
1939
 
 
1940
    case EVP_CTRL_GCM_SET_IV_INV:
 
1941
        if (gctx->iv_gen == 0 || gctx->key_set == 0 || c->encrypt)
 
1942
            return 0;
 
1943
        memcpy(gctx->iv + gctx->ivlen - arg, ptr, arg);
 
1944
        CRYPTO_gcm128_setiv(&gctx->gcm, gctx->iv, gctx->ivlen);
 
1945
        gctx->iv_set = 1;
 
1946
        return 1;
 
1947
 
 
1948
    case EVP_CTRL_AEAD_TLS1_AAD:
 
1949
        /* Save the AAD for later use */
 
1950
        if (arg != EVP_AEAD_TLS1_AAD_LEN)
 
1951
            return 0;
 
1952
        memcpy(c->buf, ptr, arg);
 
1953
        gctx->tls_aad_len = arg;
 
1954
        {
 
1955
            unsigned int len = c->buf[arg - 2] << 8 | c->buf[arg - 1];
 
1956
            /* Correct length for explicit IV */
 
1957
            if (len < EVP_GCM_TLS_EXPLICIT_IV_LEN)
 
1958
                return 0;
 
1959
            len -= EVP_GCM_TLS_EXPLICIT_IV_LEN;
 
1960
            /* If decrypting correct for tag too */
 
1961
            if (!c->encrypt) {
 
1962
                if (len < EVP_GCM_TLS_TAG_LEN)
 
1963
                    return 0;
 
1964
                len -= EVP_GCM_TLS_TAG_LEN;
 
1965
            }
 
1966
            c->buf[arg - 2] = len >> 8;
 
1967
            c->buf[arg - 1] = len & 0xff;
 
1968
        }
 
1969
        /* Extra padding: tag appended to record */
 
1970
        return EVP_GCM_TLS_TAG_LEN;
 
1971
 
 
1972
    case EVP_CTRL_COPY:
 
1973
        {
 
1974
            EVP_CIPHER_CTX *out = ptr;
 
1975
            EVP_AES_GCM_CTX *gctx_out = out->cipher_data;
 
1976
            if (gctx->gcm.key) {
 
1977
                if (gctx->gcm.key != &gctx->ks)
 
1978
                    return 0;
 
1979
                gctx_out->gcm.key = &gctx_out->ks;
 
1980
            }
 
1981
            if (gctx->iv == c->iv)
 
1982
                gctx_out->iv = out->iv;
 
1983
            else {
 
1984
                gctx_out->iv = OPENSSL_malloc(gctx->ivlen);
 
1985
                if (!gctx_out->iv)
 
1986
                    return 0;
 
1987
                memcpy(gctx_out->iv, gctx->iv, gctx->ivlen);
 
1988
            }
 
1989
            return 1;
 
1990
        }
 
1991
 
 
1992
    default:
 
1993
        return -1;
 
1994
 
 
1995
    }
 
1996
}
 
1997
 
 
1998
static int aes_gcm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
1999
                            const unsigned char *iv, int enc)
 
2000
{
 
2001
    EVP_AES_GCM_CTX *gctx = ctx->cipher_data;
 
2002
    if (!iv && !key)
 
2003
        return 1;
 
2004
    if (key) {
 
2005
        do {
 
2006
# ifdef HWAES_CAPABLE
 
2007
            if (HWAES_CAPABLE) {
 
2008
                HWAES_set_encrypt_key(key, ctx->key_len * 8, &gctx->ks.ks);
 
2009
                CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
 
2010
                                   (block128_f) HWAES_encrypt);
 
2011
#  ifdef HWAES_ctr32_encrypt_blocks
 
2012
                gctx->ctr = (ctr128_f) HWAES_ctr32_encrypt_blocks;
 
2013
#  else
 
2014
                gctx->ctr = NULL;
 
2015
#  endif
 
2016
                break;
 
2017
            } else
 
2018
# endif
 
2019
# ifdef BSAES_CAPABLE
 
2020
            if (BSAES_CAPABLE) {
 
2021
                AES_set_encrypt_key(key, ctx->key_len * 8, &gctx->ks.ks);
 
2022
                CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
 
2023
                                   (block128_f) AES_encrypt);
 
2024
                gctx->ctr = (ctr128_f) bsaes_ctr32_encrypt_blocks;
 
2025
                break;
 
2026
            } else
 
2027
# endif
 
2028
# ifdef VPAES_CAPABLE
 
2029
            if (VPAES_CAPABLE) {
 
2030
                vpaes_set_encrypt_key(key, ctx->key_len * 8, &gctx->ks.ks);
 
2031
                CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
 
2032
                                   (block128_f) vpaes_encrypt);
 
2033
                gctx->ctr = NULL;
 
2034
                break;
 
2035
            } else
 
2036
# endif
 
2037
                (void)0;        /* terminate potentially open 'else' */
 
2038
 
 
2039
            AES_set_encrypt_key(key, ctx->key_len * 8, &gctx->ks.ks);
 
2040
            CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,
 
2041
                               (block128_f) AES_encrypt);
 
2042
# ifdef AES_CTR_ASM
 
2043
            gctx->ctr = (ctr128_f) AES_ctr32_encrypt;
 
2044
# else
 
2045
            gctx->ctr = NULL;
 
2046
# endif
 
2047
        } while (0);
 
2048
 
 
2049
        /*
 
2050
         * If we have an iv can set it directly, otherwise use saved IV.
 
2051
         */
 
2052
        if (iv == NULL && gctx->iv_set)
 
2053
            iv = gctx->iv;
 
2054
        if (iv) {
 
2055
            CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 
2056
            gctx->iv_set = 1;
 
2057
        }
 
2058
        gctx->key_set = 1;
 
2059
    } else {
 
2060
        /* If key set use IV, otherwise copy */
 
2061
        if (gctx->key_set)
 
2062
            CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);
 
2063
        else
 
2064
            memcpy(gctx->iv, iv, gctx->ivlen);
 
2065
        gctx->iv_set = 1;
 
2066
        gctx->iv_gen = 0;
 
2067
    }
 
2068
    return 1;
 
2069
}
 
2070
 
 
2071
/*
 
2072
 * Handle TLS GCM packet format. This consists of the last portion of the IV
 
2073
 * followed by the payload and finally the tag. On encrypt generate IV,
 
2074
 * encrypt payload and write the tag. On verify retrieve IV, decrypt payload
 
2075
 * and verify tag.
 
2076
 */
 
2077
 
 
2078
static int aes_gcm_tls_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
2079
                              const unsigned char *in, size_t len)
 
2080
{
 
2081
    EVP_AES_GCM_CTX *gctx = ctx->cipher_data;
 
2082
    int rv = -1;
 
2083
    /* Encrypt/decrypt must be performed in place */
 
2084
    if (out != in
 
2085
        || len < (EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN))
 
2086
        return -1;
 
2087
    /*
 
2088
     * Set IV from start of buffer or generate IV and write to start of
 
2089
     * buffer.
 
2090
     */
 
2091
    if (EVP_CIPHER_CTX_ctrl(ctx, ctx->encrypt ?
 
2092
                            EVP_CTRL_GCM_IV_GEN : EVP_CTRL_GCM_SET_IV_INV,
 
2093
                            EVP_GCM_TLS_EXPLICIT_IV_LEN, out) <= 0)
 
2094
        goto err;
 
2095
    /* Use saved AAD */
 
2096
    if (CRYPTO_gcm128_aad(&gctx->gcm, ctx->buf, gctx->tls_aad_len))
 
2097
        goto err;
 
2098
    /* Fix buffer and length to point to payload */
 
2099
    in += EVP_GCM_TLS_EXPLICIT_IV_LEN;
 
2100
    out += EVP_GCM_TLS_EXPLICIT_IV_LEN;
 
2101
    len -= EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
 
2102
    if (ctx->encrypt) {
 
2103
        /* Encrypt payload */
 
2104
        if (gctx->ctr) {
 
2105
            size_t bulk = 0;
 
2106
# if defined(AES_GCM_ASM)
 
2107
            if (len >= 32 && AES_GCM_ASM(gctx)) {
 
2108
                if (CRYPTO_gcm128_encrypt(&gctx->gcm, NULL, NULL, 0))
 
2109
                    return -1;
 
2110
 
 
2111
                bulk = AES_gcm_encrypt(in, out, len,
 
2112
                                       gctx->gcm.key,
 
2113
                                       gctx->gcm.Yi.c, gctx->gcm.Xi.u);
 
2114
                gctx->gcm.len.u[1] += bulk;
 
2115
            }
 
2116
# endif
 
2117
            if (CRYPTO_gcm128_encrypt_ctr32(&gctx->gcm,
 
2118
                                            in + bulk,
 
2119
                                            out + bulk,
 
2120
                                            len - bulk, gctx->ctr))
 
2121
                goto err;
 
2122
        } else {
 
2123
            size_t bulk = 0;
 
2124
# if defined(AES_GCM_ASM2)
 
2125
            if (len >= 32 && AES_GCM_ASM2(gctx)) {
 
2126
                if (CRYPTO_gcm128_encrypt(&gctx->gcm, NULL, NULL, 0))
 
2127
                    return -1;
 
2128
 
 
2129
                bulk = AES_gcm_encrypt(in, out, len,
 
2130
                                       gctx->gcm.key,
 
2131
                                       gctx->gcm.Yi.c, gctx->gcm.Xi.u);
 
2132
                gctx->gcm.len.u[1] += bulk;
 
2133
            }
 
2134
# endif
 
2135
            if (CRYPTO_gcm128_encrypt(&gctx->gcm,
 
2136
                                      in + bulk, out + bulk, len - bulk))
 
2137
                goto err;
 
2138
        }
 
2139
        out += len;
 
2140
        /* Finally write tag */
 
2141
        CRYPTO_gcm128_tag(&gctx->gcm, out, EVP_GCM_TLS_TAG_LEN);
 
2142
        rv = len + EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN;
 
2143
    } else {
 
2144
        /* Decrypt */
 
2145
        if (gctx->ctr) {
 
2146
            size_t bulk = 0;
 
2147
# if defined(AES_GCM_ASM)
 
2148
            if (len >= 16 && AES_GCM_ASM(gctx)) {
 
2149
                if (CRYPTO_gcm128_decrypt(&gctx->gcm, NULL, NULL, 0))
 
2150
                    return -1;
 
2151
 
 
2152
                bulk = AES_gcm_decrypt(in, out, len,
 
2153
                                       gctx->gcm.key,
 
2154
                                       gctx->gcm.Yi.c, gctx->gcm.Xi.u);
 
2155
                gctx->gcm.len.u[1] += bulk;
 
2156
            }
 
2157
# endif
 
2158
            if (CRYPTO_gcm128_decrypt_ctr32(&gctx->gcm,
 
2159
                                            in + bulk,
 
2160
                                            out + bulk,
 
2161
                                            len - bulk, gctx->ctr))
 
2162
                goto err;
 
2163
        } else {
 
2164
            size_t bulk = 0;
 
2165
# if defined(AES_GCM_ASM2)
 
2166
            if (len >= 16 && AES_GCM_ASM2(gctx)) {
 
2167
                if (CRYPTO_gcm128_decrypt(&gctx->gcm, NULL, NULL, 0))
 
2168
                    return -1;
 
2169
 
 
2170
                bulk = AES_gcm_decrypt(in, out, len,
 
2171
                                       gctx->gcm.key,
 
2172
                                       gctx->gcm.Yi.c, gctx->gcm.Xi.u);
 
2173
                gctx->gcm.len.u[1] += bulk;
 
2174
            }
 
2175
# endif
 
2176
            if (CRYPTO_gcm128_decrypt(&gctx->gcm,
 
2177
                                      in + bulk, out + bulk, len - bulk))
 
2178
                goto err;
 
2179
        }
 
2180
        /* Retrieve tag */
 
2181
        CRYPTO_gcm128_tag(&gctx->gcm, ctx->buf, EVP_GCM_TLS_TAG_LEN);
 
2182
        /* If tag mismatch wipe buffer */
 
2183
        if (CRYPTO_memcmp(ctx->buf, in + len, EVP_GCM_TLS_TAG_LEN)) {
 
2184
            OPENSSL_cleanse(out, len);
 
2185
            goto err;
 
2186
        }
 
2187
        rv = len;
 
2188
    }
 
2189
 
 
2190
 err:
 
2191
    gctx->iv_set = 0;
 
2192
    gctx->tls_aad_len = -1;
 
2193
    return rv;
 
2194
}
 
2195
 
 
2196
static int aes_gcm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
2197
                          const unsigned char *in, size_t len)
 
2198
{
 
2199
    EVP_AES_GCM_CTX *gctx = ctx->cipher_data;
 
2200
    /* If not set up, return error */
 
2201
    if (!gctx->key_set)
 
2202
        return -1;
 
2203
 
 
2204
    if (gctx->tls_aad_len >= 0)
 
2205
        return aes_gcm_tls_cipher(ctx, out, in, len);
 
2206
 
 
2207
    if (!gctx->iv_set)
 
2208
        return -1;
 
2209
    if (in) {
 
2210
        if (out == NULL) {
 
2211
            if (CRYPTO_gcm128_aad(&gctx->gcm, in, len))
 
2212
                return -1;
 
2213
        } else if (ctx->encrypt) {
 
2214
            if (gctx->ctr) {
 
2215
                size_t bulk = 0;
 
2216
# if defined(AES_GCM_ASM)
 
2217
                if (len >= 32 && AES_GCM_ASM(gctx)) {
 
2218
                    size_t res = (16 - gctx->gcm.mres) % 16;
 
2219
 
 
2220
                    if (CRYPTO_gcm128_encrypt(&gctx->gcm, in, out, res))
 
2221
                        return -1;
 
2222
 
 
2223
                    bulk = AES_gcm_encrypt(in + res,
 
2224
                                           out + res, len - res,
 
2225
                                           gctx->gcm.key, gctx->gcm.Yi.c,
 
2226
                                           gctx->gcm.Xi.u);
 
2227
                    gctx->gcm.len.u[1] += bulk;
 
2228
                    bulk += res;
 
2229
                }
 
2230
# endif
 
2231
                if (CRYPTO_gcm128_encrypt_ctr32(&gctx->gcm,
 
2232
                                                in + bulk,
 
2233
                                                out + bulk,
 
2234
                                                len - bulk, gctx->ctr))
 
2235
                    return -1;
 
2236
            } else {
 
2237
                size_t bulk = 0;
 
2238
# if defined(AES_GCM_ASM2)
 
2239
                if (len >= 32 && AES_GCM_ASM2(gctx)) {
 
2240
                    size_t res = (16 - gctx->gcm.mres) % 16;
 
2241
 
 
2242
                    if (CRYPTO_gcm128_encrypt(&gctx->gcm, in, out, res))
 
2243
                        return -1;
 
2244
 
 
2245
                    bulk = AES_gcm_encrypt(in + res,
 
2246
                                           out + res, len - res,
 
2247
                                           gctx->gcm.key, gctx->gcm.Yi.c,
 
2248
                                           gctx->gcm.Xi.u);
 
2249
                    gctx->gcm.len.u[1] += bulk;
 
2250
                    bulk += res;
 
2251
                }
 
2252
# endif
 
2253
                if (CRYPTO_gcm128_encrypt(&gctx->gcm,
 
2254
                                          in + bulk, out + bulk, len - bulk))
 
2255
                    return -1;
 
2256
            }
 
2257
        } else {
 
2258
            if (gctx->ctr) {
 
2259
                size_t bulk = 0;
 
2260
# if defined(AES_GCM_ASM)
 
2261
                if (len >= 16 && AES_GCM_ASM(gctx)) {
 
2262
                    size_t res = (16 - gctx->gcm.mres) % 16;
 
2263
 
 
2264
                    if (CRYPTO_gcm128_decrypt(&gctx->gcm, in, out, res))
 
2265
                        return -1;
 
2266
 
 
2267
                    bulk = AES_gcm_decrypt(in + res,
 
2268
                                           out + res, len - res,
 
2269
                                           gctx->gcm.key,
 
2270
                                           gctx->gcm.Yi.c, gctx->gcm.Xi.u);
 
2271
                    gctx->gcm.len.u[1] += bulk;
 
2272
                    bulk += res;
 
2273
                }
 
2274
# endif
 
2275
                if (CRYPTO_gcm128_decrypt_ctr32(&gctx->gcm,
 
2276
                                                in + bulk,
 
2277
                                                out + bulk,
 
2278
                                                len - bulk, gctx->ctr))
 
2279
                    return -1;
 
2280
            } else {
 
2281
                size_t bulk = 0;
 
2282
# if defined(AES_GCM_ASM2)
 
2283
                if (len >= 16 && AES_GCM_ASM2(gctx)) {
 
2284
                    size_t res = (16 - gctx->gcm.mres) % 16;
 
2285
 
 
2286
                    if (CRYPTO_gcm128_decrypt(&gctx->gcm, in, out, res))
 
2287
                        return -1;
 
2288
 
 
2289
                    bulk = AES_gcm_decrypt(in + res,
 
2290
                                           out + res, len - res,
 
2291
                                           gctx->gcm.key,
 
2292
                                           gctx->gcm.Yi.c, gctx->gcm.Xi.u);
 
2293
                    gctx->gcm.len.u[1] += bulk;
 
2294
                    bulk += res;
 
2295
                }
 
2296
# endif
 
2297
                if (CRYPTO_gcm128_decrypt(&gctx->gcm,
 
2298
                                          in + bulk, out + bulk, len - bulk))
 
2299
                    return -1;
 
2300
            }
 
2301
        }
 
2302
        return len;
 
2303
    } else {
 
2304
        if (!ctx->encrypt) {
 
2305
            if (gctx->taglen < 0)
 
2306
                return -1;
 
2307
            if (CRYPTO_gcm128_finish(&gctx->gcm, ctx->buf, gctx->taglen) != 0)
 
2308
                return -1;
 
2309
            gctx->iv_set = 0;
 
2310
            return 0;
 
2311
        }
 
2312
        CRYPTO_gcm128_tag(&gctx->gcm, ctx->buf, 16);
 
2313
        gctx->taglen = 16;
 
2314
        /* Don't reuse the IV */
 
2315
        gctx->iv_set = 0;
 
2316
        return 0;
 
2317
    }
 
2318
 
 
2319
}
 
2320
 
 
2321
# define CUSTOM_FLAGS    (EVP_CIPH_FLAG_DEFAULT_ASN1 \
 
2322
                | EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER \
 
2323
                | EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT \
 
2324
                | EVP_CIPH_CUSTOM_COPY)
 
2325
 
 
2326
BLOCK_CIPHER_custom(NID_aes, 128, 1, 12, gcm, GCM,
 
2327
                    EVP_CIPH_FLAG_FIPS | EVP_CIPH_FLAG_AEAD_CIPHER |
 
2328
                    CUSTOM_FLAGS)
 
2329
    BLOCK_CIPHER_custom(NID_aes, 192, 1, 12, gcm, GCM,
 
2330
                    EVP_CIPH_FLAG_FIPS | EVP_CIPH_FLAG_AEAD_CIPHER |
 
2331
                    CUSTOM_FLAGS)
 
2332
    BLOCK_CIPHER_custom(NID_aes, 256, 1, 12, gcm, GCM,
 
2333
                    EVP_CIPH_FLAG_FIPS | EVP_CIPH_FLAG_AEAD_CIPHER |
 
2334
                    CUSTOM_FLAGS)
 
2335
 
 
2336
static int aes_xts_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
 
2337
{
 
2338
    EVP_AES_XTS_CTX *xctx = c->cipher_data;
 
2339
    if (type == EVP_CTRL_COPY) {
 
2340
        EVP_CIPHER_CTX *out = ptr;
 
2341
        EVP_AES_XTS_CTX *xctx_out = out->cipher_data;
 
2342
        if (xctx->xts.key1) {
 
2343
            if (xctx->xts.key1 != &xctx->ks1)
 
2344
                return 0;
 
2345
            xctx_out->xts.key1 = &xctx_out->ks1;
 
2346
        }
 
2347
        if (xctx->xts.key2) {
 
2348
            if (xctx->xts.key2 != &xctx->ks2)
 
2349
                return 0;
 
2350
            xctx_out->xts.key2 = &xctx_out->ks2;
 
2351
        }
 
2352
        return 1;
 
2353
    } else if (type != EVP_CTRL_INIT)
 
2354
        return -1;
 
2355
    /* key1 and key2 are used as an indicator both key and IV are set */
 
2356
    xctx->xts.key1 = NULL;
 
2357
    xctx->xts.key2 = NULL;
 
2358
    return 1;
 
2359
}
 
2360
 
 
2361
static int aes_xts_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
2362
                            const unsigned char *iv, int enc)
 
2363
{
 
2364
    EVP_AES_XTS_CTX *xctx = ctx->cipher_data;
 
2365
    if (!iv && !key)
 
2366
        return 1;
 
2367
 
 
2368
    if (key)
 
2369
        do {
 
2370
# ifdef AES_XTS_ASM
 
2371
            xctx->stream = enc ? AES_xts_encrypt : AES_xts_decrypt;
 
2372
# else
 
2373
            xctx->stream = NULL;
 
2374
# endif
 
2375
            /* key_len is two AES keys */
 
2376
# ifdef HWAES_CAPABLE
 
2377
            if (HWAES_CAPABLE) {
 
2378
                if (enc) {
 
2379
                    HWAES_set_encrypt_key(key, ctx->key_len * 4,
 
2380
                                          &xctx->ks1.ks);
 
2381
                    xctx->xts.block1 = (block128_f) HWAES_encrypt;
 
2382
                } else {
 
2383
                    HWAES_set_decrypt_key(key, ctx->key_len * 4,
 
2384
                                          &xctx->ks1.ks);
 
2385
                    xctx->xts.block1 = (block128_f) HWAES_decrypt;
 
2386
                }
 
2387
 
 
2388
                HWAES_set_encrypt_key(key + ctx->key_len / 2,
 
2389
                                      ctx->key_len * 4, &xctx->ks2.ks);
 
2390
                xctx->xts.block2 = (block128_f) HWAES_encrypt;
 
2391
 
 
2392
                xctx->xts.key1 = &xctx->ks1;
 
2393
                break;
 
2394
            } else
 
2395
# endif
 
2396
# ifdef BSAES_CAPABLE
 
2397
            if (BSAES_CAPABLE)
 
2398
                xctx->stream = enc ? bsaes_xts_encrypt : bsaes_xts_decrypt;
 
2399
            else
 
2400
# endif
 
2401
# ifdef VPAES_CAPABLE
 
2402
            if (VPAES_CAPABLE) {
 
2403
                if (enc) {
 
2404
                    vpaes_set_encrypt_key(key, ctx->key_len * 4,
 
2405
                                          &xctx->ks1.ks);
 
2406
                    xctx->xts.block1 = (block128_f) vpaes_encrypt;
 
2407
                } else {
 
2408
                    vpaes_set_decrypt_key(key, ctx->key_len * 4,
 
2409
                                          &xctx->ks1.ks);
 
2410
                    xctx->xts.block1 = (block128_f) vpaes_decrypt;
 
2411
                }
 
2412
 
 
2413
                vpaes_set_encrypt_key(key + ctx->key_len / 2,
 
2414
                                      ctx->key_len * 4, &xctx->ks2.ks);
 
2415
                xctx->xts.block2 = (block128_f) vpaes_encrypt;
 
2416
 
 
2417
                xctx->xts.key1 = &xctx->ks1;
 
2418
                break;
 
2419
            } else
 
2420
# endif
 
2421
                (void)0;        /* terminate potentially open 'else' */
 
2422
 
 
2423
            if (enc) {
 
2424
                AES_set_encrypt_key(key, ctx->key_len * 4, &xctx->ks1.ks);
 
2425
                xctx->xts.block1 = (block128_f) AES_encrypt;
 
2426
            } else {
 
2427
                AES_set_decrypt_key(key, ctx->key_len * 4, &xctx->ks1.ks);
 
2428
                xctx->xts.block1 = (block128_f) AES_decrypt;
 
2429
            }
 
2430
 
 
2431
            AES_set_encrypt_key(key + ctx->key_len / 2,
 
2432
                                ctx->key_len * 4, &xctx->ks2.ks);
 
2433
            xctx->xts.block2 = (block128_f) AES_encrypt;
 
2434
 
 
2435
            xctx->xts.key1 = &xctx->ks1;
 
2436
        } while (0);
 
2437
 
 
2438
    if (iv) {
 
2439
        xctx->xts.key2 = &xctx->ks2;
 
2440
        memcpy(ctx->iv, iv, 16);
 
2441
    }
 
2442
 
 
2443
    return 1;
 
2444
}
 
2445
 
 
2446
static int aes_xts_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
2447
                          const unsigned char *in, size_t len)
 
2448
{
 
2449
    EVP_AES_XTS_CTX *xctx = ctx->cipher_data;
 
2450
    if (!xctx->xts.key1 || !xctx->xts.key2)
 
2451
        return 0;
 
2452
    if (!out || !in || len < AES_BLOCK_SIZE)
 
2453
        return 0;
 
2454
    if (xctx->stream)
 
2455
        (*xctx->stream) (in, out, len,
 
2456
                         xctx->xts.key1, xctx->xts.key2, ctx->iv);
 
2457
    else if (CRYPTO_xts128_encrypt(&xctx->xts, ctx->iv, in, out, len,
 
2458
                                   ctx->encrypt))
 
2459
        return 0;
 
2460
    return 1;
 
2461
}
 
2462
 
 
2463
# define aes_xts_cleanup NULL
 
2464
 
 
2465
# define XTS_FLAGS       (EVP_CIPH_FLAG_DEFAULT_ASN1 | EVP_CIPH_CUSTOM_IV \
 
2466
                         | EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT \
 
2467
                         | EVP_CIPH_CUSTOM_COPY)
 
2468
 
 
2469
BLOCK_CIPHER_custom(NID_aes, 128, 1, 16, xts, XTS,
 
2470
                    EVP_CIPH_FLAG_FIPS | XTS_FLAGS)
 
2471
    BLOCK_CIPHER_custom(NID_aes, 256, 1, 16, xts, XTS,
 
2472
                    EVP_CIPH_FLAG_FIPS | XTS_FLAGS)
 
2473
 
 
2474
static int aes_ccm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
 
2475
{
 
2476
    EVP_AES_CCM_CTX *cctx = c->cipher_data;
 
2477
    switch (type) {
 
2478
    case EVP_CTRL_INIT:
 
2479
        cctx->key_set = 0;
 
2480
        cctx->iv_set = 0;
 
2481
        cctx->L = 8;
 
2482
        cctx->M = 12;
 
2483
        cctx->tag_set = 0;
 
2484
        cctx->len_set = 0;
 
2485
        return 1;
 
2486
 
 
2487
    case EVP_CTRL_CCM_SET_IVLEN:
 
2488
        arg = 15 - arg;
 
2489
    case EVP_CTRL_CCM_SET_L:
 
2490
        if (arg < 2 || arg > 8)
 
2491
            return 0;
 
2492
        cctx->L = arg;
 
2493
        return 1;
 
2494
 
 
2495
    case EVP_CTRL_CCM_SET_TAG:
 
2496
        if ((arg & 1) || arg < 4 || arg > 16)
 
2497
            return 0;
 
2498
        if (c->encrypt && ptr)
 
2499
            return 0;
 
2500
        if (ptr) {
 
2501
            cctx->tag_set = 1;
 
2502
            memcpy(c->buf, ptr, arg);
 
2503
        }
 
2504
        cctx->M = arg;
 
2505
        return 1;
 
2506
 
 
2507
    case EVP_CTRL_CCM_GET_TAG:
 
2508
        if (!c->encrypt || !cctx->tag_set)
 
2509
            return 0;
 
2510
        if (!CRYPTO_ccm128_tag(&cctx->ccm, ptr, (size_t)arg))
 
2511
            return 0;
 
2512
        cctx->tag_set = 0;
 
2513
        cctx->iv_set = 0;
 
2514
        cctx->len_set = 0;
 
2515
        return 1;
 
2516
 
 
2517
    case EVP_CTRL_COPY:
 
2518
        {
 
2519
            EVP_CIPHER_CTX *out = ptr;
 
2520
            EVP_AES_CCM_CTX *cctx_out = out->cipher_data;
 
2521
            if (cctx->ccm.key) {
 
2522
                if (cctx->ccm.key != &cctx->ks)
 
2523
                    return 0;
 
2524
                cctx_out->ccm.key = &cctx_out->ks;
 
2525
            }
 
2526
            return 1;
 
2527
        }
 
2528
 
 
2529
    default:
 
2530
        return -1;
 
2531
 
 
2532
    }
 
2533
}
 
2534
 
 
2535
static int aes_ccm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
2536
                            const unsigned char *iv, int enc)
 
2537
{
 
2538
    EVP_AES_CCM_CTX *cctx = ctx->cipher_data;
 
2539
    if (!iv && !key)
 
2540
        return 1;
 
2541
    if (key)
 
2542
        do {
 
2543
# ifdef HWAES_CAPABLE
 
2544
            if (HWAES_CAPABLE) {
 
2545
                HWAES_set_encrypt_key(key, ctx->key_len * 8, &cctx->ks.ks);
 
2546
 
 
2547
                CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
 
2548
                                   &cctx->ks, (block128_f) HWAES_encrypt);
 
2549
                cctx->str = NULL;
 
2550
                cctx->key_set = 1;
 
2551
                break;
 
2552
            } else
 
2553
# endif
 
2554
# ifdef VPAES_CAPABLE
 
2555
            if (VPAES_CAPABLE) {
 
2556
                vpaes_set_encrypt_key(key, ctx->key_len * 8, &cctx->ks.ks);
 
2557
                CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
 
2558
                                   &cctx->ks, (block128_f) vpaes_encrypt);
 
2559
                cctx->str = NULL;
 
2560
                cctx->key_set = 1;
 
2561
                break;
 
2562
            }
 
2563
# endif
 
2564
            AES_set_encrypt_key(key, ctx->key_len * 8, &cctx->ks.ks);
 
2565
            CRYPTO_ccm128_init(&cctx->ccm, cctx->M, cctx->L,
 
2566
                               &cctx->ks, (block128_f) AES_encrypt);
 
2567
            cctx->str = NULL;
 
2568
            cctx->key_set = 1;
 
2569
        } while (0);
 
2570
    if (iv) {
 
2571
        memcpy(ctx->iv, iv, 15 - cctx->L);
 
2572
        cctx->iv_set = 1;
 
2573
    }
 
2574
    return 1;
 
2575
}
 
2576
 
 
2577
static int aes_ccm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
2578
                          const unsigned char *in, size_t len)
 
2579
{
 
2580
    EVP_AES_CCM_CTX *cctx = ctx->cipher_data;
 
2581
    CCM128_CONTEXT *ccm = &cctx->ccm;
 
2582
    /* If not set up, return error */
 
2583
    if (!cctx->iv_set && !cctx->key_set)
 
2584
        return -1;
 
2585
    if (!ctx->encrypt && !cctx->tag_set)
 
2586
        return -1;
 
2587
    if (!out) {
 
2588
        if (!in) {
 
2589
            if (CRYPTO_ccm128_setiv(ccm, ctx->iv, 15 - cctx->L, len))
 
2590
                return -1;
 
2591
            cctx->len_set = 1;
 
2592
            return len;
 
2593
        }
 
2594
        /* If have AAD need message length */
 
2595
        if (!cctx->len_set && len)
 
2596
            return -1;
 
2597
        CRYPTO_ccm128_aad(ccm, in, len);
 
2598
        return len;
 
2599
    }
 
2600
    /* EVP_*Final() doesn't return any data */
 
2601
    if (!in)
 
2602
        return 0;
 
2603
    /* If not set length yet do it */
 
2604
    if (!cctx->len_set) {
 
2605
        if (CRYPTO_ccm128_setiv(ccm, ctx->iv, 15 - cctx->L, len))
 
2606
            return -1;
 
2607
        cctx->len_set = 1;
 
2608
    }
 
2609
    if (ctx->encrypt) {
 
2610
        if (cctx->str ? CRYPTO_ccm128_encrypt_ccm64(ccm, in, out, len,
 
2611
                                                    cctx->str) :
 
2612
            CRYPTO_ccm128_encrypt(ccm, in, out, len))
 
2613
            return -1;
 
2614
        cctx->tag_set = 1;
 
2615
        return len;
 
2616
    } else {
 
2617
        int rv = -1;
 
2618
        if (cctx->str ? !CRYPTO_ccm128_decrypt_ccm64(ccm, in, out, len,
 
2619
                                                     cctx->str) :
 
2620
            !CRYPTO_ccm128_decrypt(ccm, in, out, len)) {
 
2621
            unsigned char tag[16];
 
2622
            if (CRYPTO_ccm128_tag(ccm, tag, cctx->M)) {
 
2623
                if (!CRYPTO_memcmp(tag, ctx->buf, cctx->M))
 
2624
                    rv = len;
 
2625
            }
 
2626
        }
 
2627
        if (rv == -1)
 
2628
            OPENSSL_cleanse(out, len);
 
2629
        cctx->iv_set = 0;
 
2630
        cctx->tag_set = 0;
 
2631
        cctx->len_set = 0;
 
2632
        return rv;
 
2633
    }
 
2634
 
 
2635
}
 
2636
 
 
2637
# define aes_ccm_cleanup NULL
 
2638
 
 
2639
BLOCK_CIPHER_custom(NID_aes, 128, 1, 12, ccm, CCM,
 
2640
                    EVP_CIPH_FLAG_FIPS | CUSTOM_FLAGS)
 
2641
    BLOCK_CIPHER_custom(NID_aes, 192, 1, 12, ccm, CCM,
 
2642
                    EVP_CIPH_FLAG_FIPS | CUSTOM_FLAGS)
 
2643
    BLOCK_CIPHER_custom(NID_aes, 256, 1, 12, ccm, CCM,
 
2644
                    EVP_CIPH_FLAG_FIPS | CUSTOM_FLAGS)
 
2645
#endif
 
2646
typedef struct {
 
2647
    union {
 
2648
        double align;
 
2649
        AES_KEY ks;
 
2650
    } ks;
 
2651
    /* Indicates if IV has been set */
 
2652
    unsigned char *iv;
 
2653
} EVP_AES_WRAP_CTX;
 
2654
 
 
2655
static int aes_wrap_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
2656
                             const unsigned char *iv, int enc)
 
2657
{
 
2658
    EVP_AES_WRAP_CTX *wctx = ctx->cipher_data;
 
2659
    if (!iv && !key)
 
2660
        return 1;
 
2661
    if (key) {
 
2662
        if (ctx->encrypt)
 
2663
            AES_set_encrypt_key(key, ctx->key_len * 8, &wctx->ks.ks);
 
2664
        else
 
2665
            AES_set_decrypt_key(key, ctx->key_len * 8, &wctx->ks.ks);
 
2666
        if (!iv)
 
2667
            wctx->iv = NULL;
 
2668
    }
 
2669
    if (iv) {
 
2670
        memcpy(ctx->iv, iv, 8);
 
2671
        wctx->iv = ctx->iv;
 
2672
    }
 
2673
    return 1;
 
2674
}
 
2675
 
 
2676
static int aes_wrap_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
2677
                           const unsigned char *in, size_t inlen)
 
2678
{
 
2679
    EVP_AES_WRAP_CTX *wctx = ctx->cipher_data;
 
2680
    size_t rv;
 
2681
    if (!in)
 
2682
        return 0;
 
2683
    if (inlen % 8)
 
2684
        return -1;
 
2685
    if (ctx->encrypt && inlen < 8)
 
2686
        return -1;
 
2687
    if (!ctx->encrypt && inlen < 16)
 
2688
        return -1;
 
2689
    if (!out) {
 
2690
        if (ctx->encrypt)
 
2691
            return inlen + 8;
 
2692
        else
 
2693
            return inlen - 8;
 
2694
    }
 
2695
    if (ctx->encrypt)
 
2696
        rv = CRYPTO_128_wrap(&wctx->ks.ks, wctx->iv, out, in, inlen,
 
2697
                             (block128_f) AES_encrypt);
 
2698
    else
 
2699
        rv = CRYPTO_128_unwrap(&wctx->ks.ks, wctx->iv, out, in, inlen,
 
2700
                               (block128_f) AES_decrypt);
 
2701
    return rv ? (int)rv : -1;
 
2702
}
 
2703
 
 
2704
#define WRAP_FLAGS      (EVP_CIPH_WRAP_MODE \
 
2705
                | EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER \
 
2706
                | EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_FLAG_DEFAULT_ASN1)
 
2707
 
 
2708
static const EVP_CIPHER aes_128_wrap = {
 
2709
    NID_id_aes128_wrap,
 
2710
    8, 16, 8, WRAP_FLAGS,
 
2711
    aes_wrap_init_key, aes_wrap_cipher,
 
2712
    NULL,
 
2713
    sizeof(EVP_AES_WRAP_CTX),
 
2714
    NULL, NULL, NULL, NULL
 
2715
};
 
2716
 
 
2717
const EVP_CIPHER *EVP_aes_128_wrap(void)
 
2718
{
 
2719
    return &aes_128_wrap;
 
2720
}
 
2721
 
 
2722
static const EVP_CIPHER aes_192_wrap = {
 
2723
    NID_id_aes192_wrap,
 
2724
    8, 24, 8, WRAP_FLAGS,
 
2725
    aes_wrap_init_key, aes_wrap_cipher,
 
2726
    NULL,
 
2727
    sizeof(EVP_AES_WRAP_CTX),
 
2728
    NULL, NULL, NULL, NULL
 
2729
};
 
2730
 
 
2731
const EVP_CIPHER *EVP_aes_192_wrap(void)
 
2732
{
 
2733
    return &aes_192_wrap;
 
2734
}
 
2735
 
 
2736
static const EVP_CIPHER aes_256_wrap = {
 
2737
    NID_id_aes256_wrap,
 
2738
    8, 32, 8, WRAP_FLAGS,
 
2739
    aes_wrap_init_key, aes_wrap_cipher,
 
2740
    NULL,
 
2741
    sizeof(EVP_AES_WRAP_CTX),
 
2742
    NULL, NULL, NULL, NULL
 
2743
};
 
2744
 
 
2745
const EVP_CIPHER *EVP_aes_256_wrap(void)
 
2746
{
 
2747
    return &aes_256_wrap;
 
2748
}