CoCalc -- cipher

GitHub Repository: godotengine/godot
Path: blob/master/thirdparty/mbedtls/library/cipher_wrap.c
⁹⁸⁹⁸ views
1
/**
2
 * \file cipher_wrap.c
3
 *
4
 * \brief Generic cipher wrapper for Mbed TLS
5
 *
6
 * \author Adriaan de Jong <[email protected]>
7
 *
8
 *  Copyright The Mbed TLS Contributors
9
 *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
10
 */
11

12
#include "common.h"
13

14
#if defined(MBEDTLS_CIPHER_C)
15

16
#include "cipher_wrap.h"
17
#include "mbedtls/error.h"
18

19
#if defined(MBEDTLS_CHACHAPOLY_C)
20
#include "mbedtls/chachapoly.h"
21
#endif
22

23
#if defined(MBEDTLS_AES_C)
24
#include "mbedtls/aes.h"
25
#endif
26

27
#if defined(MBEDTLS_CAMELLIA_C)
28
#include "mbedtls/camellia.h"
29
#endif
30

31
#if defined(MBEDTLS_ARIA_C)
32
#include "mbedtls/aria.h"
33
#endif
34

35
#if defined(MBEDTLS_DES_C)
36
#include "mbedtls/des.h"
37
#endif
38

39
#if defined(MBEDTLS_CHACHA20_C)
40
#include "mbedtls/chacha20.h"
41
#endif
42

43
#if defined(MBEDTLS_GCM_C)
44
#include "mbedtls/gcm.h"
45
#endif
46

47
#if defined(MBEDTLS_CCM_C)
48
#include "mbedtls/ccm.h"
49
#endif
50

51
#if defined(MBEDTLS_NIST_KW_C)
52
#include "mbedtls/nist_kw.h"
53
#endif
54

55
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
56
#include <string.h>
57
#endif
58

59
#include "mbedtls/platform.h"
60

61
enum mbedtls_cipher_base_index {
62
#if defined(MBEDTLS_AES_C)
63
    MBEDTLS_CIPHER_BASE_INDEX_AES,
64
#endif
65
#if defined(MBEDTLS_ARIA_C)
66
    MBEDTLS_CIPHER_BASE_INDEX_ARIA,
67
#endif
68
#if defined(MBEDTLS_CAMELLIA_C)
69
    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA,
70
#endif
71
#if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
72
    MBEDTLS_CIPHER_BASE_INDEX_CCM_AES,
73
#endif
74
#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_ARIA_C)
75
    MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA,
76
#endif
77
#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_CAMELLIA_C)
78
    MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA,
79
#endif
80
#if defined(MBEDTLS_CHACHA20_C)
81
    MBEDTLS_CIPHER_BASE_INDEX_CHACHA20_BASE,
82
#endif
83
#if defined(MBEDTLS_CHACHAPOLY_C)
84
    MBEDTLS_CIPHER_BASE_INDEX_CHACHAPOLY_BASE,
85
#endif
86
#if defined(MBEDTLS_DES_C)
87
    MBEDTLS_CIPHER_BASE_INDEX_DES_EDE3,
88
#endif
89
#if defined(MBEDTLS_DES_C)
90
    MBEDTLS_CIPHER_BASE_INDEX_DES_EDE,
91
#endif
92
#if defined(MBEDTLS_DES_C)
93
    MBEDTLS_CIPHER_BASE_INDEX_DES,
94
#endif
95
#if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
96
    MBEDTLS_CIPHER_BASE_INDEX_GCM_AES,
97
#endif
98
#if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_ARIA_C)
99
    MBEDTLS_CIPHER_BASE_INDEX_GCM_ARIA,
100
#endif
101
#if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_CAMELLIA_C)
102
    MBEDTLS_CIPHER_BASE_INDEX_GCM_CAMELLIA,
103
#endif
104
#if defined(MBEDTLS_NIST_KW_C)
105
    MBEDTLS_CIPHER_BASE_INDEX_KW_AES,
106
#endif
107
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
108
    MBEDTLS_CIPHER_BASE_INDEX_NULL_BASE,
109
#endif
110
#if defined(MBEDTLS_CIPHER_MODE_XTS) && defined(MBEDTLS_AES_C)
111
    MBEDTLS_CIPHER_BASE_INDEX_XTS_AES,
112
#endif
113
    /* Prevent compile failure due to empty enum */
114
    MBEDTLS_CIPHER_BASE_PREVENT_EMPTY_ENUM
115
};
116

117
#if defined(MBEDTLS_GCM_C) && \
118
    (defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA) || \
119
    defined(MBEDTLS_ARIA_C) || defined(MBEDTLS_CAMELLIA_C))
120
/* shared by all GCM ciphers */
121
static void *gcm_ctx_alloc(void)
122
{
123
    void *ctx = mbedtls_calloc(1, sizeof(mbedtls_gcm_context));
124

125
    if (ctx != NULL) {
126
        mbedtls_gcm_init((mbedtls_gcm_context *) ctx);
127
    }
128

129
    return ctx;
130
}
131

132
static void gcm_ctx_free(void *ctx)
133
{
134
    mbedtls_gcm_free(ctx);
135
    mbedtls_free(ctx);
136
}
137
#endif /* MBEDTLS_GCM_C */
138

139
#if defined(MBEDTLS_CCM_C) && \
140
    (defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA) || \
141
    defined(MBEDTLS_ARIA_C) || defined(MBEDTLS_CAMELLIA_C))
142
/* shared by all CCM ciphers */
143
static void *ccm_ctx_alloc(void)
144
{
145
    void *ctx = mbedtls_calloc(1, sizeof(mbedtls_ccm_context));
146

147
    if (ctx != NULL) {
148
        mbedtls_ccm_init((mbedtls_ccm_context *) ctx);
149
    }
150

151
    return ctx;
152
}
153

154
static void ccm_ctx_free(void *ctx)
155
{
156
    mbedtls_ccm_free(ctx);
157
    mbedtls_free(ctx);
158
}
159
#endif /* MBEDTLS_CCM_C */
160

161
#if defined(MBEDTLS_AES_C)
162

163
static int aes_crypt_ecb_wrap(void *ctx, mbedtls_operation_t operation,
164
                              const unsigned char *input, unsigned char *output)
165
{
166
    return mbedtls_aes_crypt_ecb((mbedtls_aes_context *) ctx, operation, input, output);
167
}
168

169
#if defined(MBEDTLS_CIPHER_MODE_CBC)
170
static int aes_crypt_cbc_wrap(void *ctx, mbedtls_operation_t operation, size_t length,
171
                              unsigned char *iv, const unsigned char *input, unsigned char *output)
172
{
173
    return mbedtls_aes_crypt_cbc((mbedtls_aes_context *) ctx, operation, length, iv, input,
174
                                 output);
175
}
176
#endif /* MBEDTLS_CIPHER_MODE_CBC */
177

178
#if defined(MBEDTLS_CIPHER_MODE_CFB)
179
static int aes_crypt_cfb128_wrap(void *ctx, mbedtls_operation_t operation,
180
                                 size_t length, size_t *iv_off, unsigned char *iv,
181
                                 const unsigned char *input, unsigned char *output)
182
{
183
    return mbedtls_aes_crypt_cfb128((mbedtls_aes_context *) ctx, operation, length, iv_off, iv,
184
                                    input, output);
185
}
186
#endif /* MBEDTLS_CIPHER_MODE_CFB */
187

188
#if defined(MBEDTLS_CIPHER_MODE_OFB)
189
static int aes_crypt_ofb_wrap(void *ctx, size_t length, size_t *iv_off,
190
                              unsigned char *iv, const unsigned char *input, unsigned char *output)
191
{
192
    return mbedtls_aes_crypt_ofb((mbedtls_aes_context *) ctx, length, iv_off,
193
                                 iv, input, output);
194
}
195
#endif /* MBEDTLS_CIPHER_MODE_OFB */
196

197
#if defined(MBEDTLS_CIPHER_MODE_CTR)
198
static int aes_crypt_ctr_wrap(void *ctx, size_t length, size_t *nc_off,
199
                              unsigned char *nonce_counter, unsigned char *stream_block,
200
                              const unsigned char *input, unsigned char *output)
201
{
202
    return mbedtls_aes_crypt_ctr((mbedtls_aes_context *) ctx, length, nc_off, nonce_counter,
203
                                 stream_block, input, output);
204
}
205
#endif /* MBEDTLS_CIPHER_MODE_CTR */
206

207
#if defined(MBEDTLS_CIPHER_MODE_XTS)
208
static int aes_crypt_xts_wrap(void *ctx, mbedtls_operation_t operation,
209
                              size_t length,
210
                              const unsigned char data_unit[16],
211
                              const unsigned char *input,
212
                              unsigned char *output)
213
{
214
    mbedtls_aes_xts_context *xts_ctx = ctx;
215
    int mode;
216

217
    switch (operation) {
218
        case MBEDTLS_ENCRYPT:
219
            mode = MBEDTLS_AES_ENCRYPT;
220
            break;
221
        case MBEDTLS_DECRYPT:
222
            mode = MBEDTLS_AES_DECRYPT;
223
            break;
224
        default:
225
            return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
226
    }
227

228
    return mbedtls_aes_crypt_xts(xts_ctx, mode, length,
229
                                 data_unit, input, output);
230
}
231
#endif /* MBEDTLS_CIPHER_MODE_XTS */
232

233
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
234
static int aes_setkey_dec_wrap(void *ctx, const unsigned char *key,
235
                               unsigned int key_bitlen)
236
{
237
    return mbedtls_aes_setkey_dec((mbedtls_aes_context *) ctx, key, key_bitlen);
238
}
239
#endif
240

241
static int aes_setkey_enc_wrap(void *ctx, const unsigned char *key,
242
                               unsigned int key_bitlen)
243
{
244
    return mbedtls_aes_setkey_enc((mbedtls_aes_context *) ctx, key, key_bitlen);
245
}
246

247
static void *aes_ctx_alloc(void)
248
{
249
    mbedtls_aes_context *aes = mbedtls_calloc(1, sizeof(mbedtls_aes_context));
250

251
    if (aes == NULL) {
252
        return NULL;
253
    }
254

255
    mbedtls_aes_init(aes);
256

257
    return aes;
258
}
259

260
static void aes_ctx_free(void *ctx)
261
{
262
    mbedtls_aes_free((mbedtls_aes_context *) ctx);
263
    mbedtls_free(ctx);
264
}
265

266
static const mbedtls_cipher_base_t aes_info = {
267
    MBEDTLS_CIPHER_ID_AES,
268
    aes_crypt_ecb_wrap,
269
#if defined(MBEDTLS_CIPHER_MODE_CBC)
270
    aes_crypt_cbc_wrap,
271
#endif
272
#if defined(MBEDTLS_CIPHER_MODE_CFB)
273
    aes_crypt_cfb128_wrap,
274
#endif
275
#if defined(MBEDTLS_CIPHER_MODE_OFB)
276
    aes_crypt_ofb_wrap,
277
#endif
278
#if defined(MBEDTLS_CIPHER_MODE_CTR)
279
    aes_crypt_ctr_wrap,
280
#endif
281
#if defined(MBEDTLS_CIPHER_MODE_XTS)
282
    NULL,
283
#endif
284
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
285
    NULL,
286
#endif
287
    aes_setkey_enc_wrap,
288
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
289
    aes_setkey_dec_wrap,
290
#endif
291
    aes_ctx_alloc,
292
    aes_ctx_free
293
};
294

295
static const mbedtls_cipher_info_t aes_128_ecb_info = {
296
    "AES-128-ECB",
297
    16,
298
    0 >> MBEDTLS_IV_SIZE_SHIFT,
299
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
300
    MBEDTLS_MODE_ECB,
301
    MBEDTLS_CIPHER_AES_128_ECB,
302
    0,
303
    MBEDTLS_CIPHER_BASE_INDEX_AES
304
};
305

306
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
307
static const mbedtls_cipher_info_t aes_192_ecb_info = {
308
    "AES-192-ECB",
309
    16,
310
    0 >> MBEDTLS_IV_SIZE_SHIFT,
311
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
312
    MBEDTLS_MODE_ECB,
313
    MBEDTLS_CIPHER_AES_192_ECB,
314
    0,
315
    MBEDTLS_CIPHER_BASE_INDEX_AES
316
};
317

318
static const mbedtls_cipher_info_t aes_256_ecb_info = {
319
    "AES-256-ECB",
320
    16,
321
    0 >> MBEDTLS_IV_SIZE_SHIFT,
322
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
323
    MBEDTLS_MODE_ECB,
324
    MBEDTLS_CIPHER_AES_256_ECB,
325
    0,
326
    MBEDTLS_CIPHER_BASE_INDEX_AES
327
};
328
#endif
329

