v2 / thirdparty / mbedtls / library / cipher_wrap.c
2482 lines · 2234 sloc · 66.06 KB · 8de6de946e2fb116f77a4e3ad7e167504dacb82f
Raw 


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


61enum 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 */


121static 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


132static 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 */


143static 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


154static 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


163static 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)


170static 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)


179static 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)


189static 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)


198static 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)


208static 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)


234static 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


241static 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


247static 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


260static void aes_ctx_free(void *ctx)


261{


262    mbedtls_aes_free((mbedtls_aes_context *) ctx);


263    mbedtls_free(ctx);


264}


265


266static 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


295static 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)


307static 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


318static 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)


331static 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)


343static 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


354static 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)


368static 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)


380static 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


391static 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)


405static 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)


417static 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


428static 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)


442static 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)


454static 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


465static 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)


479static 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


486static 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


493static 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


504static 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


516static 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


543static 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)


555static 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)


570static 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)


579static 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)


617static 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)


629static 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


640static 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)


654static 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)


663static 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)


701static 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)


713static 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


724static 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)


738static 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)


750static 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


761static 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


777static 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)


785static 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)


795static 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)


805static 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)


815static 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


822static 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


828static 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


842static void camellia_ctx_free(void *ctx)


843{


844    mbedtls_camellia_free((mbedtls_camellia_context *) ctx);


845    mbedtls_free(ctx);


846}


847


848static 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


877static 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


888static 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


899static 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)


911static 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


922static 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


933static 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)


946static 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


957static 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


968static 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)


981static 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


992static 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


1003static 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)


1016static 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


1023static 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


1052static 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


1063static 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


1074static 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)


1087static 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


1094static 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


1123static 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


1134static 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


1145static 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


1156static 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


1167static 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


1178static 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


1194static 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)


1203static 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)


1213static 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)


1223static 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)


1233static 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


1240static 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


1246static 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


1260static void aria_ctx_free(void *ctx)


1261{


1262    mbedtls_aria_free((mbedtls_aria_context *) ctx);


1263    mbedtls_free(ctx);


1264}


1265


1266static 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


1295static 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


1306static 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


1317static 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)


1329static 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


1340static 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


1351static 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)


1364static 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


1375static 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


1386static 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)


1399static 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


1410static 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


1421static 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)


1434static 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


1441static 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


1470static 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


1481static 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


1492static 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)


1505static 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


1512static 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


1541static 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


1552static 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


1563static 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


1574static 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


1585static 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


1596static 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


1612static 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


1619static 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)


1627static 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)


1636static 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


1644static 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


1652static 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


1660static 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


1668static 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


1676static 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


1684static 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


1692static 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


1705static void des_ctx_free(void *ctx)


1706{


1707    mbedtls_des_free((mbedtls_des_context *) ctx);


1708    mbedtls_free(ctx);


1709}


1710


1711static 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


1725static void des3_ctx_free(void *ctx)


1726{


1727    mbedtls_des3_free((mbedtls_des3_context *) ctx);


1728    mbedtls_free(ctx);


1729}


1730


1731static 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


1758static 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)


1770static 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


1782static 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


1809static 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)


1821static 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


1833static 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


1860static 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)


1871static 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


1886static 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


1900static 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


1914static 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


1928static void chacha20_ctx_free(void *ctx)


1929{


1930    mbedtls_chacha20_free((mbedtls_chacha20_context *) ctx);


1931    mbedtls_free(ctx);


1932}


1933


1934static 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};


1962static 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


1976static 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


1991static 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


2005static void chachapoly_ctx_free(void *ctx)


2006{


2007    mbedtls_chachapoly_free((mbedtls_chachapoly_context *) ctx);


2008    mbedtls_free(ctx);


2009}


2010


2011static 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};


2039static 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)


2052static 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


2061static 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


2071static void *null_ctx_alloc(void)


2072{


2073    return (void *) 1;


2074}


2075


2076static void null_ctx_free(void *ctx)


2077{


2078    ((void) ctx);


2079}


2080


2081static 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


2110static 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)


2123static 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


2134static void kw_ctx_free(void *ctx)


2135{


2136    mbedtls_nist_kw_free(ctx);


2137    mbedtls_free(ctx);


2138}


2139


2140static 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


2147static 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


2154static 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


2181static 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)


2193static 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


2204static 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


2216static 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)


2228static 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


2239static 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


2252const 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]))


2426int mbedtls_cipher_supported[NUM_CIPHERS];


2427


2428const 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