m2mb API docs  25.30.004.0
m2mb API sets documentation
m2mb_crypto.h
Go to the documentation of this file.
1 /* $version: 252203 */
2 /*===============================================================================================*/
3 /* >>> Copyright (C) Telit Communications S.p.A. Italy All Rights Reserved. <<< */
26 #ifndef M2M_M2MB_CRYPTO_H
27 #define M2M_M2MB_CRYPTO_H
28 
34 /* Global declarations ==========================================================================*/
35 
36 #define TZ_LOGGING
37 
38 /* free choice to use free or deinit in Telit style */
39 #define m2mb_crypto_md_free m2mb_crypto_md_deinit
40 #define m2mb_crypto_hmac_free m2mb_crypto_hmac_deinit
41 #define m2mb_crypto_cmac_free m2mb_crypto_cmac_deinit
42 #define m2mb_crypto_aes_free m2mb_crypto_aes_deinit
43 #define m2mb_crypto_des_free m2mb_crypto_des_deinit
44 #define m2mb_crypto_rsa_free m2mb_crypto_rsa_deinit
45 #define m2mb_crypto_ecc_free m2mb_crypto_ecc_deinit
46 
47 
48 
49 
50 /* Global typedef ==========================================================================*/
51 
56 typedef enum
57 {
58  M2MB_CRYPTO_CTX_ALG_NONE=0,
59  M2MB_CRYPTO_CTX_ALG_MD2,
60  M2MB_CRYPTO_CTX_ALG_MD4,
61  M2MB_CRYPTO_CTX_ALG_MD5,
62  M2MB_CRYPTO_CTX_ALG_SHA1,
63  M2MB_CRYPTO_CTX_ALG_SHA224,
64  M2MB_CRYPTO_CTX_ALG_SHA256,
65  M2MB_CRYPTO_CTX_ALG_SHA384,
66  M2MB_CRYPTO_CTX_ALG_SHA512,
67  M2MB_CRYPTO_CTX_ALG_HMAC,
68  M2MB_CRYPTO_CTX_ALG_CMAC,
69  M2MB_CRYPTO_CTX_ALG_RSA,
70  M2MB_CRYPTO_CTX_ALG_ECC,
71  M2MB_CRYPTO_CTX_ALG_AES,
72  M2MB_CRYPTO_CTX_ALG_DES,
73  ENUM_TO_INT( M2MB_CRYPTO_CTX_ALG_E )
74 } M2MB_CRYPTO_CTX_ALG_E;
75 
80 typedef struct M2MB_CRYPTO_GEN_CONTEXT_TAG *M2MB_CRYPTO_GEN_CONTEXT;
81 
82 
87 typedef struct M2MB_CRYPTO_MD_CONTEXT_TAG *M2MB_CRYPTO_MD_CONTEXT;
88 
93 typedef struct M2MB_CRYPTO_HMAC_CONTEXT_TAG *M2MB_CRYPTO_HMAC_CONTEXT;
94 
99 typedef struct M2MB_CRYPTO_CMAC_CONTEXT_TAG *M2MB_CRYPTO_CMAC_CONTEXT;
100 
105 typedef struct M2MB_CRYPTO_AES_CONTEXT_TAG *M2MB_CRYPTO_AES_CONTEXT;
106 
111 typedef struct M2MB_CRYPTO_DES_CONTEXT_TAG *M2MB_CRYPTO_DES_CONTEXT;
112 
117 typedef struct M2MB_CRYPTO_RSA_CONTEXT_TAG *M2MB_CRYPTO_RSA_CONTEXT;
118 
123 typedef struct M2MB_CRYPTO_ECC_CONTEXT_TAG *M2MB_CRYPTO_ECC_CONTEXT;
124 
129 typedef enum
130 {
131  M2MB_CRYPTO_MD_ALG_NONE=0,
132  M2MB_CRYPTO_MD_ALG_MD2,
133  M2MB_CRYPTO_MD_ALG_MD4,
134  M2MB_CRYPTO_MD_ALG_MD5,
135  M2MB_CRYPTO_MD_ALG_SHA1,
136  M2MB_CRYPTO_MD_ALG_SHA224,
137  M2MB_CRYPTO_MD_ALG_SHA256,
138  M2MB_CRYPTO_MD_ALG_SHA384,
139  M2MB_CRYPTO_MD_ALG_SHA512,
140  ENUM_TO_INT( M2MB_CRYPTO_MD_ALG_E )
141 } M2MB_CRYPTO_MD_ALG_E;
142 
143 /* Global functions =============================================================================*/
144 
145 /*-----------------------------------------------------------------------------------------------*/
165 /*-----------------------------------------------------------------------------------------------*/
166 M2MB_CRYPTO_CTX_ALG_E m2mb_crypto_get_algo( M2MB_CRYPTO_GEN_CONTEXT ctx );
167 
168 /*-----------------------------------------------------------------------------------------------*/
192 /*-----------------------------------------------------------------------------------------------*/
193 UINT32 m2mb_crypto_ctx_info_for_tee( M2MB_CRYPTO_GEN_CONTEXT ctx, UINT8 *info );
194 
195 /*-----------------------------------------------------------------------------------------------*/
221 /*-----------------------------------------------------------------------------------------------*/
222 M2MB_RESULT_E m2mb_crypto_md_init( M2MB_CRYPTO_MD_CONTEXT *ctx );
223 
251 /*-----------------------------------------------------------------------------------------------*/
252 M2MB_RESULT_E m2mb_crypto_md_setup( M2MB_CRYPTO_MD_CONTEXT ctx,
253  const M2MB_CRYPTO_MD_ALG_E md_info );
254 
255 /*-----------------------------------------------------------------------------------------------*/
287 /*-----------------------------------------------------------------------------------------------*/
288 M2MB_RESULT_E m2mb_crypto_md_update( M2MB_CRYPTO_MD_CONTEXT ctx,
289  const UINT8 *data,
290  SIZE_T len );
291 
292 /*-----------------------------------------------------------------------------------------------*/
321 /*-----------------------------------------------------------------------------------------------*/
322 M2MB_RESULT_E m2mb_crypto_md_final( M2MB_CRYPTO_MD_CONTEXT ctx,
323  UINT8 *md );
324 
325 /*-----------------------------------------------------------------------------------------------*/
350 /*-----------------------------------------------------------------------------------------------*/
351 M2MB_RESULT_E m2mb_crypto_md_deinit( M2MB_CRYPTO_MD_CONTEXT ctx );
352 
353 /*-----------------------------------------------------------------------------------------------*/
399 /*-----------------------------------------------------------------------------------------------*/
400 UINT8 *m2mb_crypto_md( const M2MB_CRYPTO_MD_ALG_E md_info,
401  const UINT8 *data,
402  SIZE_T len,
403  UINT8 *md );
404 
405 
406 /* Global declarations ==========================================================================*/
407 
414 /* Global functions =============================================================================*/
415 
416 /*-----------------------------------------------------------------------------------------------*/
441 /*-----------------------------------------------------------------------------------------------*/
442 M2MB_RESULT_E m2mb_crypto_hmac_init( M2MB_CRYPTO_HMAC_CONTEXT *ctx );
443 
480 /*-----------------------------------------------------------------------------------------------*/
481 M2MB_RESULT_E m2mb_crypto_hmac_setup( M2MB_CRYPTO_HMAC_CONTEXT ctx,
482  M2MB_CRYPTO_MD_ALG_E md_info,
483  const UINT8 *key,
484  SIZE_T keylen );
485 
486 /*-----------------------------------------------------------------------------------------------*/
519 /*-----------------------------------------------------------------------------------------------*/
520 M2MB_RESULT_E m2mb_crypto_hmac_update( M2MB_CRYPTO_HMAC_CONTEXT ctx,
521  const UINT8 *data,
522  SIZE_T len );
523 
524 /*-----------------------------------------------------------------------------------------------*/
554 /*-----------------------------------------------------------------------------------------------*/
555 M2MB_RESULT_E m2mb_crypto_hmac_final( M2MB_CRYPTO_HMAC_CONTEXT ctx,
556  UINT8 *hmac );
557 
558 /*-----------------------------------------------------------------------------------------------*/
584 /*-----------------------------------------------------------------------------------------------*/
585 M2MB_RESULT_E m2mb_crypto_hmac_reset( M2MB_CRYPTO_HMAC_CONTEXT ctx );
586 
587 /*-----------------------------------------------------------------------------------------------*/
611 /*-----------------------------------------------------------------------------------------------*/
612 M2MB_RESULT_E m2mb_crypto_hmac_deinit( M2MB_CRYPTO_HMAC_CONTEXT ctx );
613 
614 /*-----------------------------------------------------------------------------------------------*/
664 /*-----------------------------------------------------------------------------------------------*/
665 UINT8 *m2mb_crypto_hmac( M2MB_CRYPTO_MD_ALG_E md_info,
666  const UINT8 *key,
667  const SIZE_T keylen,
668  const UINT8 *input,
669  const SIZE_T inlen,
670  UINT8 *hmac );
671 
681 /* Global declarations ==========================================================================*/
682 
683 
684 typedef enum
685 {
686  M2MB_CRYPTO_CMAC_ALG_AES_128 = 1,
687  M2MB_CRYPTO_CMAC_ALG_AES_192 = 2,
688  M2MB_CRYPTO_CMAC_ALG_AES_256 = 3,
689  ENUM_TO_INT( M2MB_CRYPTO_CMAC_ALG_E )
690 } M2MB_CRYPTO_CMAC_ALG_E;
691 
692 /* Global functions =============================================================================*/
693 
694 /*-----------------------------------------------------------------------------------------------*/
719 /*-----------------------------------------------------------------------------------------------*/
720 M2MB_RESULT_E m2mb_crypto_cmac_init( M2MB_CRYPTO_CMAC_CONTEXT *ctx );
721 
754 /*-----------------------------------------------------------------------------------------------*/
755 M2MB_RESULT_E m2mb_crypto_cmac_setup( M2MB_CRYPTO_CMAC_CONTEXT ctx,
756  const UINT8 *key,
757  SIZE_T keylen );
758 
759 /*-----------------------------------------------------------------------------------------------*/
792 /*-----------------------------------------------------------------------------------------------*/
793 M2MB_RESULT_E m2mb_crypto_cmac_update( M2MB_CRYPTO_CMAC_CONTEXT ctx,
794  const UINT8 *data,
795  SIZE_T len );
796 
797 /*-----------------------------------------------------------------------------------------------*/
827 /*-----------------------------------------------------------------------------------------------*/
828 M2MB_RESULT_E m2mb_crypto_cmac_final( M2MB_CRYPTO_CMAC_CONTEXT ctx,
829  UINT8 *cmac );
830 
831 /*-----------------------------------------------------------------------------------------------*/
857 /*-----------------------------------------------------------------------------------------------*/
858 M2MB_RESULT_E m2mb_crypto_cmac_reset( M2MB_CRYPTO_CMAC_CONTEXT ctx );
859 
860 /*-----------------------------------------------------------------------------------------------*/
884 /*-----------------------------------------------------------------------------------------------*/
885 M2MB_RESULT_E m2mb_crypto_cmac_deinit( M2MB_CRYPTO_CMAC_CONTEXT ctx );
886 
887 /*-----------------------------------------------------------------------------------------------*/
929 /*-----------------------------------------------------------------------------------------------*/
930 UINT8 *m2mb_crypto_cmac( M2MB_CRYPTO_CMAC_ALG_E cmac_alg,
931  const UINT8 *key,
932  const SIZE_T keylen,
933  const UINT8 *input,
934  const SIZE_T inlen,
935  UINT8 *cmac );
936 
937 
947 /* Global declarations ==========================================================================*/
948 
949 
950 
955 typedef enum
956 {
957  M2MB_CRYPTO_AES_MODE_ENCRYPT,
958  M2MB_CRYPTO_AES_MODE_DECRYPT,
959  ENUM_TO_INT( M2MB_CRYPTO_AES_MODE_E )
960 } M2MB_CRYPTO_AES_MODE_E;
961 
963 #define M2MB_CRYPTO_AES_ECB_BLOCK_SIZE 16
964 
966 #define M2MB_CRYPTO_AES_IV_SIZE 16
967 
968 
969 /* Global functions =============================================================================*/
970 
971 /*-----------------------------------------------------------------------------------------------*/
996 /*-----------------------------------------------------------------------------------------------*/
997 M2MB_RESULT_E m2mb_crypto_aes_init( M2MB_CRYPTO_AES_CONTEXT *ctx );
998 
999 /*-----------------------------------------------------------------------------------------------*/
1023 /*-----------------------------------------------------------------------------------------------*/
1024 M2MB_RESULT_E m2mb_crypto_aes_deinit( M2MB_CRYPTO_AES_CONTEXT ctx );
1025 
1026 /*-----------------------------------------------------------------------------------------------*/
1055 /*-----------------------------------------------------------------------------------------------*/
1056 M2MB_RESULT_E m2mb_crypto_aes_generate_key( M2MB_CRYPTO_AES_CONTEXT ctx,
1057  UINT32 keybits );
1058 
1059 /*-----------------------------------------------------------------------------------------------*/
1116 /*-----------------------------------------------------------------------------------------------*/
1117 M2MB_RESULT_E m2mb_crypto_aes_keyblob_export( M2MB_CRYPTO_AES_CONTEXT ctx,
1118  UINT8 *keyblob,
1119  UINT32 *keyblob_length );
1120 
1121 /*-----------------------------------------------------------------------------------------------*/
1156 /*-----------------------------------------------------------------------------------------------*/
1157 M2MB_RESULT_E m2mb_crypto_aes_keyblob_import( M2MB_CRYPTO_AES_CONTEXT ctx,
1158  const UINT8 *keyblob,
1159  UINT32 keyblob_length );
1160 
1161 /*-----------------------------------------------------------------------------------------------*/
1196 /*-----------------------------------------------------------------------------------------------*/
1197 M2MB_RESULT_E m2mb_crypto_aes_externalkey_import ( M2MB_CRYPTO_AES_CONTEXT ctx,
1198  const UINT8 *key,
1199  UINT32 keylength );
1200 
1201 /*-----------------------------------------------------------------------------------------------*/
1235 /*-----------------------------------------------------------------------------------------------*/
1236 M2MB_RESULT_E m2mb_crypto_aes_ecb_encdec( M2MB_CRYPTO_AES_CONTEXT ctx,
1237  M2MB_CRYPTO_AES_MODE_E mode,
1238  const UINT8 in[M2MB_CRYPTO_AES_ECB_BLOCK_SIZE],
1239  UINT8 out[M2MB_CRYPTO_AES_ECB_BLOCK_SIZE] );
1240 
1241 /*-----------------------------------------------------------------------------------------------*/
1284 /*-----------------------------------------------------------------------------------------------*/
1285 M2MB_RESULT_E m2mb_crypto_aes_cbc_encdec( M2MB_CRYPTO_AES_CONTEXT ctx,
1286  M2MB_CRYPTO_AES_MODE_E mode,
1287  const UINT8 *in,
1288  UINT8 *out,
1289  SIZE_T inlen,
1290  UINT8 ivec[M2MB_CRYPTO_AES_IV_SIZE] );
1291 
1301 /* Global declarations ==========================================================================*/
1302 
1303 
1304 
1306 typedef enum
1307 {
1308  M2MB_CRYPTO_ALG_DES,
1309  M2MB_CRYPTO_ALG_3DES,
1310  ENUM_TO_INT( M2MB_CRYPTO_DES_ALG_TYPE_E )
1311 } M2MB_CRYPTO_DES_ALG_TYPE_E;
1312 
1314 typedef enum
1315 {
1316  M2MB_CRYPTO_DES_MODE_ENCRYPT,
1317  M2MB_CRYPTO_DES_MODE_DECRYPT,
1318  ENUM_TO_INT( M2MB_CRYPTO_DES_MODE_E )
1319 } M2MB_CRYPTO_DES_MODE_E;
1320 
1322 #define M2MB_CRYPTO_DES_KEY_SIZE 8
1323 
1325 #define M2MB_CRYPTO_3DES_KEY2_SIZE 16
1326 
1328 #define M2MB_CRYPTO_3DES_KEY3_SIZE 24
1329 
1331 #define M2MB_CRYPTO_DES_BLOCK_BYTE_LEN 8
1332 
1334 #define M2MB_CRYPTO_DES_IV_BYTE_LEN 8
1335 
1336 /* Global functions =============================================================================*/
1337 
1338 /*-----------------------------------------------------------------------------------------------*/
1366 /*-----------------------------------------------------------------------------------------------*/
1367 M2MB_RESULT_E m2mb_crypto_des_init( M2MB_CRYPTO_DES_CONTEXT *ctx,
1368  M2MB_CRYPTO_DES_ALG_TYPE_E des_alg );
1369 
1370 /*-----------------------------------------------------------------------------------------------*/
1394 /*-----------------------------------------------------------------------------------------------*/
1395 M2MB_RESULT_E m2mb_crypto_des_deinit( M2MB_CRYPTO_DES_CONTEXT ctx );
1396 
1397 /*-----------------------------------------------------------------------------------------------*/
1425 /*-----------------------------------------------------------------------------------------------*/
1426 M2MB_RESULT_E m2mb_crypto_des_generate_key( M2MB_CRYPTO_DES_CONTEXT ctx,
1427  UINT32 keybits );
1428 
1429 /*-----------------------------------------------------------------------------------------------*/
1459 /*-----------------------------------------------------------------------------------------------*/
1460 M2MB_RESULT_E m2mb_crypto_des_externalkey_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1461  const UINT8 key[M2MB_CRYPTO_DES_KEY_SIZE] );
1462 
1463 /*-----------------------------------------------------------------------------------------------*/
1493 /*-----------------------------------------------------------------------------------------------*/
1494 M2MB_RESULT_E m2mb_crypto_3des_2externalkey_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1495  const UINT8 key[M2MB_CRYPTO_3DES_KEY2_SIZE] );
1496 
1497 /*-----------------------------------------------------------------------------------------------*/
1527 /*-----------------------------------------------------------------------------------------------*/
1528 M2MB_RESULT_E m2mb_crypto_3des_3externalkey_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1529  const UINT8 key[M2MB_CRYPTO_3DES_KEY3_SIZE] );
1530 
1531 /*-----------------------------------------------------------------------------------------------*/
1565 /*-----------------------------------------------------------------------------------------------*/
1566 M2MB_RESULT_E m2mb_crypto_des_keyblob_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1567  const UINT8 *keyblob,
1568  UINT32 keyblob_length );
1569 
1570 /*-----------------------------------------------------------------------------------------------*/
1604 /*-----------------------------------------------------------------------------------------------*/
1605 M2MB_RESULT_E m2mb_crypto_des_keyblob_export( M2MB_CRYPTO_DES_CONTEXT ctx,
1606  UINT8 *keyblob,
1607  UINT32 *keyblob_length );
1608 
1609 /*-----------------------------------------------------------------------------------------------*/
1643 /*-----------------------------------------------------------------------------------------------*/
1644 M2MB_RESULT_E m2mb_crypto_des_ecb_encdec( M2MB_CRYPTO_DES_CONTEXT ctx,
1645  M2MB_CRYPTO_DES_MODE_E mode,
1646  const UINT8 in[M2MB_CRYPTO_DES_BLOCK_BYTE_LEN],
1647  UINT8 out[M2MB_CRYPTO_DES_BLOCK_BYTE_LEN] );
1648 
1649 /*-----------------------------------------------------------------------------------------------*/
1692 /*-----------------------------------------------------------------------------------------------*/
1693 M2MB_RESULT_E m2mb_crypto_des_cbc_encdec( M2MB_CRYPTO_DES_CONTEXT ctx,
1694  M2MB_CRYPTO_DES_MODE_E mode,
1695  const UINT8 *in,
1696  UINT8 *out,
1697  SIZE_T inlen,
1698  UINT8 ivec[M2MB_CRYPTO_DES_IV_BYTE_LEN] );
1699 
1717 /* Global declarations ==========================================================================*/
1718 
1719 
1720 /* Padding types for encryption. */
1725 typedef enum
1726 {
1728  M2MB_CRYPTO_RSA_PADDING_PKCS1_V15,
1730  M2MB_CRYPTO_RSA_PADDING_PKCS1_OAEP,
1732  M2MB_CRYPTO_RSA_PADDING_PKCS1_PSS,
1734  M2MB_CRYPTO_RSA_PADDING_PKCS1_PSS_AUTORECOVER_SALTLEN,
1736  M2MB_CRYPTO_RSA_PADDING_NONE,
1737 
1738  ENUM_TO_INT( M2MB_CRYPTO_RSA_PADDING_TYPE_E )
1739 } M2MB_CRYPTO_RSA_PADDING_TYPE_E;
1740 
1745 typedef enum
1746 {
1747  M2MB_CRYPTO_RSA_PUBLIC,
1748  M2MB_CRYPTO_RSA_PRIVATE,
1749  ENUM_TO_INT( M2MB_CRYPTO_RSA_MODE_E )
1750 } M2MB_CRYPTO_RSA_MODE_E;
1751 
1752 /* Global functions =============================================================================*/
1753 
1754 /*-----------------------------------------------------------------------------------------------*/
1810 /*-----------------------------------------------------------------------------------------------*/
1811 M2MB_RESULT_E m2mb_crypto_rsa_init( M2MB_CRYPTO_RSA_CONTEXT *ctx,
1812  M2MB_CRYPTO_RSA_PADDING_TYPE_E padding_type,
1813  M2MB_CRYPTO_MD_ALG_E hash_id );
1814 
1815 /*-----------------------------------------------------------------------------------------------*/
1840 /*-----------------------------------------------------------------------------------------------*/
1841 M2MB_RESULT_E m2mb_crypto_rsa_deinit( M2MB_CRYPTO_RSA_CONTEXT ctx );
1842 
1843 /*-----------------------------------------------------------------------------------------------*/
1932 /*-----------------------------------------------------------------------------------------------*/
1933 M2MB_RESULT_E m2mb_crypto_rsa_public( M2MB_CRYPTO_RSA_CONTEXT ctx,
1934  const UINT8 *in,
1935  UINT8 *out );
1936 
1937 /*-----------------------------------------------------------------------------------------------*/
1978 /*-----------------------------------------------------------------------------------------------*/
1979 M2MB_RESULT_E m2mb_crypto_rsa_private( M2MB_CRYPTO_RSA_CONTEXT ctx,
1980  const UINT8 *in,
1981  UINT8 *out );
1982 
1983 /*-----------------------------------------------------------------------------------------------*/
2017 /*-----------------------------------------------------------------------------------------------*/
2018 M2MB_RESULT_E m2mb_crypto_rsa_generate_key( M2MB_CRYPTO_RSA_CONTEXT ctx,
2019  UINT32 key_size,
2020  UINT32 public_exponent );
2021 
2022 /*-----------------------------------------------------------------------------------------------*/
2132 /*-----------------------------------------------------------------------------------------------*/
2133 M2MB_RESULT_E m2mb_crypto_rsa_keyblob_export( M2MB_CRYPTO_RSA_CONTEXT ctx,
2134  UINT8 *keyblob,
2135  UINT32 *keyblob_length );
2136 
2137 /*-----------------------------------------------------------------------------------------------*/
2171 /*-----------------------------------------------------------------------------------------------*/
2172 M2MB_RESULT_E m2mb_crypto_rsa_keyblob_import( M2MB_CRYPTO_RSA_CONTEXT ctx,
2173  const UINT8 *keyblob,
2174  UINT32 keyblob_length );
2175 
2176 /*-----------------------------------------------------------------------------------------------*/
2292 /*-----------------------------------------------------------------------------------------------*/
2293 M2MB_RESULT_E m2mb_crypto_rsa_public_key_export( M2MB_CRYPTO_RSA_CONTEXT ctx,
2294  UINT8 *modulus,
2295  UINT32 *modulus_size,
2296  UINT8 *public_exponent,
2297  UINT32 *public_exponent_size );
2298 
2299 /*-----------------------------------------------------------------------------------------------*/
2337 /*-----------------------------------------------------------------------------------------------*/
2338 M2MB_RESULT_E m2mb_crypto_rsa_public_key_import( M2MB_CRYPTO_RSA_CONTEXT ctx,
2339  const UINT8 *modulus,
2340  UINT32 modulus_size,
2341  const UINT8 *public_exponent,
2342  UINT32 public_exponent_size );
2343 
2344 /*-----------------------------------------------------------------------------------------------*/
2474 /*-----------------------------------------------------------------------------------------------*/
2475 M2MB_RESULT_E m2mb_crypto_rsa_externalkey_import( M2MB_CRYPTO_RSA_CONTEXT ctx,
2476  const UINT8 *modulus,
2477  UINT32 modulus_size,
2478  const UINT8 *p_factor,
2479  UINT32 p_factor_size,
2480  const UINT8 *q_factor,
2481  UINT32 q_factor_size,
2482  const UINT8 *public_exponent,
2483  UINT32 public_exponent_size,
2484  const UINT8 *private_exponent,
2485  UINT32 private_exponent_size,
2486  M2MB_CRYPTO_RSA_PADDING_TYPE_E padding_type );
2487 
2488 /*-----------------------------------------------------------------------------------------------*/
2550 
2552 
2588 /*-----------------------------------------------------------------------------------------------*/
2589 M2MB_RESULT_E m2mb_crypto_rsa_encrypt( M2MB_CRYPTO_RSA_CONTEXT ctx,
2590  M2MB_CRYPTO_RSA_MODE_E mode,
2591  SIZE_T inlen,
2592  const UINT8 *in,
2593  UINT8 *out );
2594 
2595 
2596 /*-----------------------------------------------------------------------------------------------*/
2644 /*-----------------------------------------------------------------------------------------------*/
2645 M2MB_RESULT_E m2mb_crypto_rsa_decrypt( M2MB_CRYPTO_RSA_CONTEXT ctx,
2646  M2MB_CRYPTO_RSA_MODE_E mode,
2647  SIZE_T *outlen,
2648  UINT8 *out,
2649  SIZE_T out_max_len,
2650  const UINT8 *in );
2651 
2652 /*-----------------------------------------------------------------------------------------------*/
2705 /*-----------------------------------------------------------------------------------------------*/
2706 M2MB_RESULT_E m2mb_crypto_rsa_sign( M2MB_CRYPTO_RSA_CONTEXT ctx,
2707  M2MB_CRYPTO_RSA_MODE_E mode,
2708  M2MB_CRYPTO_MD_ALG_E md_alg,
2709  UINT32 hashlen,
2710  const UINT8 *hash,
2711  UINT8 *sig );
2712 
2713 /*-----------------------------------------------------------------------------------------------*/
2787 
2802 
2816 /*-----------------------------------------------------------------------------------------------*/
2817 M2MB_RESULT_E m2mb_crypto_rsa_verify( M2MB_CRYPTO_RSA_CONTEXT ctx,
2818  UINT8 *pubkey,
2819  UINT32 pubkey_length,
2820  M2MB_CRYPTO_MD_ALG_E md_alg,
2821  UINT32 hashlen,
2822  const UINT8 *hash,
2823  const UINT8 *sig );
2824 
2834 /* Global declarations ==========================================================================*/
2835 
2836 
2837 
2845 typedef enum
2846 {
2847  M2MB_CRYPTO_ECC_DP_BP256R1,
2848  M2MB_CRYPTO_ECC_DP_SECP256R1,
2849  M2MB_CRYPTO_ECC_DP_CUSTOM,
2851  ENUM_TO_INT( M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E )
2852 } M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E;
2853 
2858 //#define M2MB_CRYPTO_ECC_BIGLEN 9
2859 #define M2MB_CRYPTO_ECC_BIGLEN 18
2860 
2865 #define M2MB_MAX_ECC_KEY_SIZE 32
2866 
2874 typedef struct
2875 {
2876  UINT8 x[M2MB_MAX_ECC_KEY_SIZE+1];
2877  UINT8 y[M2MB_MAX_ECC_KEY_SIZE+1];
2878  INT32 flags;
2879  INT32 key_size_bytes;
2880 } M2MB_CRYPTO_ECC_AFFINE_POINT_T;
2881 
2886 typedef enum
2887 {
2888  M2MB_CRYPTO_ECC_DP_P,
2889  M2MB_CRYPTO_ECC_DP_A,
2890  M2MB_CRYPTO_ECC_DP_B,
2891  M2MB_CRYPTO_ECC_DP_G_X,
2892  M2MB_CRYPTO_ECC_DP_G_Y,
2893  M2MB_CRYPTO_ECC_DP_N,
2894  M2MB_CRYPTO_ECC_DP_H,
2895  ENUM_TO_INT( M2MB_CRYPTO_ECC_DP_E )
2896 } M2MB_CRYPTO_ECC_DP_E;
2897 
2898 /* Global functions =============================================================================*/
2899 
2900 /*-----------------------------------------------------------------------------------------------*/
2928 /*-----------------------------------------------------------------------------------------------*/
2929 
2930 M2MB_RESULT_E m2mb_crypto_ecc_init( M2MB_CRYPTO_ECC_CONTEXT *ctx,
2931  M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E curve_domain_params );
2932 
2933 /*-----------------------------------------------------------------------------------------------*/
2979 /*-----------------------------------------------------------------------------------------------*/
2980 
2981 M2MB_RESULT_E m2mb_crypto_ecc_dp_init( M2MB_CRYPTO_ECC_CONTEXT ctx,
2982  UINT8 *p,
2983  UINT8 *a,
2984  UINT8 *b,
2985  UINT8 *g_x,
2986  UINT8 *g_y,
2987  UINT8 *n,
2988  UINT32 *h );
2989 
2990 /*-----------------------------------------------------------------------------------------------*/
3043 /*-----------------------------------------------------------------------------------------------*/
3044 M2MB_RESULT_E m2mb_crypto_ecc_dp_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
3045  M2MB_CRYPTO_ECC_DP_E domain,
3046  UINT32 len,
3047  const UINT8 *param);
3048 
3049 /*-----------------------------------------------------------------------------------------------*/
3089 /*-----------------------------------------------------------------------------------------------*/
3090 M2MB_RESULT_E m2mb_crypto_ecdsa_sign( M2MB_CRYPTO_ECC_CONTEXT ctx,
3091  UINT8 *msg,
3092  UINT32 msg_len,
3093  UINT8 *sig,
3094  SIZE_T sig_len );
3095 
3096 
3097 /*-----------------------------------------------------------------------------------------------*/
3140 /*-----------------------------------------------------------------------------------------------*/
3141 M2MB_RESULT_E m2mb_crypto_ecdsa_verify( M2MB_CRYPTO_ECC_CONTEXT ctx,
3142  UINT8 *msg,
3143  UINT32 msg_len,
3144  M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey,
3145  UINT8 *sig,
3146  SIZE_T sig_len );
3147 
3148 /*-----------------------------------------------------------------------------------------------*/
3189 /*-----------------------------------------------------------------------------------------------*/
3190 M2MB_RESULT_E m2mb_crypto_ecdh_shared_key_derive( M2MB_CRYPTO_ECC_CONTEXT ctx,
3191  UINT8 *shared_keyblob,
3192  UINT16 *shared_keyblob_len,
3193  const M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey );
3194 
3195 /*-----------------------------------------------------------------------------------------------*/
3223 /*-----------------------------------------------------------------------------------------------*/
3224 M2MB_RESULT_E m2mb_crypto_ecc_keypair_generate( M2MB_CRYPTO_ECC_CONTEXT ctx );
3225 
3226 /*-----------------------------------------------------------------------------------------------*/
3260 /*-----------------------------------------------------------------------------------------------*/
3261 M2MB_RESULT_E m2mb_crypto_ecc_keyblob_export( M2MB_CRYPTO_ECC_CONTEXT ctx,
3262  UINT8 *keyblob,
3263  UINT16 *keyblob_length );
3264 
3265 /*-----------------------------------------------------------------------------------------------*/
3299 /*-----------------------------------------------------------------------------------------------*/
3300 M2MB_RESULT_E m2mb_crypto_ecc_keyblob_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
3301  const UINT8 *keyblob,
3302  UINT32 keyblob_length );
3303 
3304 
3305 /*-----------------------------------------------------------------------------------------------*/
3335 /*-----------------------------------------------------------------------------------------------*/
3336 M2MB_RESULT_E m2mb_crypto_ecc_public_key_export( M2MB_CRYPTO_ECC_CONTEXT ctx,
3337  M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey );
3338 
3339 /*-----------------------------------------------------------------------------------------------*/
3369 /*-----------------------------------------------------------------------------------------------*/
3370 M2MB_RESULT_E m2mb_crypto_ecc_public_key_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
3371  const M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey );
3372 
3373 
3374 #ifdef TZ_DEBUG
3375 /*-----------------------------------------------------------------------------------------------*/
3409 /*-----------------------------------------------------------------------------------------------*/
3410 M2MB_RESULT_E m2mb_crypto_ecc_private_key_export( M2MB_CRYPTO_ECC_CONTEXT ctx,
3411  UINT8 *private_key,
3412  UINT16 *private_key_len);
3413 
3414 #endif
3415 
3416 /*-----------------------------------------------------------------------------------------------*/
3448 /*-----------------------------------------------------------------------------------------------*/
3449 M2MB_RESULT_E m2mb_crypto_ecc_private_key_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
3450  const UINT8 *privkey,
3451  UINT16 privkey_len );
3452 
3453 /*-----------------------------------------------------------------------------------------------*/
3477 /*-----------------------------------------------------------------------------------------------*/
3478 M2MB_RESULT_E m2mb_crypto_ecc_deinit( M2MB_CRYPTO_ECC_CONTEXT ctx );
3479 
3490 /* Global declarations ==========================================================================*/
3491 
3493 #define M2MB_CRYPTO_PRNG_MAX_BYTES 512
3494 
3495 /* Global functions =============================================================================*/
3496 
3497 /*-----------------------------------------------------------------------------------------------*/
3522 /*-----------------------------------------------------------------------------------------------*/
3523 UINT32 m2mb_crypto_prng_get_data( UINT8 *prng_data,
3524  UINT32 prng_data_len );
3528 #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:1732
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:1730
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:105
M2MB_CRYPTO_AES_IV_SIZE
#define M2MB_CRYPTO_AES_IV_SIZE
Definition: m2mb_crypto.h:966
M2MB_CRYPTO_ECC_DP_SECP256R1
Definition: m2mb_crypto.h:2848
M2MB_CRYPTO_DES_KEY_SIZE
#define M2MB_CRYPTO_DES_KEY_SIZE
Definition: m2mb_crypto.h:1322
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:1314
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:955
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:2845
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:1736
M2MB_CRYPTO_DES_CONTEXT
struct M2MB_CRYPTO_DES_CONTEXT_TAG * M2MB_CRYPTO_DES_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:111
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:2847
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:1745
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:87
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:1331
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:117
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:2874
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:2865
M2MB_CRYPTO_DES_ALG_TYPE_E
M2MB_CRYPTO_DES_ALG_TYPE_E
Definition: m2mb_crypto.h:1306
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:123
M2MB_CRYPTO_ECC_DP_E
M2MB_CRYPTO_ECC_DP_E
Enumeration representing all the ECC Domain Parameters.
Definition: m2mb_crypto.h:2886
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:129
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:56
M2MB_CRYPTO_DES_IV_BYTE_LEN
#define M2MB_CRYPTO_DES_IV_BYTE_LEN
Definition: m2mb_crypto.h:1334
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:1325
M2MB_CRYPTO_CMAC_CONTEXT
struct M2MB_CRYPTO_CMAC_CONTEXT_TAG * M2MB_CRYPTO_CMAC_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:99
M2MB_CRYPTO_HMAC_CONTEXT
struct M2MB_CRYPTO_HMAC_CONTEXT_TAG * M2MB_CRYPTO_HMAC_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:93
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:1725
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:2849
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:1728
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:80
M2MB_CRYPTO_3DES_KEY3_SIZE
#define M2MB_CRYPTO_3DES_KEY3_SIZE
Definition: m2mb_crypto.h:1328
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:1734
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:963
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.