330
#if defined(MBEDTLS_CIPHER_MODE_CBC)
331
static const mbedtls_cipher_info_t aes_128_cbc_info = {
332
    "AES-128-CBC",
333
    16,
334
    16 >> MBEDTLS_IV_SIZE_SHIFT,
335
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
336
    MBEDTLS_MODE_CBC,
337
    MBEDTLS_CIPHER_AES_128_CBC,
338
    0,
339
    MBEDTLS_CIPHER_BASE_INDEX_AES
340
};
341

342
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
343
static const mbedtls_cipher_info_t aes_192_cbc_info = {
344
    "AES-192-CBC",
345
    16,
346
    16 >> MBEDTLS_IV_SIZE_SHIFT,
347
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
348
    MBEDTLS_MODE_CBC,
349
    MBEDTLS_CIPHER_AES_192_CBC,
350
    0,
351
    MBEDTLS_CIPHER_BASE_INDEX_AES
352
};
353

354
static const mbedtls_cipher_info_t aes_256_cbc_info = {
355
    "AES-256-CBC",
356
    16,
357
    16 >> MBEDTLS_IV_SIZE_SHIFT,
358
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
359
    MBEDTLS_MODE_CBC,
360
    MBEDTLS_CIPHER_AES_256_CBC,
361
    0,
362
    MBEDTLS_CIPHER_BASE_INDEX_AES
363
};
364
#endif
365
#endif /* MBEDTLS_CIPHER_MODE_CBC */
366

367
#if defined(MBEDTLS_CIPHER_MODE_CFB)
368
static const mbedtls_cipher_info_t aes_128_cfb128_info = {
369
    "AES-128-CFB128",
370
    16,
371
    16 >> MBEDTLS_IV_SIZE_SHIFT,
372
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
373
    MBEDTLS_MODE_CFB,
374
    MBEDTLS_CIPHER_AES_128_CFB128,
375
    0,
376
    MBEDTLS_CIPHER_BASE_INDEX_AES
377
};
378

379
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
380
static const mbedtls_cipher_info_t aes_192_cfb128_info = {
381
    "AES-192-CFB128",
382
    16,
383
    16 >> MBEDTLS_IV_SIZE_SHIFT,
384
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
385
    MBEDTLS_MODE_CFB,
386
    MBEDTLS_CIPHER_AES_192_CFB128,
387
    0,
388
    MBEDTLS_CIPHER_BASE_INDEX_AES
389
};
390

391
static const mbedtls_cipher_info_t aes_256_cfb128_info = {
392
    "AES-256-CFB128",
393
    16,
394
    16 >> MBEDTLS_IV_SIZE_SHIFT,
395
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
396
    MBEDTLS_MODE_CFB,
397
    MBEDTLS_CIPHER_AES_256_CFB128,
398
    0,
399
    MBEDTLS_CIPHER_BASE_INDEX_AES
400
};
401
#endif
402
#endif /* MBEDTLS_CIPHER_MODE_CFB */
403

404
#if defined(MBEDTLS_CIPHER_MODE_OFB)
405
static const mbedtls_cipher_info_t aes_128_ofb_info = {
406
    "AES-128-OFB",
407
    16,
408
    16 >> MBEDTLS_IV_SIZE_SHIFT,
409
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
410
    MBEDTLS_MODE_OFB,
411
    MBEDTLS_CIPHER_AES_128_OFB,
412
    0,
413
    MBEDTLS_CIPHER_BASE_INDEX_AES
414
};
415

416
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
417
static const mbedtls_cipher_info_t aes_192_ofb_info = {
418
    "AES-192-OFB",
419
    16,
420
    16 >> MBEDTLS_IV_SIZE_SHIFT,
421
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
422
    MBEDTLS_MODE_OFB,
423
    MBEDTLS_CIPHER_AES_192_OFB,
424
    0,
425
    MBEDTLS_CIPHER_BASE_INDEX_AES
426
};
427

428
static const mbedtls_cipher_info_t aes_256_ofb_info = {
429
    "AES-256-OFB",
430
    16,
431
    16 >> MBEDTLS_IV_SIZE_SHIFT,
432
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
433
    MBEDTLS_MODE_OFB,
434
    MBEDTLS_CIPHER_AES_256_OFB,
435
    0,
436
    MBEDTLS_CIPHER_BASE_INDEX_AES
437
};
438
#endif
439
#endif /* MBEDTLS_CIPHER_MODE_OFB */
440

441
#if defined(MBEDTLS_CIPHER_MODE_CTR)
442
static const mbedtls_cipher_info_t aes_128_ctr_info = {
443
    "AES-128-CTR",
444
    16,
445
    16 >> MBEDTLS_IV_SIZE_SHIFT,
446
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
447
    MBEDTLS_MODE_CTR,
448
    MBEDTLS_CIPHER_AES_128_CTR,
449
    0,
450
    MBEDTLS_CIPHER_BASE_INDEX_AES
451
};
452

453
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
454
static const mbedtls_cipher_info_t aes_192_ctr_info = {
455
    "AES-192-CTR",
456
    16,
457
    16 >> MBEDTLS_IV_SIZE_SHIFT,
458
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
459
    MBEDTLS_MODE_CTR,
460
    MBEDTLS_CIPHER_AES_192_CTR,
461
    0,
462
    MBEDTLS_CIPHER_BASE_INDEX_AES
463
};
464

465
static const mbedtls_cipher_info_t aes_256_ctr_info = {
466
    "AES-256-CTR",
467
    16,
468
    16 >> MBEDTLS_IV_SIZE_SHIFT,
469
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
470
    MBEDTLS_MODE_CTR,
471
    MBEDTLS_CIPHER_AES_256_CTR,
472
    0,
473
    MBEDTLS_CIPHER_BASE_INDEX_AES
474
};
475
#endif
476
#endif /* MBEDTLS_CIPHER_MODE_CTR */
477

478
#if defined(MBEDTLS_CIPHER_MODE_XTS)
479
static int xts_aes_setkey_enc_wrap(void *ctx, const unsigned char *key,
480
                                   unsigned int key_bitlen)
481
{
482
    mbedtls_aes_xts_context *xts_ctx = ctx;
483
    return mbedtls_aes_xts_setkey_enc(xts_ctx, key, key_bitlen);
484
}
485

486
static int xts_aes_setkey_dec_wrap(void *ctx, const unsigned char *key,
487
                                   unsigned int key_bitlen)
488
{
489
    mbedtls_aes_xts_context *xts_ctx = ctx;
490
    return mbedtls_aes_xts_setkey_dec(xts_ctx, key, key_bitlen);
491
}
492

493
static void *xts_aes_ctx_alloc(void)
494
{
495
    mbedtls_aes_xts_context *xts_ctx = mbedtls_calloc(1, sizeof(*xts_ctx));
496

497
    if (xts_ctx != NULL) {
498
        mbedtls_aes_xts_init(xts_ctx);
499
    }
500

501
    return xts_ctx;
502
}
503

504
static void xts_aes_ctx_free(void *ctx)
505
{
506
    mbedtls_aes_xts_context *xts_ctx = ctx;
507

508
    if (xts_ctx == NULL) {
509
        return;
510
    }
511

512
    mbedtls_aes_xts_free(xts_ctx);
513
    mbedtls_free(xts_ctx);
514
}
515

516
static const mbedtls_cipher_base_t xts_aes_info = {
517
    MBEDTLS_CIPHER_ID_AES,
518
    NULL,
519
#if defined(MBEDTLS_CIPHER_MODE_CBC)
520
    NULL,
521
#endif
522
#if defined(MBEDTLS_CIPHER_MODE_CFB)
523
    NULL,
524
#endif
525
#if defined(MBEDTLS_CIPHER_MODE_OFB)
526
    NULL,
527
#endif
528
#if defined(MBEDTLS_CIPHER_MODE_CTR)
529
    NULL,
530
#endif
531
#if defined(MBEDTLS_CIPHER_MODE_XTS)
532
    aes_crypt_xts_wrap,
533
#endif
534
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
535
    NULL,
536
#endif
537
    xts_aes_setkey_enc_wrap,
538
    xts_aes_setkey_dec_wrap,
539
    xts_aes_ctx_alloc,
540
    xts_aes_ctx_free
541
};
542

543
static const mbedtls_cipher_info_t aes_128_xts_info = {
544
    "AES-128-XTS",
545
    16,
546
    16 >> MBEDTLS_IV_SIZE_SHIFT,
547
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
548
    MBEDTLS_MODE_XTS,
549
    MBEDTLS_CIPHER_AES_128_XTS,
550
    0,
551
    MBEDTLS_CIPHER_BASE_INDEX_XTS_AES
552
};
553

554
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
555
static const mbedtls_cipher_info_t aes_256_xts_info = {
556
    "AES-256-XTS",
557
    16,
558
    16 >> MBEDTLS_IV_SIZE_SHIFT,
559
    512 >> MBEDTLS_KEY_BITLEN_SHIFT,
560
    MBEDTLS_MODE_XTS,
561
    MBEDTLS_CIPHER_AES_256_XTS,
562
    0,
563
    MBEDTLS_CIPHER_BASE_INDEX_XTS_AES
564
};
565
#endif
566
#endif /* MBEDTLS_CIPHER_MODE_XTS */
567
#endif /* MBEDTLS_AES_C */
568

569
#if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_CCM_GCM_CAN_AES)
570
static int gcm_aes_setkey_wrap(void *ctx, const unsigned char *key,
571
                               unsigned int key_bitlen)
