m2mb API docs  25.30.003
m2mb API sets documentation
m2mb_crypto.h
Go to the documentation of this file.
1 /*===============================================================================================*/
2 /* >>> Copyright (C) Telit Communications S.p.A. Italy All Rights Reserved. <<< */
25 #ifndef M2M_M2MB_CRYPTO_H
26 #define M2M_M2MB_CRYPTO_H
27 
33 /* Global declarations ==========================================================================*/
34 
35 #define TZ_LOGGING
36 
37 /* free choice to use free or deinit in Telit style */
38 #define m2mb_crypto_md_free m2mb_crypto_md_deinit
39 #define m2mb_crypto_hmac_free m2mb_crypto_hmac_deinit
40 #define m2mb_crypto_cmac_free m2mb_crypto_cmac_deinit
41 #define m2mb_crypto_aes_free m2mb_crypto_aes_deinit
42 #define m2mb_crypto_des_free m2mb_crypto_des_deinit
43 #define m2mb_crypto_rsa_free m2mb_crypto_rsa_deinit
44 #define m2mb_crypto_ecc_free m2mb_crypto_ecc_deinit
45 
46 
47 
48 
49 /* Global typedef ==========================================================================*/
50 
55 typedef enum
56 {
57  M2MB_CRYPTO_CTX_ALG_NONE=0,
58  M2MB_CRYPTO_CTX_ALG_MD2,
59  M2MB_CRYPTO_CTX_ALG_MD4,
60  M2MB_CRYPTO_CTX_ALG_MD5,
61  M2MB_CRYPTO_CTX_ALG_SHA1,
62  M2MB_CRYPTO_CTX_ALG_SHA224,
63  M2MB_CRYPTO_CTX_ALG_SHA256,
64  M2MB_CRYPTO_CTX_ALG_SHA384,
65  M2MB_CRYPTO_CTX_ALG_SHA512,
66  M2MB_CRYPTO_CTX_ALG_HMAC,
67  M2MB_CRYPTO_CTX_ALG_CMAC,
68  M2MB_CRYPTO_CTX_ALG_RSA,
69  M2MB_CRYPTO_CTX_ALG_ECC,
70  M2MB_CRYPTO_CTX_ALG_AES,
71  M2MB_CRYPTO_CTX_ALG_DES,
72  ENUM_TO_INT( M2MB_CRYPTO_CTX_ALG_E )
73 } M2MB_CRYPTO_CTX_ALG_E;
74 
79 typedef struct M2MB_CRYPTO_GEN_CONTEXT_TAG *M2MB_CRYPTO_GEN_CONTEXT;
80 
81 
86 typedef struct M2MB_CRYPTO_MD_CONTEXT_TAG *M2MB_CRYPTO_MD_CONTEXT;
87 
92 typedef struct M2MB_CRYPTO_HMAC_CONTEXT_TAG *M2MB_CRYPTO_HMAC_CONTEXT;
93 
98 typedef struct M2MB_CRYPTO_CMAC_CONTEXT_TAG *M2MB_CRYPTO_CMAC_CONTEXT;
99 
104 typedef struct M2MB_CRYPTO_AES_CONTEXT_TAG *M2MB_CRYPTO_AES_CONTEXT;
105 
110 typedef struct M2MB_CRYPTO_DES_CONTEXT_TAG *M2MB_CRYPTO_DES_CONTEXT;
111 
116 typedef struct M2MB_CRYPTO_RSA_CONTEXT_TAG *M2MB_CRYPTO_RSA_CONTEXT;
117 
122 typedef struct M2MB_CRYPTO_ECC_CONTEXT_TAG *M2MB_CRYPTO_ECC_CONTEXT;
123 
128 typedef enum
129 {
130  M2MB_CRYPTO_MD_ALG_NONE=0,
131  M2MB_CRYPTO_MD_ALG_MD2,
132  M2MB_CRYPTO_MD_ALG_MD4,
133  M2MB_CRYPTO_MD_ALG_MD5,
134  M2MB_CRYPTO_MD_ALG_SHA1,
135  M2MB_CRYPTO_MD_ALG_SHA224,
136  M2MB_CRYPTO_MD_ALG_SHA256,
137  M2MB_CRYPTO_MD_ALG_SHA384,
138  M2MB_CRYPTO_MD_ALG_SHA512,
139  ENUM_TO_INT( M2MB_CRYPTO_MD_ALG_E )
140 } M2MB_CRYPTO_MD_ALG_E;
141 
142 /* Global functions =============================================================================*/
143 
144 /*-----------------------------------------------------------------------------------------------*/
164 /*-----------------------------------------------------------------------------------------------*/
165 M2MB_CRYPTO_CTX_ALG_E m2mb_crypto_get_algo( M2MB_CRYPTO_GEN_CONTEXT ctx );
166 
167 /*-----------------------------------------------------------------------------------------------*/
191 /*-----------------------------------------------------------------------------------------------*/
192 UINT32 m2mb_crypto_ctx_info_for_tee( M2MB_CRYPTO_GEN_CONTEXT ctx, UINT8 *info );
193 
194 /*-----------------------------------------------------------------------------------------------*/
220 /*-----------------------------------------------------------------------------------------------*/
221 M2MB_RESULT_E m2mb_crypto_md_init( M2MB_CRYPTO_MD_CONTEXT *ctx );
222 
250 /*-----------------------------------------------------------------------------------------------*/
251 M2MB_RESULT_E m2mb_crypto_md_setup( M2MB_CRYPTO_MD_CONTEXT ctx,
252  const M2MB_CRYPTO_MD_ALG_E md_info );
253 
254 /*-----------------------------------------------------------------------------------------------*/
286 /*-----------------------------------------------------------------------------------------------*/
287 M2MB_RESULT_E m2mb_crypto_md_update( M2MB_CRYPTO_MD_CONTEXT ctx,
288  const UINT8 *data,
289  SIZE_T len );
290 
291 /*-----------------------------------------------------------------------------------------------*/
320 /*-----------------------------------------------------------------------------------------------*/
321 M2MB_RESULT_E m2mb_crypto_md_final( M2MB_CRYPTO_MD_CONTEXT ctx,
322  UINT8 *md );
323 
324 /*-----------------------------------------------------------------------------------------------*/
349 /*-----------------------------------------------------------------------------------------------*/
350 M2MB_RESULT_E m2mb_crypto_md_deinit( M2MB_CRYPTO_MD_CONTEXT ctx );
351 
352 /*-----------------------------------------------------------------------------------------------*/
398 /*-----------------------------------------------------------------------------------------------*/
399 UINT8 *m2mb_crypto_md( const M2MB_CRYPTO_MD_ALG_E md_info,
400  const UINT8 *data,
401  SIZE_T len,
402  UINT8 *md );
403 
404 
405 /* Global declarations ==========================================================================*/
406 
413 /* Global functions =============================================================================*/
414 
415 /*-----------------------------------------------------------------------------------------------*/
440 /*-----------------------------------------------------------------------------------------------*/
441 M2MB_RESULT_E m2mb_crypto_hmac_init( M2MB_CRYPTO_HMAC_CONTEXT *ctx );
442 
479 /*-----------------------------------------------------------------------------------------------*/
480 M2MB_RESULT_E m2mb_crypto_hmac_setup( M2MB_CRYPTO_HMAC_CONTEXT ctx,
481  M2MB_CRYPTO_MD_ALG_E md_info,
482  const UINT8 *key,
483  SIZE_T keylen );
484 
485 /*-----------------------------------------------------------------------------------------------*/
518 /*-----------------------------------------------------------------------------------------------*/
519 M2MB_RESULT_E m2mb_crypto_hmac_update( M2MB_CRYPTO_HMAC_CONTEXT ctx,
520  const UINT8 *data,
521  SIZE_T len );
522 
523 /*-----------------------------------------------------------------------------------------------*/
553 /*-----------------------------------------------------------------------------------------------*/
554 M2MB_RESULT_E m2mb_crypto_hmac_final( M2MB_CRYPTO_HMAC_CONTEXT ctx,
555  UINT8 *hmac );
556 
557 /*-----------------------------------------------------------------------------------------------*/
583 /*-----------------------------------------------------------------------------------------------*/
584 M2MB_RESULT_E m2mb_crypto_hmac_reset( M2MB_CRYPTO_HMAC_CONTEXT ctx );
585 
586 /*-----------------------------------------------------------------------------------------------*/
610 /*-----------------------------------------------------------------------------------------------*/
611 M2MB_RESULT_E m2mb_crypto_hmac_deinit( M2MB_CRYPTO_HMAC_CONTEXT ctx );
612 
613 /*-----------------------------------------------------------------------------------------------*/
663 /*-----------------------------------------------------------------------------------------------*/
664 UINT8 *m2mb_crypto_hmac( M2MB_CRYPTO_MD_ALG_E md_info,
665  const UINT8 *key,
666  const SIZE_T keylen,
667  const UINT8 *input,
668  const SIZE_T inlen,
669  UINT8 *hmac );
670 
680 /* Global declarations ==========================================================================*/
681 
682 
683 typedef enum
684 {
685  M2MB_CRYPTO_CMAC_ALG_AES_128 = 1,
686  M2MB_CRYPTO_CMAC_ALG_AES_192 = 2,
687  M2MB_CRYPTO_CMAC_ALG_AES_256 = 3,
688  ENUM_TO_INT( M2MB_CRYPTO_CMAC_ALG_E )
689 } M2MB_CRYPTO_CMAC_ALG_E;
690 
691 /* Global functions =============================================================================*/
692 
693 /*-----------------------------------------------------------------------------------------------*/
718 /*-----------------------------------------------------------------------------------------------*/
719 M2MB_RESULT_E m2mb_crypto_cmac_init( M2MB_CRYPTO_CMAC_CONTEXT *ctx );
720 
753 /*-----------------------------------------------------------------------------------------------*/
754 M2MB_RESULT_E m2mb_crypto_cmac_setup( M2MB_CRYPTO_CMAC_CONTEXT ctx,
755  const UINT8 *key,
756  SIZE_T keylen );
757 
758 /*-----------------------------------------------------------------------------------------------*/
791 /*-----------------------------------------------------------------------------------------------*/
792 M2MB_RESULT_E m2mb_crypto_cmac_update( M2MB_CRYPTO_CMAC_CONTEXT ctx,
793  const UINT8 *data,
794  SIZE_T len );
795 
796 /*-----------------------------------------------------------------------------------------------*/
826 /*-----------------------------------------------------------------------------------------------*/
827 M2MB_RESULT_E m2mb_crypto_cmac_final( M2MB_CRYPTO_CMAC_CONTEXT ctx,
828  UINT8 *cmac );
829 
830 /*-----------------------------------------------------------------------------------------------*/
856 /*-----------------------------------------------------------------------------------------------*/
857 M2MB_RESULT_E m2mb_crypto_cmac_reset( M2MB_CRYPTO_CMAC_CONTEXT ctx );
858 
859 /*-----------------------------------------------------------------------------------------------*/
883 /*-----------------------------------------------------------------------------------------------*/
884 M2MB_RESULT_E m2mb_crypto_cmac_deinit( M2MB_CRYPTO_CMAC_CONTEXT ctx );
885 
886 /*-----------------------------------------------------------------------------------------------*/
928 /*-----------------------------------------------------------------------------------------------*/
929 UINT8 *m2mb_crypto_cmac( M2MB_CRYPTO_CMAC_ALG_E cmac_alg,
930  const UINT8 *key,
931  const SIZE_T keylen,
932  const UINT8 *input,
933  const SIZE_T inlen,
934  UINT8 *cmac );
935 
936 
946 /* Global declarations ==========================================================================*/
947 
948 
949 
954 typedef enum
955 {
956  M2MB_CRYPTO_AES_MODE_ENCRYPT,
957  M2MB_CRYPTO_AES_MODE_DECRYPT,
958  ENUM_TO_INT( M2MB_CRYPTO_AES_MODE_E )
959 } M2MB_CRYPTO_AES_MODE_E;
960 
962 #define M2MB_CRYPTO_AES_ECB_BLOCK_SIZE 16
963 
965 #define M2MB_CRYPTO_AES_IV_SIZE 16
966 
967 
968 /* Global functions =============================================================================*/
969 
970 /*-----------------------------------------------------------------------------------------------*/
995 /*-----------------------------------------------------------------------------------------------*/
996 M2MB_RESULT_E m2mb_crypto_aes_init( M2MB_CRYPTO_AES_CONTEXT *ctx );
997 
998 /*-----------------------------------------------------------------------------------------------*/
1022 /*-----------------------------------------------------------------------------------------------*/
1023 M2MB_RESULT_E m2mb_crypto_aes_deinit( M2MB_CRYPTO_AES_CONTEXT ctx );
1024 
1025 /*-----------------------------------------------------------------------------------------------*/
1054 /*-----------------------------------------------------------------------------------------------*/
1055 M2MB_RESULT_E m2mb_crypto_aes_generate_key( M2MB_CRYPTO_AES_CONTEXT ctx,
1056  UINT32 keybits );
1057 
1058 /*-----------------------------------------------------------------------------------------------*/
1115 /*-----------------------------------------------------------------------------------------------*/
1116 M2MB_RESULT_E m2mb_crypto_aes_keyblob_export( M2MB_CRYPTO_AES_CONTEXT ctx,
1117  UINT8 *keyblob,
1118  UINT32 *keyblob_length );
1119 
1120 /*-----------------------------------------------------------------------------------------------*/
1155 /*-----------------------------------------------------------------------------------------------*/
1156 M2MB_RESULT_E m2mb_crypto_aes_keyblob_import( M2MB_CRYPTO_AES_CONTEXT ctx,
1157  const UINT8 *keyblob,
1158  UINT32 keyblob_length );
1159 
1160 /*-----------------------------------------------------------------------------------------------*/
1195 /*-----------------------------------------------------------------------------------------------*/
1196 M2MB_RESULT_E m2mb_crypto_aes_externalkey_import ( M2MB_CRYPTO_AES_CONTEXT ctx,
1197  const UINT8 *key,
1198  UINT32 keylength );
1199 
1200 /*-----------------------------------------------------------------------------------------------*/
1234 /*-----------------------------------------------------------------------------------------------*/
1235 M2MB_RESULT_E m2mb_crypto_aes_ecb_encdec( M2MB_CRYPTO_AES_CONTEXT ctx,
1236  M2MB_CRYPTO_AES_MODE_E mode,
1237  const UINT8 in[M2MB_CRYPTO_AES_ECB_BLOCK_SIZE],
1238  UINT8 out[M2MB_CRYPTO_AES_ECB_BLOCK_SIZE] );
1239 
1240 /*-----------------------------------------------------------------------------------------------*/
1283 /*-----------------------------------------------------------------------------------------------*/
1284 M2MB_RESULT_E m2mb_crypto_aes_cbc_encdec( M2MB_CRYPTO_AES_CONTEXT ctx,
1285  M2MB_CRYPTO_AES_MODE_E mode,
1286  const UINT8 *in,
1287  UINT8 *out,
1288  SIZE_T inlen,
1289  UINT8 ivec[M2MB_CRYPTO_AES_IV_SIZE] );
1290 
1300 /* Global declarations ==========================================================================*/
1301 
1302 
1303 
1305 typedef enum
1306 {
1307  M2MB_CRYPTO_ALG_DES,
1308  M2MB_CRYPTO_ALG_3DES,
1309  ENUM_TO_INT( M2MB_CRYPTO_DES_ALG_TYPE_E )
1310 } M2MB_CRYPTO_DES_ALG_TYPE_E;
1311 
1313 typedef enum
1314 {
1315  M2MB_CRYPTO_DES_MODE_ENCRYPT,
1316  M2MB_CRYPTO_DES_MODE_DECRYPT,
1317  ENUM_TO_INT( M2MB_CRYPTO_DES_MODE_E )
1318 } M2MB_CRYPTO_DES_MODE_E;
1319 
1321 #define M2MB_CRYPTO_DES_KEY_SIZE 8
1322 
1324 #define M2MB_CRYPTO_3DES_KEY2_SIZE 16
1325 
1327 #define M2MB_CRYPTO_3DES_KEY3_SIZE 24
1328 
1330 #define M2MB_CRYPTO_DES_BLOCK_BYTE_LEN 8
1331 
1333 #define M2MB_CRYPTO_DES_IV_BYTE_LEN 8
1334 
1335 /* Global functions =============================================================================*/
1336 
1337 /*-----------------------------------------------------------------------------------------------*/
1365 /*-----------------------------------------------------------------------------------------------*/
1366 M2MB_RESULT_E m2mb_crypto_des_init( M2MB_CRYPTO_DES_CONTEXT *ctx,
1367  M2MB_CRYPTO_DES_ALG_TYPE_E des_alg );
1368 
1369 /*-----------------------------------------------------------------------------------------------*/
1393 /*-----------------------------------------------------------------------------------------------*/
1394 M2MB_RESULT_E m2mb_crypto_des_deinit( M2MB_CRYPTO_DES_CONTEXT ctx );
1395 
1396 /*-----------------------------------------------------------------------------------------------*/
1424 /*-----------------------------------------------------------------------------------------------*/
1425 M2MB_RESULT_E m2mb_crypto_des_generate_key( M2MB_CRYPTO_DES_CONTEXT ctx,
1426  UINT32 keybits );
1427 
1428 /*-----------------------------------------------------------------------------------------------*/
1458 /*-----------------------------------------------------------------------------------------------*/
1459 M2MB_RESULT_E m2mb_crypto_des_externalkey_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1460  const UINT8 key[M2MB_CRYPTO_DES_KEY_SIZE] );
1461 
1462 /*-----------------------------------------------------------------------------------------------*/
1492 /*-----------------------------------------------------------------------------------------------*/
1493 M2MB_RESULT_E m2mb_crypto_3des_2externalkey_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1494  const UINT8 key[M2MB_CRYPTO_3DES_KEY2_SIZE] );
1495 
1496 /*-----------------------------------------------------------------------------------------------*/
1526 /*-----------------------------------------------------------------------------------------------*/
1527 M2MB_RESULT_E m2mb_crypto_3des_3externalkey_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1528  const UINT8 key[M2MB_CRYPTO_3DES_KEY3_SIZE] );
1529 
1530 /*-----------------------------------------------------------------------------------------------*/
1564 /*-----------------------------------------------------------------------------------------------*/
1565 M2MB_RESULT_E m2mb_crypto_des_keyblob_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1566  const UINT8 *keyblob,
1567  UINT32 keyblob_length );
1568 
1569 /*-----------------------------------------------------------------------------------------------*/
1603 /*-----------------------------------------------------------------------------------------------*/
1604 M2MB_RESULT_E m2mb_crypto_des_keyblob_export( M2MB_CRYPTO_DES_CONTEXT ctx,
1605  UINT8 *keyblob,
1606  UINT32 *keyblob_length );
1607 
1608 /*-----------------------------------------------------------------------------------------------*/
1642 /*-----------------------------------------------------------------------------------------------*/
1643 M2MB_RESULT_E m2mb_crypto_des_ecb_encdec( M2MB_CRYPTO_DES_CONTEXT ctx,
1644  M2MB_CRYPTO_DES_MODE_E mode,
1645  const UINT8 in[M2MB_CRYPTO_DES_BLOCK_BYTE_LEN],
1646  UINT8 out[M2MB_CRYPTO_DES_BLOCK_BYTE_LEN] );
1647 
1648 /*-----------------------------------------------------------------------------------------------*/
1691 /*-----------------------------------------------------------------------------------------------*/
1692 M2MB_RESULT_E m2mb_crypto_des_cbc_encdec( M2MB_CRYPTO_DES_CONTEXT ctx,
1693  M2MB_CRYPTO_DES_MODE_E mode,
1694  const UINT8 *in,
1695  UINT8 *out,
1696  SIZE_T inlen,
1697  UINT8 ivec[M2MB_CRYPTO_DES_IV_BYTE_LEN] );
1698 
1716 /* Global declarations ==========================================================================*/
1717 
1718 
1719 /* Padding types for encryption. */
1724 typedef enum
1725 {
1727  M2MB_CRYPTO_RSA_PADDING_PKCS1_V15,
1729  M2MB_CRYPTO_RSA_PADDING_PKCS1_OAEP,
1731  M2MB_CRYPTO_RSA_PADDING_PKCS1_PSS,
1733  M2MB_CRYPTO_RSA_PADDING_PKCS1_PSS_AUTORECOVER_SALTLEN,
1735  M2MB_CRYPTO_RSA_PADDING_NONE,
1736 
1737  ENUM_TO_INT( M2MB_CRYPTO_RSA_PADDING_TYPE_E )
1738 } M2MB_CRYPTO_RSA_PADDING_TYPE_E;
1739 
1744 typedef enum
1745 {
1746  M2MB_CRYPTO_RSA_PUBLIC,
1747  M2MB_CRYPTO_RSA_PRIVATE,
1748  ENUM_TO_INT( M2MB_CRYPTO_RSA_MODE_E )
1749 } M2MB_CRYPTO_RSA_MODE_E;
1750 
1751 /* Global functions =============================================================================*/
1752 
1753 /*-----------------------------------------------------------------------------------------------*/
1809 /*-----------------------------------------------------------------------------------------------*/
1810 M2MB_RESULT_E m2mb_crypto_rsa_init( M2MB_CRYPTO_RSA_CONTEXT *ctx,
1811  M2MB_CRYPTO_RSA_PADDING_TYPE_E padding_type,
1812  M2MB_CRYPTO_MD_ALG_E hash_id );
1813 
1814 /*-----------------------------------------------------------------------------------------------*/
1839 /*-----------------------------------------------------------------------------------------------*/
1840 M2MB_RESULT_E m2mb_crypto_rsa_deinit( M2MB_CRYPTO_RSA_CONTEXT ctx );
1841 
1842 /*-----------------------------------------------------------------------------------------------*/
1931 /*-----------------------------------------------------------------------------------------------*/
1932 M2MB_RESULT_E m2mb_crypto_rsa_public( M2MB_CRYPTO_RSA_CONTEXT ctx,
1933  const UINT8 *in,
1934  UINT8 *out );
1935 
1936 /*-----------------------------------------------------------------------------------------------*/
1977 /*-----------------------------------------------------------------------------------------------*/
1978 M2MB_RESULT_E m2mb_crypto_rsa_private( M2MB_CRYPTO_RSA_CONTEXT ctx,
1979  const UINT8 *in,
1980  UINT8 *out );
1981 
1982 /*-----------------------------------------------------------------------------------------------*/
2016 /*-----------------------------------------------------------------------------------------------*/
2017 M2MB_RESULT_E m2mb_crypto_rsa_generate_key( M2MB_CRYPTO_RSA_CONTEXT ctx,
2018  UINT32 key_size,
2019  UINT32 public_exponent );
2020 
2021 /*-----------------------------------------------------------------------------------------------*/
2131 /*-----------------------------------------------------------------------------------------------*/
2132 M2MB_RESULT_E m2mb_crypto_rsa_keyblob_export( M2MB_CRYPTO_RSA_CONTEXT ctx,
2133  UINT8 *keyblob,
2134  UINT32 *keyblob_length );
2135 
2136 /*-----------------------------------------------------------------------------------------------*/
2170 /*-----------------------------------------------------------------------------------------------*/
2171 M2MB_RESULT_E m2mb_crypto_rsa_keyblob_import( M2MB_CRYPTO_RSA_CONTEXT ctx,
2172  const UINT8 *keyblob,
2173  UINT32 keyblob_length );
2174 
2175 /*-----------------------------------------------------------------------------------------------*/
2291 /*-----------------------------------------------------------------------------------------------*/
2292 M2MB_RESULT_E m2mb_crypto_rsa_public_key_export( M2MB_CRYPTO_RSA_CONTEXT ctx,
2293  UINT8 *modulus,
2294  UINT32 *modulus_size,
2295  UINT8 *public_exponent,
2296  UINT32 *public_exponent_size );
2297 
2298 /*-----------------------------------------------------------------------------------------------*/
2336 /*-----------------------------------------------------------------------------------------------*/
2337 M2MB_RESULT_E m2mb_crypto_rsa_public_key_import( M2MB_CRYPTO_RSA_CONTEXT ctx,
2338  const UINT8 *modulus,
2339  UINT32 modulus_size,
2340  const UINT8 *public_exponent,
2341  UINT32 public_exponent_size );
2342 
2343 /*-----------------------------------------------------------------------------------------------*/
2473 /*-----------------------------------------------------------------------------------------------*/
2474 M2MB_RESULT_E m2mb_crypto_rsa_externalkey_import( M2MB_CRYPTO_RSA_CONTEXT ctx,
2475  const UINT8 *modulus,
2476  UINT32 modulus_size,
2477  const UINT8 *p_factor,
2478  UINT32 p_factor_size,
2479  const UINT8 *q_factor,
2480  UINT32 q_factor_size,
2481  const UINT8 *public_exponent,
2482  UINT32 public_exponent_size,
2483  const UINT8 *private_exponent,
2484  UINT32 private_exponent_size,
2485  M2MB_CRYPTO_RSA_PADDING_TYPE_E padding_type );
2486 
2487 /*-----------------------------------------------------------------------------------------------*/
2549 
2551 
2587 /*-----------------------------------------------------------------------------------------------*/
2588 M2MB_RESULT_E m2mb_crypto_rsa_encrypt( M2MB_CRYPTO_RSA_CONTEXT ctx,
2589  M2MB_CRYPTO_RSA_MODE_E mode,
2590  SIZE_T inlen,
2591  const UINT8 *in,
2592  UINT8 *out );
2593 
2594 
2595 /*-----------------------------------------------------------------------------------------------*/
2643 /*-----------------------------------------------------------------------------------------------*/
2644 M2MB_RESULT_E m2mb_crypto_rsa_decrypt( M2MB_CRYPTO_RSA_CONTEXT ctx,
2645  M2MB_CRYPTO_RSA_MODE_E mode,
2646  SIZE_T *outlen,
2647  UINT8 *out,
2648  SIZE_T out_max_len,
2649  const UINT8 *in );
2650 
2651 /*-----------------------------------------------------------------------------------------------*/
2704 /*-----------------------------------------------------------------------------------------------*/
2705 M2MB_RESULT_E m2mb_crypto_rsa_sign( M2MB_CRYPTO_RSA_CONTEXT ctx,
2706  M2MB_CRYPTO_RSA_MODE_E mode,
2707  M2MB_CRYPTO_MD_ALG_E md_alg,
2708  UINT32 hashlen,
2709  const UINT8 *hash,
2710  UINT8 *sig );
2711 
2712 /*-----------------------------------------------------------------------------------------------*/
2786 
2801 
2815 /*-----------------------------------------------------------------------------------------------*/
2816 M2MB_RESULT_E m2mb_crypto_rsa_verify( M2MB_CRYPTO_RSA_CONTEXT ctx,
2817  UINT8 *pubkey,
2818  UINT32 pubkey_length,
2819  M2MB_CRYPTO_MD_ALG_E md_alg,
2820  UINT32 hashlen,
2821  const UINT8 *hash,
2822  const UINT8 *sig );
2823 
2833 /* Global declarations ==========================================================================*/
2834 
2835 
2836 
2844 typedef enum
2845 {
2846  M2MB_CRYPTO_ECC_DP_BP256R1,
2847  M2MB_CRYPTO_ECC_DP_SECP256R1,
2848  M2MB_CRYPTO_ECC_DP_CUSTOM,
2850  ENUM_TO_INT( M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E )
2851 } M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E;
2852 
2857 //#define M2MB_CRYPTO_ECC_BIGLEN 9
2858 #define M2MB_CRYPTO_ECC_BIGLEN 18
2859 
2864 #define M2MB_MAX_ECC_KEY_SIZE 32
2865 
2873 typedef struct
2874 {
2875  UINT8 x[M2MB_MAX_ECC_KEY_SIZE+1];
2876  UINT8 y[M2MB_MAX_ECC_KEY_SIZE+1];
2877  INT32 flags;
2878  INT32 key_size_bytes;
2879 } M2MB_CRYPTO_ECC_AFFINE_POINT_T;
2880 
2885 typedef enum
2886 {
2887  M2MB_CRYPTO_ECC_DP_P,
2888  M2MB_CRYPTO_ECC_DP_A,
2889  M2MB_CRYPTO_ECC_DP_B,
2890  M2MB_CRYPTO_ECC_DP_G_X,
2891  M2MB_CRYPTO_ECC_DP_G_Y,
2892  M2MB_CRYPTO_ECC_DP_N,
2893  M2MB_CRYPTO_ECC_DP_H,
2894  ENUM_TO_INT( M2MB_CRYPTO_ECC_DP_E )
2895 } M2MB_CRYPTO_ECC_DP_E;
2896 
2897 /* Global functions =============================================================================*/
2898 
2899 /*-----------------------------------------------------------------------------------------------*/
2927 /*-----------------------------------------------------------------------------------------------*/
2928 
2929 M2MB_RESULT_E m2mb_crypto_ecc_init( M2MB_CRYPTO_ECC_CONTEXT *ctx,
2930  M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E curve_domain_params );
2931 
2932 /*-----------------------------------------------------------------------------------------------*/
2978 /*-----------------------------------------------------------------------------------------------*/
2979 
2980 M2MB_RESULT_E m2mb_crypto_ecc_dp_init( M2MB_CRYPTO_ECC_CONTEXT ctx,
2981  UINT8 *p,
2982  UINT8 *a,
2983  UINT8 *b,
2984  UINT8 *g_x,
2985  UINT8 *g_y,
2986  UINT8 *n,
2987  UINT32 *h );
2988 
2989 /*-----------------------------------------------------------------------------------------------*/
3042 /*-----------------------------------------------------------------------------------------------*/
3043 M2MB_RESULT_E m2mb_crypto_ecc_dp_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
3044  M2MB_CRYPTO_ECC_DP_E domain,
3045  UINT32 len,
3046  const UINT8 *param);
3047 
3048 /*-----------------------------------------------------------------------------------------------*/
3088 /*-----------------------------------------------------------------------------------------------*/
3089 M2MB_RESULT_E m2mb_crypto_ecdsa_sign( M2MB_CRYPTO_ECC_CONTEXT ctx,
3090  UINT8 *msg,
3091  UINT32 msg_len,
3092  UINT8 *sig,
3093  SIZE_T sig_len );
3094 
3095 
3096 /*-----------------------------------------------------------------------------------------------*/
3139 /*-----------------------------------------------------------------------------------------------*/
3140 M2MB_RESULT_E m2mb_crypto_ecdsa_verify( M2MB_CRYPTO_ECC_CONTEXT ctx,
3141  UINT8 *msg,
3142  UINT32 msg_len,
3143  M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey,
3144  UINT8 *sig,
3145  SIZE_T sig_len );
3146 
3147 /*-----------------------------------------------------------------------------------------------*/
3188 /*-----------------------------------------------------------------------------------------------*/
3189 M2MB_RESULT_E m2mb_crypto_ecdh_shared_key_derive( M2MB_CRYPTO_ECC_CONTEXT ctx,
3190  UINT8 *shared_keyblob,
3191  UINT16 *shared_keyblob_len,
3192  const M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey );
3193 
3194 /*-----------------------------------------------------------------------------------------------*/
3222 /*-----------------------------------------------------------------------------------------------*/
3223 M2MB_RESULT_E m2mb_crypto_ecc_keypair_generate( M2MB_CRYPTO_ECC_CONTEXT ctx );
3224 
3225 /*-----------------------------------------------------------------------------------------------*/
3259 /*-----------------------------------------------------------------------------------------------*/
3260 M2MB_RESULT_E m2mb_crypto_ecc_keyblob_export( M2MB_CRYPTO_ECC_CONTEXT ctx,
3261  UINT8 *keyblob,
3262  UINT16 *keyblob_length );
3263 
3264 /*-----------------------------------------------------------------------------------------------*/
3298 /*-----------------------------------------------------------------------------------------------*/
3299 M2MB_RESULT_E m2mb_crypto_ecc_keyblob_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
3300  const UINT8 *keyblob,
3301  UINT32 keyblob_length );
3302 
3303 
3304 /*-----------------------------------------------------------------------------------------------*/
3334 /*-----------------------------------------------------------------------------------------------*/
3335 M2MB_RESULT_E m2mb_crypto_ecc_public_key_export( M2MB_CRYPTO_ECC_CONTEXT ctx,
3336  M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey );
3337 
3338 /*-----------------------------------------------------------------------------------------------*/
3368 /*-----------------------------------------------------------------------------------------------*/
3369 M2MB_RESULT_E m2mb_crypto_ecc_public_key_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
3370  const M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey );
3371 
3372 
3373 #ifdef TZ_DEBUG
3374 /*-----------------------------------------------------------------------------------------------*/
3408 /*-----------------------------------------------------------------------------------------------*/
3409 M2MB_RESULT_E m2mb_crypto_ecc_private_key_export( M2MB_CRYPTO_ECC_CONTEXT ctx,
3410  UINT8 *private_key,
3411  UINT16 *private_key_len);
3412 
3413 #endif
3414 
3415 /*-----------------------------------------------------------------------------------------------*/
3447 /*-----------------------------------------------------------------------------------------------*/
3448 M2MB_RESULT_E m2mb_crypto_ecc_private_key_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
3449  const UINT8 *privkey,
3450  UINT16 privkey_len );
3451 
3452 /*-----------------------------------------------------------------------------------------------*/
3476 /*-----------------------------------------------------------------------------------------------*/
3477 M2MB_RESULT_E m2mb_crypto_ecc_deinit( M2MB_CRYPTO_ECC_CONTEXT ctx );
3478 
3489 /* Global declarations ==========================================================================*/
3490 
3492 #define M2MB_CRYPTO_PRNG_MAX_BYTES 512
3493 
3494 /* Global functions =============================================================================*/
3495 
3496 /*-----------------------------------------------------------------------------------------------*/
3521 /*-----------------------------------------------------------------------------------------------*/
3522 UINT32 m2mb_crypto_prng_get_data( UINT8 *prng_data,
3523  UINT32 prng_data_len );
3527 #endif /* M2M_M2MB_CRYPTO_H */
m2mb_crypto_rsa_sign
M2MB_RESULT_E m2mb_crypto_rsa_sign(M2MB_CRYPTO_RSA_CONTEXT ctx, M2MB_CRYPTO_RSA_MODE_E mode, M2MB_CRYPTO_MD_ALG_E md_alg, UINT32 hashlen, const UINT8 *hash, UINT8 *sig)
Generic RSA PKCS#1 signature creation method. The signature is created using the context key (created...
m2mb_crypto_ecc_keyblob_export
M2MB_RESULT_E m2mb_crypto_ecc_keyblob_export(M2MB_CRYPTO_ECC_CONTEXT ctx, UINT8 *keyblob, UINT16 *keyblob_length)
Exports an ECC key pair blob from the given context. The blob is encrypted with a device specific key...
M2MB_CRYPTO_RSA_PADDING_PKCS1_PSS
Definition: m2mb_crypto.h:1731
m2mb_crypto_get_algo
M2MB_CRYPTO_CTX_ALG_E m2mb_crypto_get_algo(M2MB_CRYPTO_GEN_CONTEXT ctx)
Returns the Crypto algorithm.
M2MB_CRYPTO_RSA_PADDING_PKCS1_OAEP
Definition: m2mb_crypto.h:1729
m2mb_crypto_cmac
UINT8 * m2mb_crypto_cmac(M2MB_CRYPTO_CMAC_ALG_E cmac_alg, const UINT8 *key, const SIZE_T keylen, const UINT8 *input, const SIZE_T inlen, UINT8 *cmac)
This function will compute the CMAC in one shot without needing any context.
m2mb_crypto_cmac_setup
M2MB_RESULT_E m2mb_crypto_cmac_setup(M2MB_CRYPTO_CMAC_CONTEXT ctx, const UINT8 *key, SIZE_T keylen)
Sets up an M2MB_CRYPTO_CMAC_CONTEXT structure.
M2MB_CRYPTO_AES_CONTEXT
struct M2MB_CRYPTO_AES_CONTEXT_TAG * M2MB_CRYPTO_AES_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:104
M2MB_CRYPTO_AES_IV_SIZE
#define M2MB_CRYPTO_AES_IV_SIZE
Definition: m2mb_crypto.h:965
M2MB_CRYPTO_ECC_DP_SECP256R1
Definition: m2mb_crypto.h:2847
M2MB_CRYPTO_DES_KEY_SIZE
#define M2MB_CRYPTO_DES_KEY_SIZE
Definition: m2mb_crypto.h:1321
m2mb_crypto_3des_2externalkey_import
M2MB_RESULT_E m2mb_crypto_3des_2externalkey_import(M2MB_CRYPTO_DES_CONTEXT ctx, const UINT8 key[M2MB_CRYPTO_3DES_KEY2_SIZE])
Sets up a 3DES encryption key (128 bits = 112 effective bits key + parity) for a given context.
M2MB_CRYPTO_DES_MODE_E
M2MB_CRYPTO_DES_MODE_E
Definition: m2mb_crypto.h:1313
m2mb_crypto_3des_3externalkey_import
M2MB_RESULT_E m2mb_crypto_3des_3externalkey_import(M2MB_CRYPTO_DES_CONTEXT ctx, const UINT8 key[M2MB_CRYPTO_3DES_KEY3_SIZE])
Sets up a 3DES encryption key (192 bits = 168 effective bits key + parity) for a given context.
m2mb_crypto_rsa_generate_key
M2MB_RESULT_E m2mb_crypto_rsa_generate_key(M2MB_CRYPTO_RSA_CONTEXT ctx, UINT32 key_size, UINT32 public_exponent)
Generates an RSA key pair.
m2mb_crypto_aes_keyblob_export
M2MB_RESULT_E m2mb_crypto_aes_keyblob_export(M2MB_CRYPTO_AES_CONTEXT ctx, UINT8 *keyblob, UINT32 *keyblob_length)
Exports the AES symmetric key from the given context.
m2mb_crypto_rsa_public
M2MB_RESULT_E m2mb_crypto_rsa_public(M2MB_CRYPTO_RSA_CONTEXT ctx, const UINT8 *in, UINT8 *out)
RSA public key operation.
M2MB_CRYPTO_AES_MODE_E
M2MB_CRYPTO_AES_MODE_E
AES operation mode (encrypt decrypt)
Definition: m2mb_crypto.h:954
m2mb_crypto_des_deinit
M2MB_RESULT_E m2mb_crypto_des_deinit(M2MB_CRYPTO_DES_CONTEXT ctx)
Free an M2MB_CRYPTO_DES_CONTEXT structure.
m2mb_crypto_prng_get_data
UINT32 m2mb_crypto_prng_get_data(UINT8 *prng_data, UINT32 prng_data_len)
Generates prng data.
m2mb_crypto_aes_keyblob_import
M2MB_RESULT_E m2mb_crypto_aes_keyblob_import(M2MB_CRYPTO_AES_CONTEXT ctx, const UINT8 *keyblob, UINT32 keyblob_length)
Import a symmetric key, previously generated on the same device, into a given context.
M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E
M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E
Definition: m2mb_crypto.h:2844
m2mb_crypto_ecdh_shared_key_derive
M2MB_RESULT_E m2mb_crypto_ecdh_shared_key_derive(M2MB_CRYPTO_ECC_CONTEXT ctx, UINT8 *shared_keyblob, UINT16 *shared_keyblob_len, const M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey)
Function to derive the shared key for the DH algorithm.
m2mb_crypto_hmac_deinit
M2MB_RESULT_E m2mb_crypto_hmac_deinit(M2MB_CRYPTO_HMAC_CONTEXT ctx)
This function free an HMAC context releasing the associated resources.
M2MB_CRYPTO_RSA_PADDING_NONE
Definition: m2mb_crypto.h:1735
M2MB_CRYPTO_DES_CONTEXT
struct M2MB_CRYPTO_DES_CONTEXT_TAG * M2MB_CRYPTO_DES_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:110
m2mb_crypto_rsa_encrypt
M2MB_RESULT_E m2mb_crypto_rsa_encrypt(M2MB_CRYPTO_RSA_CONTEXT ctx, M2MB_CRYPTO_RSA_MODE_E mode, SIZE_T inlen, const UINT8 *in, UINT8 *out)
Generic RSA PKCS#1 encryption method. This function adds the message padding, then performs an RSA op...
m2mb_crypto_hmac_final
M2MB_RESULT_E m2mb_crypto_hmac_final(M2MB_CRYPTO_HMAC_CONTEXT ctx, UINT8 *hmac)
This function computes the final HMAC for all previously provided messages for the given context.
M2MB_CRYPTO_ECC_DP_BP256R1
Definition: m2mb_crypto.h:2846
m2mb_crypto_rsa_keyblob_import
M2MB_RESULT_E m2mb_crypto_rsa_keyblob_import(M2MB_CRYPTO_RSA_CONTEXT ctx, const UINT8 *keyblob, UINT32 keyblob_length)
Imports an RSA key pair into the context.
M2MB_CRYPTO_RSA_MODE_E
M2MB_CRYPTO_RSA_MODE_E
The operation mode (encrypt/decrypt).
Definition: m2mb_crypto.h:1744
m2mb_crypto_ecc_keyblob_import
M2MB_RESULT_E m2mb_crypto_ecc_keyblob_import(M2MB_CRYPTO_ECC_CONTEXT ctx, const UINT8 *keyblob, UINT32 keyblob_length)
Imports an ECC key pair keyblob into the context.
m2mb_crypto_ecc_public_key_import
M2MB_RESULT_E m2mb_crypto_ecc_public_key_import(M2MB_CRYPTO_ECC_CONTEXT ctx, const M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey)
Imports an ECC public key to the given context.
m2mb_crypto_md_init
M2MB_RESULT_E m2mb_crypto_md_init(M2MB_CRYPTO_MD_CONTEXT *ctx)
Allocates an M2MB_CRYPTO_MD_CONTEXT structure.
m2mb_crypto_cmac_init
M2MB_RESULT_E m2mb_crypto_cmac_init(M2MB_CRYPTO_CMAC_CONTEXT *ctx)
Allocates a M2MB_CRYPTO_CMAC_CONTEXT structure.
m2mb_crypto_aes_ecb_encdec
M2MB_RESULT_E m2mb_crypto_aes_ecb_encdec(M2MB_CRYPTO_AES_CONTEXT ctx, M2MB_CRYPTO_AES_MODE_E mode, const UINT8 in[M2MB_CRYPTO_AES_ECB_BLOCK_SIZE], UINT8 out[M2MB_CRYPTO_AES_ECB_BLOCK_SIZE])
Encrypts/decrypts a single 16 bytes block onto the output buffer using the AES ECB algorithm.
m2mb_crypto_cmac_update
M2MB_RESULT_E m2mb_crypto_cmac_update(M2MB_CRYPTO_CMAC_CONTEXT ctx, const UINT8 *data, SIZE_T len)
continuously CMAC of data. This function can be called repeatedly similar to streaming
m2mb_crypto_md_update
M2MB_RESULT_E m2mb_crypto_md_update(M2MB_CRYPTO_MD_CONTEXT ctx, const UINT8 *data, SIZE_T len)
Continuously hashing of data. This function should be called repeatedly with chunks of the message to...
M2MB_CRYPTO_MD_CONTEXT
struct M2MB_CRYPTO_MD_CONTEXT_TAG * M2MB_CRYPTO_MD_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:86
m2mb_crypto_rsa_init
M2MB_RESULT_E m2mb_crypto_rsa_init(M2MB_CRYPTO_RSA_CONTEXT *ctx, M2MB_CRYPTO_RSA_PADDING_TYPE_E padding_type, M2MB_CRYPTO_MD_ALG_E hash_id)
Allocates an M2MB_CRYPTO_RSA_CONTEXT structure.
m2mb_crypto_ecdsa_sign
M2MB_RESULT_E m2mb_crypto_ecdsa_sign(M2MB_CRYPTO_ECC_CONTEXT ctx, UINT8 *msg, UINT32 msg_len, UINT8 *sig, SIZE_T sig_len)
ECDSA signature function.
m2mb_crypto_ctx_info_for_tee
UINT32 m2mb_crypto_ctx_info_for_tee(M2MB_CRYPTO_GEN_CONTEXT ctx, UINT8 *info)
Returns the context ID for the given context structure.
m2mb_crypto_aes_externalkey_import
M2MB_RESULT_E m2mb_crypto_aes_externalkey_import(M2MB_CRYPTO_AES_CONTEXT ctx, const UINT8 *key, UINT32 keylength)
Imports a symmetric key into the given context. This is a plaintext key that may have been generated ...
m2mb_crypto_rsa_keyblob_export
M2MB_RESULT_E m2mb_crypto_rsa_keyblob_export(M2MB_CRYPTO_RSA_CONTEXT ctx, UINT8 *keyblob, UINT32 *keyblob_length)
Exports an RSA key pair blob from the given context. The blob is encrypted with a device specific key...
M2MB_CRYPTO_DES_BLOCK_BYTE_LEN
#define M2MB_CRYPTO_DES_BLOCK_BYTE_LEN
Definition: m2mb_crypto.h:1330
m2mb_crypto_rsa_deinit
M2MB_RESULT_E m2mb_crypto_rsa_deinit(M2MB_CRYPTO_RSA_CONTEXT ctx)
Free an M2MB_CRYPTO_RSA_CONTEXT structure.
M2MB_CRYPTO_RSA_CONTEXT
struct M2MB_CRYPTO_RSA_CONTEXT_TAG * M2MB_CRYPTO_RSA_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:116
m2mb_crypto_ecc_init
M2MB_RESULT_E m2mb_crypto_ecc_init(M2MB_CRYPTO_ECC_CONTEXT *ctx, M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E curve_domain_params)
Allocates an M2MB_CRYPTO_ECC_CONTEXT structure.
m2mb_crypto_md_final
M2MB_RESULT_E m2mb_crypto_md_final(M2MB_CRYPTO_MD_CONTEXT ctx, UINT8 *md)
This function computes the final digest for the hash process.
m2mb_crypto_md_setup
M2MB_RESULT_E m2mb_crypto_md_setup(M2MB_CRYPTO_MD_CONTEXT ctx, const M2MB_CRYPTO_MD_ALG_E md_info)
Sets up a M2MB_CRYPTO_MD_CONTEXT structure.
m2mb_crypto_ecc_public_key_export
M2MB_RESULT_E m2mb_crypto_ecc_public_key_export(M2MB_CRYPTO_ECC_CONTEXT ctx, M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey)
Exports an ECC public key from the given context.
M2MB_CRYPTO_ECC_AFFINE_POINT_T
Structure representing the X,Y coordinates of a point. The point is zero, or "at infinity",...
Definition: m2mb_crypto.h:2873
M2MB_MAX_ECC_KEY_SIZE
#define M2MB_MAX_ECC_KEY_SIZE
Maximum size for key size (x or y coordinates in binary format, private key).
Definition: m2mb_crypto.h:2864
M2MB_CRYPTO_DES_ALG_TYPE_E
M2MB_CRYPTO_DES_ALG_TYPE_E
Definition: m2mb_crypto.h:1305
m2mb_crypto_des_externalkey_import
M2MB_RESULT_E m2mb_crypto_des_externalkey_import(M2MB_CRYPTO_DES_CONTEXT ctx, const UINT8 key[M2MB_CRYPTO_DES_KEY_SIZE])
Sets up a DES encryption key (64 bits = 56 effective bits key + parity) for a given context.
m2mb_crypto_md_deinit
M2MB_RESULT_E m2mb_crypto_md_deinit(M2MB_CRYPTO_MD_CONTEXT ctx)
This function frees an MD context.
m2mb_crypto_ecc_private_key_import
M2MB_RESULT_E m2mb_crypto_ecc_private_key_import(M2MB_CRYPTO_ECC_CONTEXT ctx, const UINT8 *privkey, UINT16 privkey_len)
Imports an ECC private key to the given context.
m2mb_crypto_hmac_setup
M2MB_RESULT_E m2mb_crypto_hmac_setup(M2MB_CRYPTO_HMAC_CONTEXT ctx, M2MB_CRYPTO_MD_ALG_E md_info, const UINT8 *key, SIZE_T keylen)
Sets up an M2MB_CRYPTO_HMAC_CONTEXT structure.
M2MB_CRYPTO_ECC_CONTEXT
struct M2MB_CRYPTO_ECC_CONTEXT_TAG * M2MB_CRYPTO_ECC_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:122
M2MB_CRYPTO_ECC_DP_E
M2MB_CRYPTO_ECC_DP_E
Enumeration representing all the ECC Domain Parameters.
Definition: m2mb_crypto.h:2885
m2mb_crypto_cmac_deinit
M2MB_RESULT_E m2mb_crypto_cmac_deinit(M2MB_CRYPTO_CMAC_CONTEXT ctx)
This function free an CMAC context.
m2mb_crypto_md
UINT8 * m2mb_crypto_md(const M2MB_CRYPTO_MD_ALG_E md_info, const UINT8 *data, SIZE_T len, UINT8 *md)
This function will compute the message digest in one shot, in case of limited and available size of d...
M2MB_CRYPTO_MD_ALG_E
M2MB_CRYPTO_MD_ALG_E
Enumeration respresenting all supported HASH algorithms.
Definition: m2mb_crypto.h:128
m2mb_crypto_des_init
M2MB_RESULT_E m2mb_crypto_des_init(M2MB_CRYPTO_DES_CONTEXT *ctx, M2MB_CRYPTO_DES_ALG_TYPE_E des_alg)
Allocates an M2MB_CRYPTO_DES_CONTEXT structure.
m2mb_crypto_hmac_init
M2MB_RESULT_E m2mb_crypto_hmac_init(M2MB_CRYPTO_HMAC_CONTEXT *ctx)
Opaque structure for context.
m2mb_crypto_des_cbc_encdec
M2MB_RESULT_E m2mb_crypto_des_cbc_encdec(M2MB_CRYPTO_DES_CONTEXT ctx, M2MB_CRYPTO_DES_MODE_E mode, const UINT8 *in, UINT8 *out, SIZE_T inlen, UINT8 ivec[M2MB_CRYPTO_DES_IV_BYTE_LEN])
Encrypts/decrypts a given buffer with a given length using the DES CBC. The length must be a multiple...
m2mb_crypto_ecc_dp_import
M2MB_RESULT_E m2mb_crypto_ecc_dp_import(M2MB_CRYPTO_ECC_CONTEXT ctx, M2MB_CRYPTO_ECC_DP_E domain, UINT32 len, const UINT8 *param)
Imports an ECC Domain Parameter to the given context.
M2MB_CRYPTO_CTX_ALG_E
M2MB_CRYPTO_CTX_ALG_E
Enumeration representing all supported Crypto algorithms.
Definition: m2mb_crypto.h:55
M2MB_CRYPTO_DES_IV_BYTE_LEN
#define M2MB_CRYPTO_DES_IV_BYTE_LEN
Definition: m2mb_crypto.h:1333
m2mb_crypto_hmac
UINT8 * m2mb_crypto_hmac(M2MB_CRYPTO_MD_ALG_E md_info, const UINT8 *key, const SIZE_T keylen, const UINT8 *input, const SIZE_T inlen, UINT8 *hmac)
This function will compute the HMAC in one shot without needing any context.
m2mb_crypto_ecdsa_verify
M2MB_RESULT_E m2mb_crypto_ecdsa_verify(M2MB_CRYPTO_ECC_CONTEXT ctx, UINT8 *msg, UINT32 msg_len, M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey, UINT8 *sig, SIZE_T sig_len)
ECDSA signature verification function.
M2MB_CRYPTO_3DES_KEY2_SIZE
#define M2MB_CRYPTO_3DES_KEY2_SIZE
Definition: m2mb_crypto.h:1324
M2MB_CRYPTO_CMAC_CONTEXT
struct M2MB_CRYPTO_CMAC_CONTEXT_TAG * M2MB_CRYPTO_CMAC_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:98
M2MB_CRYPTO_HMAC_CONTEXT
struct M2MB_CRYPTO_HMAC_CONTEXT_TAG * M2MB_CRYPTO_HMAC_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:92
m2mb_crypto_aes_deinit
M2MB_RESULT_E m2mb_crypto_aes_deinit(M2MB_CRYPTO_AES_CONTEXT ctx)
Free an M2MB_CRYPTO_AES_CONTEXT structure.
m2mb_crypto_aes_init
M2MB_RESULT_E m2mb_crypto_aes_init(M2MB_CRYPTO_AES_CONTEXT *ctx)
Allocates an M2MB_CRYPTO_AES_CONTEXT structure.
m2mb_crypto_ecc_keypair_generate
M2MB_RESULT_E m2mb_crypto_ecc_keypair_generate(M2MB_CRYPTO_ECC_CONTEXT ctx)
Function to generate an ECC keypair.
m2mb_crypto_des_keyblob_import
M2MB_RESULT_E m2mb_crypto_des_keyblob_import(M2MB_CRYPTO_DES_CONTEXT ctx, const UINT8 *keyblob, UINT32 keyblob_length)
Imports a DES/3DES symmetric key into the context.
M2MB_CRYPTO_RSA_PADDING_TYPE_E
M2MB_CRYPTO_RSA_PADDING_TYPE_E
Padding types for RSA encryption.
Definition: m2mb_crypto.h:1724
m2mb_crypto_rsa_private
M2MB_RESULT_E m2mb_crypto_rsa_private(M2MB_CRYPTO_RSA_CONTEXT ctx, const UINT8 *in, UINT8 *out)
RSA private key operation.
m2mb_crypto_rsa_public_key_import
M2MB_RESULT_E m2mb_crypto_rsa_public_key_import(M2MB_CRYPTO_RSA_CONTEXT ctx, const UINT8 *modulus, UINT32 modulus_size, const UINT8 *public_exponent, UINT32 public_exponent_size)
Imports an RSA public key to the given context.
m2mb_crypto_cmac_reset
M2MB_RESULT_E m2mb_crypto_cmac_reset(M2MB_CRYPTO_CMAC_CONTEXT ctx)
Prepare to run CMAC for a new message.
m2mb_crypto_hmac_update
M2MB_RESULT_E m2mb_crypto_hmac_update(M2MB_CRYPTO_HMAC_CONTEXT ctx, const UINT8 *data, SIZE_T len)
Continuously HMAC of data. This function can be called repeatedly similar to streaming.
M2MB_CRYPTO_ECC_DP_CUSTOM
Definition: m2mb_crypto.h:2848
m2mb_crypto_rsa_externalkey_import
M2MB_RESULT_E m2mb_crypto_rsa_externalkey_import(M2MB_CRYPTO_RSA_CONTEXT ctx, const UINT8 *modulus, UINT32 modulus_size, const UINT8 *p_factor, UINT32 p_factor_size, const UINT8 *q_factor, UINT32 q_factor_size, const UINT8 *public_exponent, UINT32 public_exponent_size, const UINT8 *private_exponent, UINT32 private_exponent_size, M2MB_CRYPTO_RSA_PADDING_TYPE_E padding_type)
Imports an externally generated RSA key pair into the context.
m2mb_crypto_des_keyblob_export
M2MB_RESULT_E m2mb_crypto_des_keyblob_export(M2MB_CRYPTO_DES_CONTEXT ctx, UINT8 *keyblob, UINT32 *keyblob_length)
Exports a DES key blob from the given context. The blob is encrypted with a device specific key and c...
m2mb_crypto_hmac_reset
M2MB_RESULT_E m2mb_crypto_hmac_reset(M2MB_CRYPTO_HMAC_CONTEXT ctx)
Prepare to run HMAC for a new message reusing the context.
m2mb_crypto_rsa_public_key_export
M2MB_RESULT_E m2mb_crypto_rsa_public_key_export(M2MB_CRYPTO_RSA_CONTEXT ctx, UINT8 *modulus, UINT32 *modulus_size, UINT8 *public_exponent, UINT32 *public_exponent_size)
Exports an RSA public key from the given context.
m2mb_crypto_rsa_decrypt
M2MB_RESULT_E m2mb_crypto_rsa_decrypt(M2MB_CRYPTO_RSA_CONTEXT ctx, M2MB_CRYPTO_RSA_MODE_E mode, SIZE_T *outlen, UINT8 *out, SIZE_T out_max_len, const UINT8 *in)
Generic RSA PKCS#1 decryption method. This function performs an RSA operation (decryption),...
M2MB_CRYPTO_RSA_PADDING_PKCS1_V15
Definition: m2mb_crypto.h:1727
m2mb_crypto_cmac_final
M2MB_RESULT_E m2mb_crypto_cmac_final(M2MB_CRYPTO_CMAC_CONTEXT ctx, UINT8 *cmac)
This function computes the final CMAC for all previously provided messages for the given context.
m2mb_crypto_ecc_dp_init
M2MB_RESULT_E m2mb_crypto_ecc_dp_init(M2MB_CRYPTO_ECC_CONTEXT ctx, UINT8 *p, UINT8 *a, UINT8 *b, UINT8 *g_x, UINT8 *g_y, UINT8 *n, UINT32 *h)
Allocates an M2MB_CRYPTO_ECC_CONTEXT structure.
m2mb_crypto_des_generate_key
M2MB_RESULT_E m2mb_crypto_des_generate_key(M2MB_CRYPTO_DES_CONTEXT ctx, UINT32 keybits)
Generates a DES encryption key for a given context.
M2MB_CRYPTO_GEN_CONTEXT
struct M2MB_CRYPTO_GEN_CONTEXT_TAG * M2MB_CRYPTO_GEN_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:79
M2MB_CRYPTO_3DES_KEY3_SIZE
#define M2MB_CRYPTO_3DES_KEY3_SIZE
Definition: m2mb_crypto.h:1327
m2mb_crypto_des_ecb_encdec
M2MB_RESULT_E m2mb_crypto_des_ecb_encdec(M2MB_CRYPTO_DES_CONTEXT ctx, M2MB_CRYPTO_DES_MODE_E mode, const UINT8 in[M2MB_CRYPTO_DES_BLOCK_BYTE_LEN], UINT8 out[M2MB_CRYPTO_DES_BLOCK_BYTE_LEN])
Encrypts/decrypts a single 8 bytes block onto the output buffer using the DES ECB algorithm.
M2MB_CRYPTO_RSA_PADDING_PKCS1_PSS_AUTORECOVER_SALTLEN
Definition: m2mb_crypto.h:1733
m2mb_crypto_aes_cbc_encdec
M2MB_RESULT_E m2mb_crypto_aes_cbc_encdec(M2MB_CRYPTO_AES_CONTEXT ctx, M2MB_CRYPTO_AES_MODE_E mode, const UINT8 *in, UINT8 *out, SIZE_T inlen, UINT8 ivec[M2MB_CRYPTO_AES_IV_SIZE])
Encrypts/decrypts a given buffer with a given length using the AES CBC. The length must be a multiple...
m2mb_crypto_rsa_verify
M2MB_RESULT_E m2mb_crypto_rsa_verify(M2MB_CRYPTO_RSA_CONTEXT ctx, UINT8 *pubkey, UINT32 pubkey_length, M2MB_CRYPTO_MD_ALG_E md_alg, UINT32 hashlen, const UINT8 *hash, const UINT8 *sig)
Generic RSA PKCS#1 signature verification method.
M2MB_CRYPTO_AES_ECB_BLOCK_SIZE
#define M2MB_CRYPTO_AES_ECB_BLOCK_SIZE
Definition: m2mb_crypto.h:962
m2mb_crypto_ecc_deinit
M2MB_RESULT_E m2mb_crypto_ecc_deinit(M2MB_CRYPTO_ECC_CONTEXT ctx)
Free an M2MB_CRYPTO_ECC_CONTEXT structure.
m2mb_crypto_aes_generate_key
M2MB_RESULT_E m2mb_crypto_aes_generate_key(M2MB_CRYPTO_AES_CONTEXT ctx, UINT32 keybits)
Generates an AES encryption key for a given context.