572
{
573
    return mbedtls_gcm_setkey((mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
574
                              key, key_bitlen);
575
}
576
#endif /* MBEDTLS_GCM_C && MBEDTLS_CCM_GCM_CAN_AES */
577

578
#if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
579
static const mbedtls_cipher_base_t gcm_aes_info = {
580
    MBEDTLS_CIPHER_ID_AES,
581
    NULL,
582
#if defined(MBEDTLS_CIPHER_MODE_CBC)
583
    NULL,
584
#endif
585
#if defined(MBEDTLS_CIPHER_MODE_CFB)
586
    NULL,
587
#endif
588
#if defined(MBEDTLS_CIPHER_MODE_OFB)
589
    NULL,
590
#endif
591
#if defined(MBEDTLS_CIPHER_MODE_CTR)
592
    NULL,
593
#endif
594
#if defined(MBEDTLS_CIPHER_MODE_XTS)
595
    NULL,
596
#endif
597
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
598
    NULL,
599
#endif
600
#if defined(MBEDTLS_GCM_C)
601
    gcm_aes_setkey_wrap,
602
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
603
    gcm_aes_setkey_wrap,
604
#endif
605
    gcm_ctx_alloc,
606
    gcm_ctx_free,
607
#else
608
    NULL,
609
    NULL,
610
    NULL,
611
    NULL,
612
#endif /* MBEDTLS_GCM_C */
613
};
614
#endif /* MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA */
615

616
#if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
617
static const mbedtls_cipher_info_t aes_128_gcm_info = {
618
    "AES-128-GCM",
619
    16,
620
    12 >> MBEDTLS_IV_SIZE_SHIFT,
621
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
622
    MBEDTLS_MODE_GCM,
623
    MBEDTLS_CIPHER_AES_128_GCM,
624
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
625
    MBEDTLS_CIPHER_BASE_INDEX_GCM_AES
626
};
627

628
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
629
static const mbedtls_cipher_info_t aes_192_gcm_info = {
630
    "AES-192-GCM",
631
    16,
632
    12 >> MBEDTLS_IV_SIZE_SHIFT,
633
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
634
    MBEDTLS_MODE_GCM,
635
    MBEDTLS_CIPHER_AES_192_GCM,
636
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
637
    MBEDTLS_CIPHER_BASE_INDEX_GCM_AES
638
};
639

640
static const mbedtls_cipher_info_t aes_256_gcm_info = {
641
    "AES-256-GCM",
642
    16,
643
    12 >> MBEDTLS_IV_SIZE_SHIFT,
644
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
645
    MBEDTLS_MODE_GCM,
646
    MBEDTLS_CIPHER_AES_256_GCM,
647
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
648
    MBEDTLS_CIPHER_BASE_INDEX_GCM_AES
649
};
650
#endif
651
#endif /* MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA */
652

653
#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_CCM_GCM_CAN_AES)
654
static int ccm_aes_setkey_wrap(void *ctx, const unsigned char *key,
655
                               unsigned int key_bitlen)
656
{
657
    return mbedtls_ccm_setkey((mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
658
                              key, key_bitlen);
659
}
660
#endif /* MBEDTLS_CCM_C && MBEDTLS_CCM_GCM_CAN_AES */
661

662
#if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
663
static const mbedtls_cipher_base_t ccm_aes_info = {
664
    MBEDTLS_CIPHER_ID_AES,
665
    NULL,
666
#if defined(MBEDTLS_CIPHER_MODE_CBC)
667
    NULL,
668
#endif
669
#if defined(MBEDTLS_CIPHER_MODE_CFB)
670
    NULL,
671
#endif
672
#if defined(MBEDTLS_CIPHER_MODE_OFB)
673
    NULL,
674
#endif
675
#if defined(MBEDTLS_CIPHER_MODE_CTR)
676
    NULL,
677
#endif
678
#if defined(MBEDTLS_CIPHER_MODE_XTS)
679
    NULL,
680
#endif
681
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
682
    NULL,
683
#endif
684
#if defined(MBEDTLS_CCM_C)
685
    ccm_aes_setkey_wrap,
686
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
687
    ccm_aes_setkey_wrap,
688
#endif
689
    ccm_ctx_alloc,
690
    ccm_ctx_free,
691
#else
692
    NULL,
693
    NULL,
694
    NULL,
695
    NULL,
696
#endif
697
};
698
#endif /* MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA */
699

700
#if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
701
static const mbedtls_cipher_info_t aes_128_ccm_info = {
702
    "AES-128-CCM",
703
    16,
704
    12 >> MBEDTLS_IV_SIZE_SHIFT,
705
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
706
    MBEDTLS_MODE_CCM,
707
    MBEDTLS_CIPHER_AES_128_CCM,
708
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
709
    MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
710
};
711

712
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
713
static const mbedtls_cipher_info_t aes_192_ccm_info = {
714
    "AES-192-CCM",
715
    16,
716
    12 >> MBEDTLS_IV_SIZE_SHIFT,
717
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
718
    MBEDTLS_MODE_CCM,
719
    MBEDTLS_CIPHER_AES_192_CCM,
720
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
721
    MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
722
};
723

724
static const mbedtls_cipher_info_t aes_256_ccm_info = {
725
    "AES-256-CCM",
726
    16,
727
    12 >> MBEDTLS_IV_SIZE_SHIFT,
728
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
729
    MBEDTLS_MODE_CCM,
730
    MBEDTLS_CIPHER_AES_256_CCM,
731
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
732
    MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
733
};
734
#endif
735
#endif /* MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA */
736

737
#if defined(MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_AES_VIA_LEGACY_OR_USE_PSA)
738
static const mbedtls_cipher_info_t aes_128_ccm_star_no_tag_info = {
739
    "AES-128-CCM*-NO-TAG",
740
    16,
741
    12 >> MBEDTLS_IV_SIZE_SHIFT,
742
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
743
    MBEDTLS_MODE_CCM_STAR_NO_TAG,
744
    MBEDTLS_CIPHER_AES_128_CCM_STAR_NO_TAG,
745
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
746
    MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
747
};
748

749
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
750
static const mbedtls_cipher_info_t aes_192_ccm_star_no_tag_info = {
751
    "AES-192-CCM*-NO-TAG",
752
    16,
753
    12 >> MBEDTLS_IV_SIZE_SHIFT,
754
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
755
    MBEDTLS_MODE_CCM_STAR_NO_TAG,
756
    MBEDTLS_CIPHER_AES_192_CCM_STAR_NO_TAG,
757
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
758
    MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
759
};
760

761
static const mbedtls_cipher_info_t aes_256_ccm_star_no_tag_info = {
762
    "AES-256-CCM*-NO-TAG",
763
    16,
764
    12 >> MBEDTLS_IV_SIZE_SHIFT,
765
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
766
    MBEDTLS_MODE_CCM_STAR_NO_TAG,
767
    MBEDTLS_CIPHER_AES_256_CCM_STAR_NO_TAG,
768
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
769
    MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
770
};
771
#endif
772
#endif /* MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_AES_VIA_LEGACY_OR_USE_PSA */
773

774

775
#if defined(MBEDTLS_CAMELLIA_C)
776

777
static int camellia_crypt_ecb_wrap(void *ctx, mbedtls_operation_t operation,
778
                                   const unsigned char *input, unsigned char *output)
779
{
780
    return mbedtls_camellia_crypt_ecb((mbedtls_camellia_context *) ctx, operation, input,
781
                                      output);
782
}
783

784
#if defined(MBEDTLS_CIPHER_MODE_CBC)
785
static int camellia_crypt_cbc_wrap(void *ctx, mbedtls_operation_t operation,
786
                                   size_t length, unsigned char *iv,
787
                                   const unsigned char *input, unsigned char *output)
788
{
789
    return mbedtls_camellia_crypt_cbc((mbedtls_camellia_context *) ctx, operation, length, iv,
790
                                      input, output);
791
}
792
#endif /* MBEDTLS_CIPHER_MODE_CBC */
793

794
#if defined(MBEDTLS_CIPHER_MODE_CFB)
795
static int camellia_crypt_cfb128_wrap(void *ctx, mbedtls_operation_t operation,
796
                                      size_t length, size_t *iv_off, unsigned char *iv,
797
                                      const unsigned char *input, unsigned char *output)
798
{
799
    return mbedtls_camellia_crypt_cfb128((mbedtls_camellia_context *) ctx, operation, length,
800
                                         iv_off, iv, input, output);
801
}
802
#endif /* MBEDTLS_CIPHER_MODE_CFB */
803

804
#if defined(MBEDTLS_CIPHER_MODE_CTR)
805
static int camellia_crypt_ctr_wrap(void *ctx, size_t length, size_t *nc_off,
806
                                   unsigned char *nonce_counter, unsigned char *stream_block,
807
                                   const unsigned char *input, unsigned char *output)
808
{
809
    return mbedtls_camellia_crypt_ctr((mbedtls_camellia_context *) ctx, length, nc_off,
810
                                      nonce_counter, stream_block, input, output);
811
}
812
#endif /* MBEDTLS_CIPHER_MODE_CTR */
813

814
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
815
static int camellia_setkey_dec_wrap(void *ctx, const unsigned char *key,
816
                                    unsigned int key_bitlen)
817
{
818
    return mbedtls_camellia_setkey_dec((mbedtls_camellia_context *) ctx, key, key_bitlen);
819
}
820
#endif
821

822
static int camellia_setkey_enc_wrap(void *ctx, const unsigned char *key,
823
                                    unsigned int key_bitlen)
824
{
825
    return mbedtls_camellia_setkey_enc((mbedtls_camellia_context *) ctx, key, key_bitlen);
826
}
827

828
static void *camellia_ctx_alloc(void)
829
{
830
    mbedtls_camellia_context *ctx;
831
    ctx = mbedtls_calloc(1, sizeof(mbedtls_camellia_context));
832

833
    if (ctx == NULL) {
834
        return NULL;
835
    }
836

837
    mbedtls_camellia_init(ctx);
838

839
    return ctx;
840
}
841

842
static void camellia_ctx_free(void *ctx)
843
{
844
    mbedtls_camellia_free((mbedtls_camellia_context *) ctx);
845
    mbedtls_free(ctx);
846
}
847

848
static const mbedtls_cipher_base_t camellia_info = {
849
    MBEDTLS_CIPHER_ID_CAMELLIA,
850
    camellia_crypt_ecb_wrap,
851
#if defined(MBEDTLS_CIPHER_MODE_CBC)
852
    camellia_crypt_cbc_wrap,
853
#endif
854
#if defined(MBEDTLS_CIPHER_MODE_CFB)
855
    camellia_crypt_cfb128_wrap,
856
#endif
857
#if defined(MBEDTLS_CIPHER_MODE_OFB)
858
    NULL,
859
#endif
860
#if defined(MBEDTLS_CIPHER_MODE_CTR)
861
    camellia_crypt_ctr_wrap,
862
#endif
863
#if defined(MBEDTLS_CIPHER_MODE_XTS)
864
    NULL,
865
#endif
866
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
867
    NULL,
868
#endif
869
    camellia_setkey_enc_wrap,
870
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
871
    camellia_setkey_dec_wrap,
872
#endif
873
    camellia_ctx_alloc,
874
    camellia_ctx_free
875
};
876

877
static const mbedtls_cipher_info_t camellia_128_ecb_info = {
878
    "CAMELLIA-128-ECB",
879
    16,
880
    0 >> MBEDTLS_IV_SIZE_SHIFT,
881
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
882
    MBEDTLS_MODE_ECB,
883
    MBEDTLS_CIPHER_CAMELLIA_128_ECB,
884
    0,
885
    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
886
};
887

888
static const mbedtls_cipher_info_t camellia_192_ecb_info = {
889
    "CAMELLIA-192-ECB",
890
    16,
891
    0 >> MBEDTLS_IV_SIZE_SHIFT,
892
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
893
    MBEDTLS_MODE_ECB,
894
    MBEDTLS_CIPHER_CAMELLIA_192_ECB,
895
    0,
896
    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
897
};
898

899
static const mbedtls_cipher_info_t camellia_256_ecb_info = {
900
    "CAMELLIA-256-ECB",
901
    16,
902
    0 >> MBEDTLS_IV_SIZE_SHIFT,
903
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
904
    MBEDTLS_MODE_ECB,
905
    MBEDTLS_CIPHER_CAMELLIA_256_ECB,
906
    0,
907
    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
908
};
909

910
#if defined(MBEDTLS_CIPHER_MODE_CBC)
911
static const mbedtls_cipher_info_t camellia_128_cbc_info = {
912
    "CAMELLIA-128-CBC",
913
    16,
914
    16 >> MBEDTLS_IV_SIZE_SHIFT,
915
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
916
    MBEDTLS_MODE_CBC,
917
    MBEDTLS_CIPHER_CAMELLIA_128_CBC,
918
    0,
919
    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
920
};
921

922
static const mbedtls_cipher_info_t camellia_192_cbc_info = {
923
    "CAMELLIA-192-CBC",
924
    16,
925
    16 >> MBEDTLS_IV_SIZE_SHIFT,
926
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
927
    MBEDTLS_MODE_CBC,
928
    MBEDTLS_CIPHER_CAMELLIA_192_CBC,
929
    0,
930
    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
931
};
932

933
static const mbedtls_cipher_info_t camellia_256_cbc_info = {
934
    "CAMELLIA-256-CBC",
935
    16,
936
    16 >> MBEDTLS_IV_SIZE_SHIFT,
937
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
938
    MBEDTLS_MODE_CBC,
939
    MBEDTLS_CIPHER_CAMELLIA_256_CBC,
940
    0,
941
    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
942
};
943
#endif /* MBEDTLS_CIPHER_MODE_CBC */
944

945
#if defined(MBEDTLS_CIPHER_MODE_CFB)
946
static const mbedtls_cipher_info_t camellia_128_cfb128_info = {
947
    "CAMELLIA-128-CFB128",
948
    16,
949
    16 >> MBEDTLS_IV_SIZE_SHIFT,
950
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
951
    MBEDTLS_MODE_CFB,
952
    MBEDTLS_CIPHER_CAMELLIA_128_CFB128,
953
    0,
954
    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
955
};
956

957
static const mbedtls_cipher_info_t camellia_192_cfb128_info = {
958
    "CAMELLIA-192-CFB128",
959
    16,
960
    16 >> MBEDTLS_IV_SIZE_SHIFT,
961
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
962
    MBEDTLS_MODE_CFB,
963
    MBEDTLS_CIPHER_CAMELLIA_192_CFB128,
964
    0,
965
    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
966
};
967

968
static const mbedtls_cipher_info_t camellia_256_cfb128_info = {
969
    "CAMELLIA-256-CFB128",
970
    16,
971
    16 >> MBEDTLS_IV_SIZE_SHIFT,
972
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
973
    MBEDTLS_MODE_CFB,
974
    MBEDTLS_CIPHER_CAMELLIA_256_CFB128,
975
    0,
976
    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
977
};
978
#endif /* MBEDTLS_CIPHER_MODE_CFB */
979

980
#if defined(MBEDTLS_CIPHER_MODE_CTR)
981
static const mbedtls_cipher_info_t camellia_128_ctr_info = {
982
    "CAMELLIA-128-CTR",
983
    16,
984
    16 >> MBEDTLS_IV_SIZE_SHIFT,
985
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
986
    MBEDTLS_MODE_CTR,
987
    MBEDTLS_CIPHER_CAMELLIA_128_CTR,
988
    0,
989
    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
990
};
991

992
static const mbedtls_cipher_info_t camellia_192_ctr_info = {
993
    "CAMELLIA-192-CTR",
994
    16,
995
    16 >> MBEDTLS_IV_SIZE_SHIFT,
996
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
997
    MBEDTLS_MODE_CTR,
998
    MBEDTLS_CIPHER_CAMELLIA_192_CTR,
999
    0,
1000
    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
1001
};
1002

1003
static const mbedtls_cipher_info_t camellia_256_ctr_info = {
1004
    "CAMELLIA-256-CTR",
1005
    16,
1006
    16 >> MBEDTLS_IV_SIZE_SHIFT,
1007
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1008
    MBEDTLS_MODE_CTR,
1009
    MBEDTLS_CIPHER_CAMELLIA_256_CTR,
1010
    0,
1011
    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA
1012
};
1013
#endif /* MBEDTLS_CIPHER_MODE_CTR */
1014

1015
#if defined(MBEDTLS_GCM_C)
1016
static int gcm_camellia_setkey_wrap(void *ctx, const unsigned char *key,
1017
                                    unsigned int key_bitlen)
1018
{
1019
    return mbedtls_gcm_setkey((mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA,
1020
                              key, key_bitlen);
1021
}
1022

1023
static const mbedtls_cipher_base_t gcm_camellia_info = {
1024
    MBEDTLS_CIPHER_ID_CAMELLIA,
1025
    NULL,
1026
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1027
    NULL,
1028
#endif
1029
#if defined(MBEDTLS_CIPHER_MODE_CFB)
1030
    NULL,
1031
#endif
1032
#if defined(MBEDTLS_CIPHER_MODE_OFB)
1033
    NULL,
1034
#endif
1035
#if defined(MBEDTLS_CIPHER_MODE_CTR)
1036
    NULL,
1037
#endif
1038
#if defined(MBEDTLS_CIPHER_MODE_XTS)
1039
    NULL,
1040
#endif
1041
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1042
    NULL,
1043
#endif
1044
    gcm_camellia_setkey_wrap,
1045
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1046
    gcm_camellia_setkey_wrap,
1047
#endif
1048
    gcm_ctx_alloc,
1049
    gcm_ctx_free,
1050
};
1051

1052
static const mbedtls_cipher_info_t camellia_128_gcm_info = {
1053
    "CAMELLIA-128-GCM",
1054
    16,
1055
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1056
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1057
    MBEDTLS_MODE_GCM,
1058
    MBEDTLS_CIPHER_CAMELLIA_128_GCM,
1059
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1060
    MBEDTLS_CIPHER_BASE_INDEX_GCM_CAMELLIA
1061
};
1062

1063
static const mbedtls_cipher_info_t camellia_192_gcm_info = {
1064
    "CAMELLIA-192-GCM",
1065
    16,
1066
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1067
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1068
    MBEDTLS_MODE_GCM,
1069
    MBEDTLS_CIPHER_CAMELLIA_192_GCM,
1070
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1071
    MBEDTLS_CIPHER_BASE_INDEX_GCM_CAMELLIA
1072
};
1073

1074
static const mbedtls_cipher_info_t camellia_256_gcm_info = {
1075
    "CAMELLIA-256-GCM",
1076
    16,
1077
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1078
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1079
    MBEDTLS_MODE_GCM,
1080
    MBEDTLS_CIPHER_CAMELLIA_256_GCM,
1081
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1082
    MBEDTLS_CIPHER_BASE_INDEX_GCM_CAMELLIA
1083
};
1084
#endif /* MBEDTLS_GCM_C */
1085

1086
#if defined(MBEDTLS_CCM_C)
1087
static int ccm_camellia_setkey_wrap(void *ctx, const unsigned char *key,
1088
                                    unsigned int key_bitlen)
1089
{
1090
    return mbedtls_ccm_setkey((mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA,
1091
                              key, key_bitlen);
1092
}
1093

1094
static const mbedtls_cipher_base_t ccm_camellia_info = {
1095
    MBEDTLS_CIPHER_ID_CAMELLIA,
1096
    NULL,
1097
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1098
    NULL,
1099
#endif
1100
#if defined(MBEDTLS_CIPHER_MODE_CFB)
1101
    NULL,
1102
#endif
1103
#if defined(MBEDTLS_CIPHER_MODE_OFB)
1104
    NULL,
1105
#endif
1106
#if defined(MBEDTLS_CIPHER_MODE_CTR)
1107
    NULL,
1108
#endif
1109
#if defined(MBEDTLS_CIPHER_MODE_XTS)
1110
    NULL,
1111
#endif
1112
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1113
    NULL,
1114
#endif
1115
    ccm_camellia_setkey_wrap,
1116
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1117
    ccm_camellia_setkey_wrap,
1118
#endif
1119
    ccm_ctx_alloc,
1120
    ccm_ctx_free,
1121
};
1122

1123
static const mbedtls_cipher_info_t camellia_128_ccm_info = {
1124
    "CAMELLIA-128-CCM",
1125
    16,
1126
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1127
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1128
    MBEDTLS_MODE_CCM,
1129
    MBEDTLS_CIPHER_CAMELLIA_128_CCM,
1130
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1131
    MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA
1132
};
1133

1134
static const mbedtls_cipher_info_t camellia_192_ccm_info = {
1135
    "CAMELLIA-192-CCM",
1136
    16,
1137
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1138
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1139
    MBEDTLS_MODE_CCM,
1140
    MBEDTLS_CIPHER_CAMELLIA_192_CCM,
1141
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1142
    MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA
1143
};
1144

1145
static const mbedtls_cipher_info_t camellia_256_ccm_info = {
1146
    "CAMELLIA-256-CCM",
1147
    16,
1148
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1149
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1150
    MBEDTLS_MODE_CCM,
1151
    MBEDTLS_CIPHER_CAMELLIA_256_CCM,
1152
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1153
    MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA
1154
};
1155

1156
static const mbedtls_cipher_info_t camellia_128_ccm_star_no_tag_info = {
1157
    "CAMELLIA-128-CCM*-NO-TAG",
1158
    16,
1159
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1160
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1161
    MBEDTLS_MODE_CCM_STAR_NO_TAG,
1162
    MBEDTLS_CIPHER_CAMELLIA_128_CCM_STAR_NO_TAG,
1163
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1164
    MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA
1165
};
1166

1167
static const mbedtls_cipher_info_t camellia_192_ccm_star_no_tag_info = {
1168
    "CAMELLIA-192-CCM*-NO-TAG",
1169
    16,
1170
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1171
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1172
    MBEDTLS_MODE_CCM_STAR_NO_TAG,
1173
    MBEDTLS_CIPHER_CAMELLIA_192_CCM_STAR_NO_TAG,
1174
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1175
    MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA
1176
};
1177

1178
static const mbedtls_cipher_info_t camellia_256_ccm_star_no_tag_info = {
1179
    "CAMELLIA-256-CCM*-NO-TAG",
1180
    16,
1181
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1182
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1183
    MBEDTLS_MODE_CCM_STAR_NO_TAG,
1184
    MBEDTLS_CIPHER_CAMELLIA_256_CCM_STAR_NO_TAG,
1185
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1186
    MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA
1187
};
1188
#endif /* MBEDTLS_CCM_C */
1189

1190
#endif /* MBEDTLS_CAMELLIA_C */
1191

1192
#if defined(MBEDTLS_ARIA_C)
1193

1194
static int aria_crypt_ecb_wrap(void *ctx, mbedtls_operation_t operation,
1195
                               const unsigned char *input, unsigned char *output)
1196
{
1197
    (void) operation;
1198
    return mbedtls_aria_crypt_ecb((mbedtls_aria_context *) ctx, input,
1199
                                  output);
1200
}
1201

1202
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1203
static int aria_crypt_cbc_wrap(void *ctx, mbedtls_operation_t operation,
1204
                               size_t length, unsigned char *iv,
1205
                               const unsigned char *input, unsigned char *output)
1206
{
1207
    return mbedtls_aria_crypt_cbc((mbedtls_aria_context *) ctx, operation, length, iv,
1208
                                  input, output);
1209
}
1210
#endif /* MBEDTLS_CIPHER_MODE_CBC */
1211

1212
#if defined(MBEDTLS_CIPHER_MODE_CFB)
1213
static int aria_crypt_cfb128_wrap(void *ctx, mbedtls_operation_t operation,
1214
                                  size_t length, size_t *iv_off, unsigned char *iv,
1215
                                  const unsigned char *input, unsigned char *output)
1216
{
1217
    return mbedtls_aria_crypt_cfb128((mbedtls_aria_context *) ctx, operation, length,
1218
                                     iv_off, iv, input, output);
1219
}
1220
#endif /* MBEDTLS_CIPHER_MODE_CFB */
1221

1222
#if defined(MBEDTLS_CIPHER_MODE_CTR)
1223
static int aria_crypt_ctr_wrap(void *ctx, size_t length, size_t *nc_off,
1224
                               unsigned char *nonce_counter, unsigned char *stream_block,
1225
                               const unsigned char *input, unsigned char *output)
1226
{
1227
    return mbedtls_aria_crypt_ctr((mbedtls_aria_context *) ctx, length, nc_off,
1228
                                  nonce_counter, stream_block, input, output);
1229
}
1230
#endif /* MBEDTLS_CIPHER_MODE_CTR */
1231

1232
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1233
static int aria_setkey_dec_wrap(void *ctx, const unsigned char *key,
1234
                                unsigned int key_bitlen)
1235
{
1236
    return mbedtls_aria_setkey_dec((mbedtls_aria_context *) ctx, key, key_bitlen);
1237
}
1238
#endif
1239

1240
static int aria_setkey_enc_wrap(void *ctx, const unsigned char *key,
1241
                                unsigned int key_bitlen)
1242
{
1243
    return mbedtls_aria_setkey_enc((mbedtls_aria_context *) ctx, key, key_bitlen);
1244
}
1245

1246
static void *aria_ctx_alloc(void)
1247
{
1248
    mbedtls_aria_context *ctx;
1249
    ctx = mbedtls_calloc(1, sizeof(mbedtls_aria_context));
1250

1251
    if (ctx == NULL) {
1252
        return NULL;
1253
    }
1254

1255
    mbedtls_aria_init(ctx);
1256

1257
    return ctx;
1258
}
1259

1260
static void aria_ctx_free(void *ctx)
1261
{
1262
    mbedtls_aria_free((mbedtls_aria_context *) ctx);
1263
    mbedtls_free(ctx);
1264
}
1265

1266
static const mbedtls_cipher_base_t aria_info = {
1267
    MBEDTLS_CIPHER_ID_ARIA,
1268
    aria_crypt_ecb_wrap,
1269
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1270
    aria_crypt_cbc_wrap,
1271
#endif
1272
#if defined(MBEDTLS_CIPHER_MODE_CFB)
1273
    aria_crypt_cfb128_wrap,
1274
#endif
1275
#if defined(MBEDTLS_CIPHER_MODE_OFB)
1276
    NULL,
1277
#endif
1278
#if defined(MBEDTLS_CIPHER_MODE_CTR)
1279
    aria_crypt_ctr_wrap,
1280
#endif
1281
#if defined(MBEDTLS_CIPHER_MODE_XTS)
1282
    NULL,
1283
#endif
1284
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1285
    NULL,
1286
#endif
1287
    aria_setkey_enc_wrap,
1288
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1289
    aria_setkey_dec_wrap,
1290
#endif
1291
    aria_ctx_alloc,
1292
    aria_ctx_free
1293
};
1294

1295
static const mbedtls_cipher_info_t aria_128_ecb_info = {
1296
    "ARIA-128-ECB",
1297
    16,
1298
    0 >> MBEDTLS_IV_SIZE_SHIFT,
1299
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1300
    MBEDTLS_MODE_ECB,
1301
    MBEDTLS_CIPHER_ARIA_128_ECB,
1302
    0,
1303
    MBEDTLS_CIPHER_BASE_INDEX_ARIA
1304
};
1305

1306
static const mbedtls_cipher_info_t aria_192_ecb_info = {
1307
    "ARIA-192-ECB",
1308
    16,
1309
    0 >> MBEDTLS_IV_SIZE_SHIFT,
1310
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1311
    MBEDTLS_MODE_ECB,
1312
    MBEDTLS_CIPHER_ARIA_192_ECB,
1313
    0,
1314
    MBEDTLS_CIPHER_BASE_INDEX_ARIA
1315
};
1316

1317
static const mbedtls_cipher_info_t aria_256_ecb_info = {
1318
    "ARIA-256-ECB",
1319
    16,
1320
    0 >> MBEDTLS_IV_SIZE_SHIFT,
1321
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1322
    MBEDTLS_MODE_ECB,
1323
    MBEDTLS_CIPHER_ARIA_256_ECB,
1324
    0,
1325
    MBEDTLS_CIPHER_BASE_INDEX_ARIA
1326
};
1327

1328
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1329
static const mbedtls_cipher_info_t aria_128_cbc_info = {
1330
    "ARIA-128-CBC",
1331
    16,
1332
    16 >> MBEDTLS_IV_SIZE_SHIFT,
1333
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1334
    MBEDTLS_MODE_CBC,
1335
    MBEDTLS_CIPHER_ARIA_128_CBC,
1336
    0,
1337
    MBEDTLS_CIPHER_BASE_INDEX_ARIA
1338
};
1339

1340
static const mbedtls_cipher_info_t aria_192_cbc_info = {
1341
    "ARIA-192-CBC",
1342
    16,
1343
    16 >> MBEDTLS_IV_SIZE_SHIFT,
1344
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1345
    MBEDTLS_MODE_CBC,
1346
    MBEDTLS_CIPHER_ARIA_192_CBC,
1347
    0,
1348
    MBEDTLS_CIPHER_BASE_INDEX_ARIA
1349
};
1350

1351
static const mbedtls_cipher_info_t aria_256_cbc_info = {
1352
    "ARIA-256-CBC",
1353
    16,
1354
    16 >> MBEDTLS_IV_SIZE_SHIFT,
1355
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1356
    MBEDTLS_MODE_CBC,
1357
    MBEDTLS_CIPHER_ARIA_256_CBC,
1358
    0,
1359
    MBEDTLS_CIPHER_BASE_INDEX_ARIA
1360
};
1361
#endif /* MBEDTLS_CIPHER_MODE_CBC */
1362

1363
#if defined(MBEDTLS_CIPHER_MODE_CFB)
1364
static const mbedtls_cipher_info_t aria_128_cfb128_info = {
1365
    "ARIA-128-CFB128",
1366
    16,
1367
    16 >> MBEDTLS_IV_SIZE_SHIFT,
1368
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1369
    MBEDTLS_MODE_CFB,
1370
    MBEDTLS_CIPHER_ARIA_128_CFB128,
1371
    0,
1372
    MBEDTLS_CIPHER_BASE_INDEX_ARIA
1373
};
1374

1375
static const mbedtls_cipher_info_t aria_192_cfb128_info = {
1376
    "ARIA-192-CFB128",
1377
    16,
1378
    16 >> MBEDTLS_IV_SIZE_SHIFT,
1379
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1380
    MBEDTLS_MODE_CFB,
1381
    MBEDTLS_CIPHER_ARIA_192_CFB128,
1382
    0,
1383
    MBEDTLS_CIPHER_BASE_INDEX_ARIA
1384
};
1385

1386
static const mbedtls_cipher_info_t aria_256_cfb128_info = {
1387
    "ARIA-256-CFB128",
1388
    16,
1389
    16 >> MBEDTLS_IV_SIZE_SHIFT,
1390
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1391
    MBEDTLS_MODE_CFB,
1392
    MBEDTLS_CIPHER_ARIA_256_CFB128,
1393
    0,
1394
    MBEDTLS_CIPHER_BASE_INDEX_ARIA
1395
};
1396
#endif /* MBEDTLS_CIPHER_MODE_CFB */
1397

1398
#if defined(MBEDTLS_CIPHER_MODE_CTR)
1399
static const mbedtls_cipher_info_t aria_128_ctr_info = {
1400
    "ARIA-128-CTR",
1401
    16,
1402
    16 >> MBEDTLS_IV_SIZE_SHIFT,
1403
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1404
    MBEDTLS_MODE_CTR,
1405
    MBEDTLS_CIPHER_ARIA_128_CTR,
1406
    0,
1407
    MBEDTLS_CIPHER_BASE_INDEX_ARIA
1408
};
1409

1410
static const mbedtls_cipher_info_t aria_192_ctr_info = {
1411
    "ARIA-192-CTR",
1412
    16,
1413
    16 >> MBEDTLS_IV_SIZE_SHIFT,
1414
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1415
    MBEDTLS_MODE_CTR,
1416
    MBEDTLS_CIPHER_ARIA_192_CTR,
1417
    0,
1418
    MBEDTLS_CIPHER_BASE_INDEX_ARIA
1419
};
1420

1421
static const mbedtls_cipher_info_t aria_256_ctr_info = {
1422
    "ARIA-256-CTR",
1423
    16,
1424
    16 >> MBEDTLS_IV_SIZE_SHIFT,
1425
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1426
    MBEDTLS_MODE_CTR,
1427
    MBEDTLS_CIPHER_ARIA_256_CTR,
1428
    0,
1429
    MBEDTLS_CIPHER_BASE_INDEX_ARIA
1430
};
1431
#endif /* MBEDTLS_CIPHER_MODE_CTR */
1432

1433
#if defined(MBEDTLS_GCM_C)
1434
static int gcm_aria_setkey_wrap(void *ctx, const unsigned char *key,
1435
                                unsigned int key_bitlen)
1436
{
1437
    return mbedtls_gcm_setkey((mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_ARIA,
1438
                              key, key_bitlen);
1439
}
1440

1441
static const mbedtls_cipher_base_t gcm_aria_info = {
1442
    MBEDTLS_CIPHER_ID_ARIA,
1443
    NULL,
1444
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1445
    NULL,
1446
#endif
1447
#if defined(MBEDTLS_CIPHER_MODE_CFB)
1448
    NULL,
1449
#endif
1450
#if defined(MBEDTLS_CIPHER_MODE_OFB)
1451
    NULL,
1452
#endif
1453
#if defined(MBEDTLS_CIPHER_MODE_CTR)
1454
    NULL,
1455
#endif
1456
#if defined(MBEDTLS_CIPHER_MODE_XTS)
1457
    NULL,
1458
#endif
1459
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1460
    NULL,
1461
#endif
1462
    gcm_aria_setkey_wrap,
1463
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1464
    gcm_aria_setkey_wrap,
1465
#endif
1466
    gcm_ctx_alloc,
1467
    gcm_ctx_free,
1468
};
1469

1470
static const mbedtls_cipher_info_t aria_128_gcm_info = {
1471
    "ARIA-128-GCM",
1472
    16,
1473
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1474
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1475
    MBEDTLS_MODE_GCM,
1476
    MBEDTLS_CIPHER_ARIA_128_GCM,
1477
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1478
    MBEDTLS_CIPHER_BASE_INDEX_GCM_ARIA
1479
};
1480

1481
static const mbedtls_cipher_info_t aria_192_gcm_info = {
1482
    "ARIA-192-GCM",
1483
    16,
1484
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1485
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1486
    MBEDTLS_MODE_GCM,
1487
    MBEDTLS_CIPHER_ARIA_192_GCM,
1488
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1489
    MBEDTLS_CIPHER_BASE_INDEX_GCM_ARIA
1490
};
1491

1492
static const mbedtls_cipher_info_t aria_256_gcm_info = {
1493
    "ARIA-256-GCM",
1494
    16,
1495
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1496
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1497
    MBEDTLS_MODE_GCM,
1498
    MBEDTLS_CIPHER_ARIA_256_GCM,
1499
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1500
    MBEDTLS_CIPHER_BASE_INDEX_GCM_ARIA
1501
};
1502
#endif /* MBEDTLS_GCM_C */
1503

1504
#if defined(MBEDTLS_CCM_C)
1505
static int ccm_aria_setkey_wrap(void *ctx, const unsigned char *key,
1506
                                unsigned int key_bitlen)
1507
{
1508
    return mbedtls_ccm_setkey((mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_ARIA,
1509
                              key, key_bitlen);
1510
}
1511

1512
static const mbedtls_cipher_base_t ccm_aria_info = {
1513
    MBEDTLS_CIPHER_ID_ARIA,
1514
    NULL,
1515
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1516
    NULL,
1517
#endif
1518
#if defined(MBEDTLS_CIPHER_MODE_CFB)
1519
    NULL,
1520
#endif
1521
#if defined(MBEDTLS_CIPHER_MODE_OFB)
1522
    NULL,
1523
#endif
1524
#if defined(MBEDTLS_CIPHER_MODE_CTR)
1525
    NULL,
1526
#endif
1527
#if defined(MBEDTLS_CIPHER_MODE_XTS)
1528
    NULL,
1529
#endif
1530
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1531
    NULL,
1532
#endif
1533
    ccm_aria_setkey_wrap,
1534
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1535
    ccm_aria_setkey_wrap,
1536
#endif
1537
    ccm_ctx_alloc,
1538
    ccm_ctx_free,
1539
};
1540

1541
static const mbedtls_cipher_info_t aria_128_ccm_info = {
1542
    "ARIA-128-CCM",
1543
    16,
1544
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1545
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1546
    MBEDTLS_MODE_CCM,
1547
    MBEDTLS_CIPHER_ARIA_128_CCM,
1548
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1549
    MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA
1550
};
1551

1552
static const mbedtls_cipher_info_t aria_192_ccm_info = {
1553
    "ARIA-192-CCM",
1554
    16,
1555
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1556
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1557
    MBEDTLS_MODE_CCM,
1558
    MBEDTLS_CIPHER_ARIA_192_CCM,
1559
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1560
    MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA
1561
};
1562

1563
static const mbedtls_cipher_info_t aria_256_ccm_info = {
1564
    "ARIA-256-CCM",
1565
    16,
1566
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1567
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1568
    MBEDTLS_MODE_CCM,
1569
    MBEDTLS_CIPHER_ARIA_256_CCM,
1570
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1571
    MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA
1572
};
1573

1574
static const mbedtls_cipher_info_t aria_128_ccm_star_no_tag_info = {
1575
    "ARIA-128-CCM*-NO-TAG",
1576
    16,
1577
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1578
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
1579
    MBEDTLS_MODE_CCM_STAR_NO_TAG,
1580
    MBEDTLS_CIPHER_ARIA_128_CCM_STAR_NO_TAG,
1581
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1582
    MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA
1583
};
1584

1585
static const mbedtls_cipher_info_t aria_192_ccm_star_no_tag_info = {
1586
    "ARIA-192-CCM*-NO-TAG",
1587
    16,
1588
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1589
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
1590
    MBEDTLS_MODE_CCM_STAR_NO_TAG,
1591
    MBEDTLS_CIPHER_ARIA_192_CCM_STAR_NO_TAG,
1592
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1593
    MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA
1594
};
1595

1596
static const mbedtls_cipher_info_t aria_256_ccm_star_no_tag_info = {
1597
    "ARIA-256-CCM*-NO-TAG",
1598
    16,
1599
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1600
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1601
    MBEDTLS_MODE_CCM_STAR_NO_TAG,
1602
    MBEDTLS_CIPHER_ARIA_256_CCM_STAR_NO_TAG,
1603
    MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1604
    MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA
1605
};
1606
#endif /* MBEDTLS_CCM_C */
1607

1608
#endif /* MBEDTLS_ARIA_C */
1609

1610
#if defined(MBEDTLS_DES_C)
1611

1612
static int des_crypt_ecb_wrap(void *ctx, mbedtls_operation_t operation,
1613
                              const unsigned char *input, unsigned char *output)
1614
{
1615
    ((void) operation);
1616
    return mbedtls_des_crypt_ecb((mbedtls_des_context *) ctx, input, output);
1617
}
1618

1619
static int des3_crypt_ecb_wrap(void *ctx, mbedtls_operation_t operation,
1620
                               const unsigned char *input, unsigned char *output)
1621
{
1622
    ((void) operation);
1623
    return mbedtls_des3_crypt_ecb((mbedtls_des3_context *) ctx, input, output);
1624
}
1625

1626
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1627
static int des_crypt_cbc_wrap(void *ctx, mbedtls_operation_t operation, size_t length,
1628
                              unsigned char *iv, const unsigned char *input, unsigned char *output)
1629
{
1630
    return mbedtls_des_crypt_cbc((mbedtls_des_context *) ctx, operation, length, iv, input,
1631
                                 output);
1632
}
1633
#endif /* MBEDTLS_CIPHER_MODE_CBC */
1634

1635
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1636
static int des3_crypt_cbc_wrap(void *ctx, mbedtls_operation_t operation, size_t length,
1637
                               unsigned char *iv, const unsigned char *input, unsigned char *output)
1638
{
1639
    return mbedtls_des3_crypt_cbc((mbedtls_des3_context *) ctx, operation, length, iv, input,
1640
                                  output);
1641
}
1642
#endif /* MBEDTLS_CIPHER_MODE_CBC */
1643

1644
static int des_setkey_dec_wrap(void *ctx, const unsigned char *key,
1645
                               unsigned int key_bitlen)
1646
{
1647
    ((void) key_bitlen);
1648

1649
    return mbedtls_des_setkey_dec((mbedtls_des_context *) ctx, key);
1650
}
1651

1652
static int des_setkey_enc_wrap(void *ctx, const unsigned char *key,
1653
                               unsigned int key_bitlen)
1654
{
1655
    ((void) key_bitlen);
1656

1657
    return mbedtls_des_setkey_enc((mbedtls_des_context *) ctx, key);
1658
}
1659

1660
static int des3_set2key_dec_wrap(void *ctx, const unsigned char *key,
1661
                                 unsigned int key_bitlen)
1662
{
1663
    ((void) key_bitlen);
1664

1665
    return mbedtls_des3_set2key_dec((mbedtls_des3_context *) ctx, key);
1666
}
1667

1668
static int des3_set2key_enc_wrap(void *ctx, const unsigned char *key,
1669
                                 unsigned int key_bitlen)
1670
{
1671
    ((void) key_bitlen);
1672

1673
    return mbedtls_des3_set2key_enc((mbedtls_des3_context *) ctx, key);
1674
}
1675

1676
static int des3_set3key_dec_wrap(void *ctx, const unsigned char *key,
1677
                                 unsigned int key_bitlen)
1678
{
1679
    ((void) key_bitlen);
1680

1681
    return mbedtls_des3_set3key_dec((mbedtls_des3_context *) ctx, key);
1682
}
1683

1684
static int des3_set3key_enc_wrap(void *ctx, const unsigned char *key,
1685
                                 unsigned int key_bitlen)
1686
{
1687
    ((void) key_bitlen);
1688

1689
    return mbedtls_des3_set3key_enc((mbedtls_des3_context *) ctx, key);
1690
}
1691

1692
static void *des_ctx_alloc(void)
1693
{
1694
    mbedtls_des_context *des = mbedtls_calloc(1, sizeof(mbedtls_des_context));
1695

1696
    if (des == NULL) {
1697
        return NULL;
1698
    }
1699

1700
    mbedtls_des_init(des);
1701

1702
    return des;
1703
}
1704

1705
static void des_ctx_free(void *ctx)
1706
{
1707
    mbedtls_des_free((mbedtls_des_context *) ctx);
1708
    mbedtls_free(ctx);
1709
}
1710

1711
static void *des3_ctx_alloc(void)
1712
{
1713
    mbedtls_des3_context *des3;
1714
    des3 = mbedtls_calloc(1, sizeof(mbedtls_des3_context));
1715

1716
    if (des3 == NULL) {
1717
        return NULL;
1718
    }
1719

1720
    mbedtls_des3_init(des3);
1721

1722
    return des3;
1723
}
1724

1725
static void des3_ctx_free(void *ctx)
1726
{
1727
    mbedtls_des3_free((mbedtls_des3_context *) ctx);
1728
    mbedtls_free(ctx);
1729
}
1730

1731
static const mbedtls_cipher_base_t des_info = {
1732
    MBEDTLS_CIPHER_ID_DES,
1733
    des_crypt_ecb_wrap,
1734
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1735
    des_crypt_cbc_wrap,
1736
#endif
1737
#if defined(MBEDTLS_CIPHER_MODE_CFB)
1738
    NULL,
1739
#endif
1740
#if defined(MBEDTLS_CIPHER_MODE_OFB)
1741
    NULL,
1742
#endif
1743
#if defined(MBEDTLS_CIPHER_MODE_CTR)
1744
    NULL,
1745
#endif
1746
#if defined(MBEDTLS_CIPHER_MODE_XTS)
1747
    NULL,
1748
#endif
1749
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1750
    NULL,
1751
#endif
1752
    des_setkey_enc_wrap,
1753
    des_setkey_dec_wrap,
1754
    des_ctx_alloc,
1755
    des_ctx_free
1756
};
1757

1758
static const mbedtls_cipher_info_t des_ecb_info = {
1759
    "DES-ECB",
1760
    8,
1761
    0 >> MBEDTLS_IV_SIZE_SHIFT,
1762
    MBEDTLS_KEY_LENGTH_DES >> MBEDTLS_KEY_BITLEN_SHIFT,
1763
    MBEDTLS_MODE_ECB,
1764
    MBEDTLS_CIPHER_DES_ECB,
1765
    0,
1766
    MBEDTLS_CIPHER_BASE_INDEX_DES
1767
};
1768

1769
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1770
static const mbedtls_cipher_info_t des_cbc_info = {
1771
    "DES-CBC",
1772
    8,
1773
    8 >> MBEDTLS_IV_SIZE_SHIFT,
1774
    MBEDTLS_KEY_LENGTH_DES >> MBEDTLS_KEY_BITLEN_SHIFT,
1775
    MBEDTLS_MODE_CBC,
1776
    MBEDTLS_CIPHER_DES_CBC,
1777
    0,
1778
    MBEDTLS_CIPHER_BASE_INDEX_DES
1779
};
1780
#endif /* MBEDTLS_CIPHER_MODE_CBC */
1781

1782
static const mbedtls_cipher_base_t des_ede_info = {
1783
    MBEDTLS_CIPHER_ID_DES,
1784
    des3_crypt_ecb_wrap,
1785
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1786
    des3_crypt_cbc_wrap,
1787
#endif
1788
#if defined(MBEDTLS_CIPHER_MODE_CFB)
1789
    NULL,
1790
#endif
1791
#if defined(MBEDTLS_CIPHER_MODE_OFB)
1792
    NULL,
1793
#endif
1794
#if defined(MBEDTLS_CIPHER_MODE_CTR)
1795
    NULL,
1796
#endif
1797
#if defined(MBEDTLS_CIPHER_MODE_XTS)
1798
    NULL,
1799
#endif
1800
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1801
    NULL,
1802
#endif
1803
    des3_set2key_enc_wrap,
1804
    des3_set2key_dec_wrap,
1805
    des3_ctx_alloc,
1806
    des3_ctx_free
1807
};
1808

1809
static const mbedtls_cipher_info_t des_ede_ecb_info = {
1810
    "DES-EDE-ECB",
1811
    8,
1812
    0 >> MBEDTLS_IV_SIZE_SHIFT,
1813
    MBEDTLS_KEY_LENGTH_DES_EDE >> MBEDTLS_KEY_BITLEN_SHIFT,
1814
    MBEDTLS_MODE_ECB,
1815
    MBEDTLS_CIPHER_DES_EDE_ECB,
1816
    0,
1817
    MBEDTLS_CIPHER_BASE_INDEX_DES_EDE
1818
};
1819

1820
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1821
static const mbedtls_cipher_info_t des_ede_cbc_info = {
1822
    "DES-EDE-CBC",
1823
    8,
1824
    8 >> MBEDTLS_IV_SIZE_SHIFT,
1825
    MBEDTLS_KEY_LENGTH_DES_EDE >> MBEDTLS_KEY_BITLEN_SHIFT,
1826
    MBEDTLS_MODE_CBC,
1827
    MBEDTLS_CIPHER_DES_EDE_CBC,
1828
    0,
1829
    MBEDTLS_CIPHER_BASE_INDEX_DES_EDE
1830
};
1831
#endif /* MBEDTLS_CIPHER_MODE_CBC */
1832

1833
static const mbedtls_cipher_base_t des_ede3_info = {
1834
    MBEDTLS_CIPHER_ID_3DES,
1835
    des3_crypt_ecb_wrap,
1836
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1837
    des3_crypt_cbc_wrap,
1838
#endif
1839
#if defined(MBEDTLS_CIPHER_MODE_CFB)
1840
    NULL,
1841
#endif
1842
#if defined(MBEDTLS_CIPHER_MODE_OFB)
1843
    NULL,
1844
#endif
1845
#if defined(MBEDTLS_CIPHER_MODE_CTR)
1846
    NULL,
1847
#endif
1848
#if defined(MBEDTLS_CIPHER_MODE_XTS)
1849
    NULL,
1850
#endif
1851
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1852
    NULL,
1853
#endif
1854
    des3_set3key_enc_wrap,
1855
    des3_set3key_dec_wrap,
1856
    des3_ctx_alloc,
1857
    des3_ctx_free
1858
};
1859

1860
static const mbedtls_cipher_info_t des_ede3_ecb_info = {
1861
    "DES-EDE3-ECB",
1862
    8,
1863
    0 >> MBEDTLS_IV_SIZE_SHIFT,
1864
    MBEDTLS_KEY_LENGTH_DES_EDE3 >> MBEDTLS_KEY_BITLEN_SHIFT,
1865
    MBEDTLS_MODE_ECB,
1866
    MBEDTLS_CIPHER_DES_EDE3_ECB,
1867
    0,
1868
    MBEDTLS_CIPHER_BASE_INDEX_DES_EDE3
1869
};
1870
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1871
static const mbedtls_cipher_info_t des_ede3_cbc_info = {
1872
    "DES-EDE3-CBC",
1873
    8,
1874
    8 >> MBEDTLS_IV_SIZE_SHIFT,
1875
    MBEDTLS_KEY_LENGTH_DES_EDE3 >> MBEDTLS_KEY_BITLEN_SHIFT,
1876
    MBEDTLS_MODE_CBC,
1877
    MBEDTLS_CIPHER_DES_EDE3_CBC,
1878
    0,
1879
    MBEDTLS_CIPHER_BASE_INDEX_DES_EDE3
1880
};
1881
#endif /* MBEDTLS_CIPHER_MODE_CBC */
1882
#endif /* MBEDTLS_DES_C */
1883

1884
#if defined(MBEDTLS_CHACHA20_C)
1885

1886
static int chacha20_setkey_wrap(void *ctx, const unsigned char *key,
1887
                                unsigned int key_bitlen)
1888
{
1889
    if (key_bitlen != 256U) {
1890
        return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
1891
    }
1892

1893
    if (0 != mbedtls_chacha20_setkey((mbedtls_chacha20_context *) ctx, key)) {
1894
        return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
1895
    }
1896

1897
    return 0;
1898
}
1899

1900
static int chacha20_stream_wrap(void *ctx,  size_t length,
1901
                                const unsigned char *input,
1902
                                unsigned char *output)
1903
{
1904
    int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
1905

1906
    ret = mbedtls_chacha20_update(ctx, length, input, output);
1907
    if (ret == MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA) {
1908
        return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
1909
    }
1910

1911
    return ret;
1912
}
1913

1914
static void *chacha20_ctx_alloc(void)
1915
{
1916
    mbedtls_chacha20_context *ctx;
1917
    ctx = mbedtls_calloc(1, sizeof(mbedtls_chacha20_context));
1918

1919
    if (ctx == NULL) {
1920
        return NULL;
1921
    }
1922

1923
    mbedtls_chacha20_init(ctx);
1924

1925
    return ctx;
1926
}
1927

1928
static void chacha20_ctx_free(void *ctx)
1929
{
1930
    mbedtls_chacha20_free((mbedtls_chacha20_context *) ctx);
1931
    mbedtls_free(ctx);
1932
}
1933

1934
static const mbedtls_cipher_base_t chacha20_base_info = {
1935
    MBEDTLS_CIPHER_ID_CHACHA20,
1936
    NULL,
1937
#if defined(MBEDTLS_CIPHER_MODE_CBC)
1938
    NULL,
1939
#endif
1940
#if defined(MBEDTLS_CIPHER_MODE_CFB)
1941
    NULL,
1942
#endif
1943
#if defined(MBEDTLS_CIPHER_MODE_OFB)
1944
    NULL,
1945
#endif
1946
#if defined(MBEDTLS_CIPHER_MODE_CTR)
1947
    NULL,
1948
#endif
1949
#if defined(MBEDTLS_CIPHER_MODE_XTS)
1950
    NULL,
1951
#endif
1952
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1953
    chacha20_stream_wrap,
1954
#endif
1955
    chacha20_setkey_wrap,
1956
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
1957
    chacha20_setkey_wrap,
1958
#endif
1959
    chacha20_ctx_alloc,
1960
    chacha20_ctx_free
1961
};
1962
static const mbedtls_cipher_info_t chacha20_info = {
1963
    "CHACHA20",
1964
    1,
1965
    12 >> MBEDTLS_IV_SIZE_SHIFT,
1966
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
1967
    MBEDTLS_MODE_STREAM,
1968
    MBEDTLS_CIPHER_CHACHA20,
1969
    0,
1970
    MBEDTLS_CIPHER_BASE_INDEX_CHACHA20_BASE
1971
};
1972
#endif /* MBEDTLS_CHACHA20_C */
1973

1974
#if defined(MBEDTLS_CHACHAPOLY_C)
1975

1976
static int chachapoly_setkey_wrap(void *ctx,
1977
                                  const unsigned char *key,
1978
                                  unsigned int key_bitlen)
1979
{
1980
    if (key_bitlen != 256U) {
1981
        return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
1982
    }
1983

1984
    if (0 != mbedtls_chachapoly_setkey((mbedtls_chachapoly_context *) ctx, key)) {
1985
        return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
1986
    }
1987

1988
    return 0;
1989
}
1990

1991
static void *chachapoly_ctx_alloc(void)
1992
{
1993
    mbedtls_chachapoly_context *ctx;
1994
    ctx = mbedtls_calloc(1, sizeof(mbedtls_chachapoly_context));
1995

1996
    if (ctx == NULL) {
1997
        return NULL;
1998
    }
1999

2000
    mbedtls_chachapoly_init(ctx);
2001

2002
    return ctx;
2003
}
2004

2005
static void chachapoly_ctx_free(void *ctx)
2006
{
2007
    mbedtls_chachapoly_free((mbedtls_chachapoly_context *) ctx);
2008
    mbedtls_free(ctx);
2009
}
2010

2011
static const mbedtls_cipher_base_t chachapoly_base_info = {
2012
    MBEDTLS_CIPHER_ID_CHACHA20,
2013
    NULL,
2014
#if defined(MBEDTLS_CIPHER_MODE_CBC)
2015
    NULL,
2016
#endif
2017
#if defined(MBEDTLS_CIPHER_MODE_CFB)
2018
    NULL,
2019
#endif
2020
#if defined(MBEDTLS_CIPHER_MODE_OFB)
2021
    NULL,
2022
#endif
2023
#if defined(MBEDTLS_CIPHER_MODE_CTR)
2024
    NULL,
2025
#endif
2026
#if defined(MBEDTLS_CIPHER_MODE_XTS)
2027
    NULL,
2028
#endif
2029
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
2030
    NULL,
2031
#endif
2032
    chachapoly_setkey_wrap,
2033
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
2034
    chachapoly_setkey_wrap,
2035
#endif
2036
    chachapoly_ctx_alloc,
2037
    chachapoly_ctx_free
2038
};
2039
static const mbedtls_cipher_info_t chachapoly_info = {
2040
    "CHACHA20-POLY1305",
2041
    1,
2042
    12 >> MBEDTLS_IV_SIZE_SHIFT,
2043
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
2044
    MBEDTLS_MODE_CHACHAPOLY,
2045
    MBEDTLS_CIPHER_CHACHA20_POLY1305,
2046
    0,
2047
    MBEDTLS_CIPHER_BASE_INDEX_CHACHAPOLY_BASE
2048
};
2049
#endif /* MBEDTLS_CHACHAPOLY_C */
2050

2051
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
2052
static int null_crypt_stream(void *ctx, size_t length,
2053
                             const unsigned char *input,
2054
                             unsigned char *output)
2055
{
2056
    ((void) ctx);
2057
    memmove(output, input, length);
2058
    return 0;
2059
}
2060

2061
static int null_setkey(void *ctx, const unsigned char *key,
2062
                       unsigned int key_bitlen)
2063
{
2064
    ((void) ctx);
2065
    ((void) key);
2066
    ((void) key_bitlen);
2067

2068
    return 0;
2069
}
2070

2071
static void *null_ctx_alloc(void)
2072
{
2073
    return (void *) 1;
2074
}
2075

2076
static void null_ctx_free(void *ctx)
2077
{
2078
    ((void) ctx);
2079
}
2080

2081
static const mbedtls_cipher_base_t null_base_info = {
2082
    MBEDTLS_CIPHER_ID_NULL,
2083
    NULL,
2084
#if defined(MBEDTLS_CIPHER_MODE_CBC)
2085
    NULL,
2086
#endif
2087
#if defined(MBEDTLS_CIPHER_MODE_CFB)
2088
    NULL,
2089
#endif
2090
#if defined(MBEDTLS_CIPHER_MODE_OFB)
2091
    NULL,
2092
#endif
2093
#if defined(MBEDTLS_CIPHER_MODE_CTR)
2094
    NULL,
2095
#endif
2096
#if defined(MBEDTLS_CIPHER_MODE_XTS)
2097
    NULL,
2098
#endif
2099
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
2100
    null_crypt_stream,
2101
#endif
2102
    null_setkey,
2103
#if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
2104
    null_setkey,
2105
#endif
2106
    null_ctx_alloc,
2107
    null_ctx_free
2108
};
2109

2110
static const mbedtls_cipher_info_t null_cipher_info = {
2111
    "NULL",
2112
    1,
2113
    0 >> MBEDTLS_IV_SIZE_SHIFT,
2114
    0 >> MBEDTLS_KEY_BITLEN_SHIFT,
2115
    MBEDTLS_MODE_STREAM,
2116
    MBEDTLS_CIPHER_NULL,
2117
    0,
2118
    MBEDTLS_CIPHER_BASE_INDEX_NULL_BASE
2119
};
2120
#endif /* defined(MBEDTLS_CIPHER_NULL_CIPHER) */
2121

2122
#if defined(MBEDTLS_NIST_KW_C)
2123
static void *kw_ctx_alloc(void)
2124
{
2125
    void *ctx = mbedtls_calloc(1, sizeof(mbedtls_nist_kw_context));
2126

2127
    if (ctx != NULL) {
2128
        mbedtls_nist_kw_init((mbedtls_nist_kw_context *) ctx);
2129
    }
2130

2131
    return ctx;
2132
}
2133

2134
static void kw_ctx_free(void *ctx)
2135
{
2136
    mbedtls_nist_kw_free(ctx);
2137
    mbedtls_free(ctx);
2138
}
2139

2140
static int kw_aes_setkey_wrap(void *ctx, const unsigned char *key,
2141
                              unsigned int key_bitlen)
2142
{
2143
    return mbedtls_nist_kw_setkey((mbedtls_nist_kw_context *) ctx,
2144
                                  MBEDTLS_CIPHER_ID_AES, key, key_bitlen, 1);
2145
}
2146

2147
static int kw_aes_setkey_unwrap(void *ctx, const unsigned char *key,
2148
                                unsigned int key_bitlen)
2149
{
2150
    return mbedtls_nist_kw_setkey((mbedtls_nist_kw_context *) ctx,
2151
                                  MBEDTLS_CIPHER_ID_AES, key, key_bitlen, 0);
2152
}
2153

2154
static const mbedtls_cipher_base_t kw_aes_info = {
2155
    MBEDTLS_CIPHER_ID_AES,
2156
    NULL,
2157
#if defined(MBEDTLS_CIPHER_MODE_CBC)
2158
    NULL,
2159
#endif
2160
#if defined(MBEDTLS_CIPHER_MODE_CFB)
2161
    NULL,
2162
#endif
2163
#if defined(MBEDTLS_CIPHER_MODE_OFB)
2164
    NULL,
2165
#endif
2166
#if defined(MBEDTLS_CIPHER_MODE_CTR)
2167
    NULL,
2168
#endif
2169
#if defined(MBEDTLS_CIPHER_MODE_XTS)
2170
    NULL,
2171
#endif
2172
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
2173
    NULL,
2174
#endif
2175
    kw_aes_setkey_wrap,
2176
    kw_aes_setkey_unwrap,
2177
    kw_ctx_alloc,
2178
    kw_ctx_free,
2179
};
2180

2181
static const mbedtls_cipher_info_t aes_128_nist_kw_info = {
2182
    "AES-128-KW",
2183
    16,
2184
    0 >> MBEDTLS_IV_SIZE_SHIFT,
2185
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
2186
    MBEDTLS_MODE_KW,
2187
    MBEDTLS_CIPHER_AES_128_KW,
2188
    0,
2189
    MBEDTLS_CIPHER_BASE_INDEX_KW_AES
2190
};
2191

2192
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2193
static const mbedtls_cipher_info_t aes_192_nist_kw_info = {
2194
    "AES-192-KW",
2195
    16,
2196
    0 >> MBEDTLS_IV_SIZE_SHIFT,
2197
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
2198
    MBEDTLS_MODE_KW,
2199
    MBEDTLS_CIPHER_AES_192_KW,
2200
    0,
2201
    MBEDTLS_CIPHER_BASE_INDEX_KW_AES
2202
};
2203

2204
static const mbedtls_cipher_info_t aes_256_nist_kw_info = {
2205
    "AES-256-KW",
2206
    16,
2207
    0 >> MBEDTLS_IV_SIZE_SHIFT,
2208
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
2209
    MBEDTLS_MODE_KW,
2210
    MBEDTLS_CIPHER_AES_256_KW,
2211
    0,
2212
    MBEDTLS_CIPHER_BASE_INDEX_KW_AES
2213
};
2214
#endif
2215

2216
static const mbedtls_cipher_info_t aes_128_nist_kwp_info = {
2217
    "AES-128-KWP",
2218
    16,
2219
    0 >> MBEDTLS_IV_SIZE_SHIFT,
2220
    128 >> MBEDTLS_KEY_BITLEN_SHIFT,
2221
    MBEDTLS_MODE_KWP,
2222
    MBEDTLS_CIPHER_AES_128_KWP,
2223
    0,
2224
    MBEDTLS_CIPHER_BASE_INDEX_KW_AES
2225
};
2226

2227
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2228
static const mbedtls_cipher_info_t aes_192_nist_kwp_info = {
2229
    "AES-192-KWP",
2230
    16,
2231
    0 >> MBEDTLS_IV_SIZE_SHIFT,
2232
    192 >> MBEDTLS_KEY_BITLEN_SHIFT,
2233
    MBEDTLS_MODE_KWP,
2234
    MBEDTLS_CIPHER_AES_192_KWP,
2235
    0,
2236
    MBEDTLS_CIPHER_BASE_INDEX_KW_AES
2237
};
2238

2239
static const mbedtls_cipher_info_t aes_256_nist_kwp_info = {
2240
    "AES-256-KWP",
2241
    16,
2242
    0 >> MBEDTLS_IV_SIZE_SHIFT,
2243
    256 >> MBEDTLS_KEY_BITLEN_SHIFT,
2244
    MBEDTLS_MODE_KWP,
2245
    MBEDTLS_CIPHER_AES_256_KWP,
2246
    0,
2247
    MBEDTLS_CIPHER_BASE_INDEX_KW_AES
2248
};
2249
#endif
2250
#endif /* MBEDTLS_NIST_KW_C */
2251

2252
const mbedtls_cipher_definition_t mbedtls_cipher_definitions[] =
2253
{
2254
#if defined(MBEDTLS_AES_C)
2255
    { MBEDTLS_CIPHER_AES_128_ECB,          &aes_128_ecb_info },
2256
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2257
    { MBEDTLS_CIPHER_AES_192_ECB,          &aes_192_ecb_info },
2258
    { MBEDTLS_CIPHER_AES_256_ECB,          &aes_256_ecb_info },
2259
#endif
2260
#if defined(MBEDTLS_CIPHER_MODE_CBC)
2261
    { MBEDTLS_CIPHER_AES_128_CBC,          &aes_128_cbc_info },
2262
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2263
    { MBEDTLS_CIPHER_AES_192_CBC,          &aes_192_cbc_info },
2264
    { MBEDTLS_CIPHER_AES_256_CBC,          &aes_256_cbc_info },
2265
#endif
2266
#endif
2267
#if defined(MBEDTLS_CIPHER_MODE_CFB)
2268
    { MBEDTLS_CIPHER_AES_128_CFB128,       &aes_128_cfb128_info },
2269
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2270
    { MBEDTLS_CIPHER_AES_192_CFB128,       &aes_192_cfb128_info },
2271
    { MBEDTLS_CIPHER_AES_256_CFB128,       &aes_256_cfb128_info },
2272
#endif
2273
#endif
2274
#if defined(MBEDTLS_CIPHER_MODE_OFB)
2275
    { MBEDTLS_CIPHER_AES_128_OFB,          &aes_128_ofb_info },
2276
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2277
    { MBEDTLS_CIPHER_AES_192_OFB,          &aes_192_ofb_info },
2278
    { MBEDTLS_CIPHER_AES_256_OFB,          &aes_256_ofb_info },
2279
#endif
2280
#endif
2281
#if defined(MBEDTLS_CIPHER_MODE_CTR)
2282
    { MBEDTLS_CIPHER_AES_128_CTR,          &aes_128_ctr_info },
2283
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2284
    { MBEDTLS_CIPHER_AES_192_CTR,          &aes_192_ctr_info },
2285
    { MBEDTLS_CIPHER_AES_256_CTR,          &aes_256_ctr_info },
2286
#endif
2287
#endif
2288
#if defined(MBEDTLS_CIPHER_MODE_XTS)
2289
    { MBEDTLS_CIPHER_AES_128_XTS,          &aes_128_xts_info },
2290
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2291
    { MBEDTLS_CIPHER_AES_256_XTS,          &aes_256_xts_info },
2292
#endif
2293
#endif
2294
#endif /* MBEDTLS_AES_C */
2295
#if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
2296
    { MBEDTLS_CIPHER_AES_128_GCM,          &aes_128_gcm_info },
2297
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2298
    { MBEDTLS_CIPHER_AES_192_GCM,          &aes_192_gcm_info },
2299
    { MBEDTLS_CIPHER_AES_256_GCM,          &aes_256_gcm_info },
2300
#endif
2301
#endif
2302
#if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
2303
    { MBEDTLS_CIPHER_AES_128_CCM,          &aes_128_ccm_info },
2304
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2305
    { MBEDTLS_CIPHER_AES_192_CCM,          &aes_192_ccm_info },
2306
    { MBEDTLS_CIPHER_AES_256_CCM,          &aes_256_ccm_info },
2307
#endif
2308
#endif
2309
#if defined(MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_AES_VIA_LEGACY_OR_USE_PSA)
2310
    { MBEDTLS_CIPHER_AES_128_CCM_STAR_NO_TAG,          &aes_128_ccm_star_no_tag_info },
2311
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2312
    { MBEDTLS_CIPHER_AES_192_CCM_STAR_NO_TAG,          &aes_192_ccm_star_no_tag_info },
2313
    { MBEDTLS_CIPHER_AES_256_CCM_STAR_NO_TAG,          &aes_256_ccm_star_no_tag_info },
2314
#endif
2315
#endif
2316

2317
#if defined(MBEDTLS_CAMELLIA_C)
2318
    { MBEDTLS_CIPHER_CAMELLIA_128_ECB,     &camellia_128_ecb_info },
2319
    { MBEDTLS_CIPHER_CAMELLIA_192_ECB,     &camellia_192_ecb_info },
2320
    { MBEDTLS_CIPHER_CAMELLIA_256_ECB,     &camellia_256_ecb_info },
2321
#if defined(MBEDTLS_CIPHER_MODE_CBC)
2322
    { MBEDTLS_CIPHER_CAMELLIA_128_CBC,     &camellia_128_cbc_info },
2323
    { MBEDTLS_CIPHER_CAMELLIA_192_CBC,     &camellia_192_cbc_info },
2324
    { MBEDTLS_CIPHER_CAMELLIA_256_CBC,     &camellia_256_cbc_info },
2325
#endif
2326
#if defined(MBEDTLS_CIPHER_MODE_CFB)
2327
    { MBEDTLS_CIPHER_CAMELLIA_128_CFB128,  &camellia_128_cfb128_info },
2328
    { MBEDTLS_CIPHER_CAMELLIA_192_CFB128,  &camellia_192_cfb128_info },
2329
    { MBEDTLS_CIPHER_CAMELLIA_256_CFB128,  &camellia_256_cfb128_info },
2330
#endif
2331
#if defined(MBEDTLS_CIPHER_MODE_CTR)
2332
    { MBEDTLS_CIPHER_CAMELLIA_128_CTR,     &camellia_128_ctr_info },
2333
    { MBEDTLS_CIPHER_CAMELLIA_192_CTR,     &camellia_192_ctr_info },
2334
    { MBEDTLS_CIPHER_CAMELLIA_256_CTR,     &camellia_256_ctr_info },
2335
#endif
2336
#if defined(MBEDTLS_GCM_C)
2337
    { MBEDTLS_CIPHER_CAMELLIA_128_GCM,     &camellia_128_gcm_info },
2338
    { MBEDTLS_CIPHER_CAMELLIA_192_GCM,     &camellia_192_gcm_info },
2339
    { MBEDTLS_CIPHER_CAMELLIA_256_GCM,     &camellia_256_gcm_info },
2340
#endif
2341
#if defined(MBEDTLS_CCM_C)
2342
    { MBEDTLS_CIPHER_CAMELLIA_128_CCM,     &camellia_128_ccm_info },
2343
    { MBEDTLS_CIPHER_CAMELLIA_192_CCM,     &camellia_192_ccm_info },
2344
    { MBEDTLS_CIPHER_CAMELLIA_256_CCM,     &camellia_256_ccm_info },
2345
    { MBEDTLS_CIPHER_CAMELLIA_128_CCM_STAR_NO_TAG,     &camellia_128_ccm_star_no_tag_info },
2346
    { MBEDTLS_CIPHER_CAMELLIA_192_CCM_STAR_NO_TAG,     &camellia_192_ccm_star_no_tag_info },
2347
    { MBEDTLS_CIPHER_CAMELLIA_256_CCM_STAR_NO_TAG,     &camellia_256_ccm_star_no_tag_info },
2348
#endif
2349
#endif /* MBEDTLS_CAMELLIA_C */
2350

2351
#if defined(MBEDTLS_ARIA_C)
2352
    { MBEDTLS_CIPHER_ARIA_128_ECB,     &aria_128_ecb_info },
2353
    { MBEDTLS_CIPHER_ARIA_192_ECB,     &aria_192_ecb_info },
2354
    { MBEDTLS_CIPHER_ARIA_256_ECB,     &aria_256_ecb_info },
2355
#if defined(MBEDTLS_CIPHER_MODE_CBC)
2356
    { MBEDTLS_CIPHER_ARIA_128_CBC,     &aria_128_cbc_info },
2357
    { MBEDTLS_CIPHER_ARIA_192_CBC,     &aria_192_cbc_info },
2358
    { MBEDTLS_CIPHER_ARIA_256_CBC,     &aria_256_cbc_info },
2359
#endif
2360
#if defined(MBEDTLS_CIPHER_MODE_CFB)
2361
    { MBEDTLS_CIPHER_ARIA_128_CFB128,  &aria_128_cfb128_info },
2362
    { MBEDTLS_CIPHER_ARIA_192_CFB128,  &aria_192_cfb128_info },
2363
    { MBEDTLS_CIPHER_ARIA_256_CFB128,  &aria_256_cfb128_info },
2364
#endif
2365
#if defined(MBEDTLS_CIPHER_MODE_CTR)
2366
    { MBEDTLS_CIPHER_ARIA_128_CTR,     &aria_128_ctr_info },
2367
    { MBEDTLS_CIPHER_ARIA_192_CTR,     &aria_192_ctr_info },
2368
    { MBEDTLS_CIPHER_ARIA_256_CTR,     &aria_256_ctr_info },
2369
#endif
2370
#if defined(MBEDTLS_GCM_C)
2371
    { MBEDTLS_CIPHER_ARIA_128_GCM,     &aria_128_gcm_info },
2372
    { MBEDTLS_CIPHER_ARIA_192_GCM,     &aria_192_gcm_info },
2373
    { MBEDTLS_CIPHER_ARIA_256_GCM,     &aria_256_gcm_info },
2374
#endif
2375
#if defined(MBEDTLS_CCM_C)
2376
    { MBEDTLS_CIPHER_ARIA_128_CCM,     &aria_128_ccm_info },
2377
    { MBEDTLS_CIPHER_ARIA_192_CCM,     &aria_192_ccm_info },
2378
    { MBEDTLS_CIPHER_ARIA_256_CCM,     &aria_256_ccm_info },
2379
    { MBEDTLS_CIPHER_ARIA_128_CCM_STAR_NO_TAG,     &aria_128_ccm_star_no_tag_info },
2380
    { MBEDTLS_CIPHER_ARIA_192_CCM_STAR_NO_TAG,     &aria_192_ccm_star_no_tag_info },
2381
    { MBEDTLS_CIPHER_ARIA_256_CCM_STAR_NO_TAG,     &aria_256_ccm_star_no_tag_info },
2382
#endif
2383
#endif /* MBEDTLS_ARIA_C */
2384

2385
#if defined(MBEDTLS_DES_C)
2386
    { MBEDTLS_CIPHER_DES_ECB,              &des_ecb_info },
2387
    { MBEDTLS_CIPHER_DES_EDE_ECB,          &des_ede_ecb_info },
2388
    { MBEDTLS_CIPHER_DES_EDE3_ECB,         &des_ede3_ecb_info },
2389
#if defined(MBEDTLS_CIPHER_MODE_CBC)
2390
    { MBEDTLS_CIPHER_DES_CBC,              &des_cbc_info },
2391
    { MBEDTLS_CIPHER_DES_EDE_CBC,          &des_ede_cbc_info },
2392
    { MBEDTLS_CIPHER_DES_EDE3_CBC,         &des_ede3_cbc_info },
2393
#endif
2394
#endif /* MBEDTLS_DES_C */
2395

2396
#if defined(MBEDTLS_CHACHA20_C)
2397
    { MBEDTLS_CIPHER_CHACHA20,             &chacha20_info },
2398
#endif
2399

2400
#if defined(MBEDTLS_CHACHAPOLY_C)
2401
    { MBEDTLS_CIPHER_CHACHA20_POLY1305,    &chachapoly_info },
2402
#endif
2403

2404
#if defined(MBEDTLS_NIST_KW_C)
2405
    { MBEDTLS_CIPHER_AES_128_KW,          &aes_128_nist_kw_info },
2406
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2407
    { MBEDTLS_CIPHER_AES_192_KW,          &aes_192_nist_kw_info },
2408
    { MBEDTLS_CIPHER_AES_256_KW,          &aes_256_nist_kw_info },
2409
#endif
2410
    { MBEDTLS_CIPHER_AES_128_KWP,         &aes_128_nist_kwp_info },
2411
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
2412
    { MBEDTLS_CIPHER_AES_192_KWP,         &aes_192_nist_kwp_info },
2413
    { MBEDTLS_CIPHER_AES_256_KWP,         &aes_256_nist_kwp_info },
2414
#endif
2415
#endif
2416

2417
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
2418
    { MBEDTLS_CIPHER_NULL,                 &null_cipher_info },
2419
#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
2420

2421
    { MBEDTLS_CIPHER_NONE, NULL }
2422
};
2423

2424
#define NUM_CIPHERS (sizeof(mbedtls_cipher_definitions) /      \
2425
                     sizeof(mbedtls_cipher_definitions[0]))
2426
int mbedtls_cipher_supported[NUM_CIPHERS];
2427

2428
const mbedtls_cipher_base_t * const mbedtls_cipher_base_lookup_table[] = {
2429
#if defined(MBEDTLS_AES_C)
2430
    [MBEDTLS_CIPHER_BASE_INDEX_AES] = &aes_info,
2431
#endif
2432
#if defined(MBEDTLS_ARIA_C)
2433
    [MBEDTLS_CIPHER_BASE_INDEX_ARIA] = &aria_info,
2434
#endif
2435
#if defined(MBEDTLS_CAMELLIA_C)
2436
    [MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA] = &camellia_info,
2437
#endif
2438
#if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
2439
    [MBEDTLS_CIPHER_BASE_INDEX_CCM_AES] = &ccm_aes_info,
2440
#endif
2441
#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_ARIA_C)
2442
    [MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA] = &ccm_aria_info,
2443
#endif
2444
#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_CAMELLIA_C)
2445
    [MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA] = &ccm_camellia_info,
2446
#endif
2447
#if defined(MBEDTLS_CHACHA20_C)
2448
    [MBEDTLS_CIPHER_BASE_INDEX_CHACHA20_BASE] = &chacha20_base_info,
2449
#endif
2450
#if defined(MBEDTLS_CHACHAPOLY_C)
2451
    [MBEDTLS_CIPHER_BASE_INDEX_CHACHAPOLY_BASE] = &chachapoly_base_info,
2452
#endif
2453
#if defined(MBEDTLS_DES_C)
2454
    [MBEDTLS_CIPHER_BASE_INDEX_DES_EDE3] = &des_ede3_info,
2455
#endif
2456
#if defined(MBEDTLS_DES_C)
2457
    [MBEDTLS_CIPHER_BASE_INDEX_DES_EDE] = &des_ede_info,
2458
#endif
2459
#if defined(MBEDTLS_DES_C)
2460
    [MBEDTLS_CIPHER_BASE_INDEX_DES] = &des_info,
2461
#endif
2462
#if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
2463
    [MBEDTLS_CIPHER_BASE_INDEX_GCM_AES] = &gcm_aes_info,
2464
#endif
2465
#if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_ARIA_C)
2466
    [MBEDTLS_CIPHER_BASE_INDEX_GCM_ARIA] = &gcm_aria_info,
2467
#endif
2468
#if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_CAMELLIA_C)
2469
    [MBEDTLS_CIPHER_BASE_INDEX_GCM_CAMELLIA] = &gcm_camellia_info,
2470
#endif
2471
#if defined(MBEDTLS_NIST_KW_C)
2472
    [MBEDTLS_CIPHER_BASE_INDEX_KW_AES] = &kw_aes_info,
2473
#endif
2474
#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
2475
    [MBEDTLS_CIPHER_BASE_INDEX_NULL_BASE] = &null_base_info,
2476
#endif
2477
#if defined(MBEDTLS_CIPHER_MODE_XTS) && defined(MBEDTLS_AES_C)
2478
    [MBEDTLS_CIPHER_BASE_INDEX_XTS_AES] = &xts_aes_info
2479
#endif
2480
};
2481

2482
#endif /* MBEDTLS_CIPHER_C */
2483

2484
Product

Resources

Company
