m2mb API docs  30.00.007
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 /*-----------------------------------------------------------------------------------------------*/
214 /*-----------------------------------------------------------------------------------------------*/
215 M2MB_CRYPTO_GEN_CONTEXT m2mb_crypto_retrieve_ctx( UINT8 *info );
216 
217 /*-----------------------------------------------------------------------------------------------*/
241 /*-----------------------------------------------------------------------------------------------*/
242 M2MB_RESULT_E m2mb_crypto_md_init( M2MB_CRYPTO_MD_CONTEXT *ctx );
243 
269 /*-----------------------------------------------------------------------------------------------*/
270 M2MB_RESULT_E m2mb_crypto_md_setup( M2MB_CRYPTO_MD_CONTEXT ctx,
271  const M2MB_CRYPTO_MD_ALG_E md_info );
272 
273 /*-----------------------------------------------------------------------------------------------*/
304 /*-----------------------------------------------------------------------------------------------*/
305 M2MB_RESULT_E m2mb_crypto_md_update( M2MB_CRYPTO_MD_CONTEXT ctx,
306  const UINT8 *data,
307  SIZE_T len );
308 
309 /*-----------------------------------------------------------------------------------------------*/
337 /*-----------------------------------------------------------------------------------------------*/
338 M2MB_RESULT_E m2mb_crypto_md_final( M2MB_CRYPTO_MD_CONTEXT ctx,
339  UINT8 *md );
340 
341 /*-----------------------------------------------------------------------------------------------*/
365 /*-----------------------------------------------------------------------------------------------*/
366 M2MB_RESULT_E m2mb_crypto_md_deinit( M2MB_CRYPTO_MD_CONTEXT ctx );
367 
368 /*-----------------------------------------------------------------------------------------------*/
409 /*-----------------------------------------------------------------------------------------------*/
410 UINT8 *m2mb_crypto_md( const M2MB_CRYPTO_MD_ALG_E md_info,
411  const UINT8 *data,
412  SIZE_T len,
413  UINT8 *md );
414 
415 
416 /* Global declarations ==========================================================================*/
417 
424 /* Global functions =============================================================================*/
425 
426 /*-----------------------------------------------------------------------------------------------*/
450 /*-----------------------------------------------------------------------------------------------*/
451 M2MB_RESULT_E m2mb_crypto_hmac_init( M2MB_CRYPTO_HMAC_CONTEXT *ctx );
452 
486 /*-----------------------------------------------------------------------------------------------*/
487 M2MB_RESULT_E m2mb_crypto_hmac_setup( M2MB_CRYPTO_HMAC_CONTEXT ctx,
488  M2MB_CRYPTO_MD_ALG_E md_info,
489  const UINT8 *key,
490  SIZE_T keylen );
491 
492 /*-----------------------------------------------------------------------------------------------*/
524 /*-----------------------------------------------------------------------------------------------*/
525 M2MB_RESULT_E m2mb_crypto_hmac_update( M2MB_CRYPTO_HMAC_CONTEXT ctx,
526  const UINT8 *data,
527  SIZE_T len );
528 
529 /*-----------------------------------------------------------------------------------------------*/
558 /*-----------------------------------------------------------------------------------------------*/
559 M2MB_RESULT_E m2mb_crypto_hmac_final( M2MB_CRYPTO_HMAC_CONTEXT ctx,
560  UINT8 *hmac );
561 
562 /*-----------------------------------------------------------------------------------------------*/
587 /*-----------------------------------------------------------------------------------------------*/
588 M2MB_RESULT_E m2mb_crypto_hmac_reset( M2MB_CRYPTO_HMAC_CONTEXT ctx );
589 
590 /*-----------------------------------------------------------------------------------------------*/
613 /*-----------------------------------------------------------------------------------------------*/
614 M2MB_RESULT_E m2mb_crypto_hmac_deinit( M2MB_CRYPTO_HMAC_CONTEXT ctx );
615 
616 /*-----------------------------------------------------------------------------------------------*/
661 /*-----------------------------------------------------------------------------------------------*/
662 UINT8 *m2mb_crypto_hmac( M2MB_CRYPTO_MD_ALG_E md_info,
663  const UINT8 *key,
664  const SIZE_T keylen,
665  const UINT8 *input,
666  const SIZE_T inlen,
667  UINT8 *hmac );
668 
678 /* Global declarations ==========================================================================*/
679 
680 
681 typedef enum
682 {
683  M2MB_CRYPTO_CMAC_ALG_AES_128 = 1,
684  M2MB_CRYPTO_CMAC_ALG_AES_192 = 2,
685  M2MB_CRYPTO_CMAC_ALG_AES_256 = 3,
686  ENUM_TO_INT( M2MB_CRYPTO_CMAC_ALG_E )
687 } M2MB_CRYPTO_CMAC_ALG_E;
688 
689 /* Global functions =============================================================================*/
690 
691 /*-----------------------------------------------------------------------------------------------*/
715 /*-----------------------------------------------------------------------------------------------*/
716 M2MB_RESULT_E m2mb_crypto_cmac_init( M2MB_CRYPTO_CMAC_CONTEXT *ctx );
717 
749 /*-----------------------------------------------------------------------------------------------*/
750 M2MB_RESULT_E m2mb_crypto_cmac_setup( M2MB_CRYPTO_CMAC_CONTEXT ctx,
751  const UINT8 *key,
752  SIZE_T keylen );
753 
754 /*-----------------------------------------------------------------------------------------------*/
786 /*-----------------------------------------------------------------------------------------------*/
787 M2MB_RESULT_E m2mb_crypto_cmac_update( M2MB_CRYPTO_CMAC_CONTEXT ctx,
788  const UINT8 *data,
789  SIZE_T len );
790 
791 /*-----------------------------------------------------------------------------------------------*/
820 /*-----------------------------------------------------------------------------------------------*/
821 M2MB_RESULT_E m2mb_crypto_cmac_final( M2MB_CRYPTO_CMAC_CONTEXT ctx,
822  UINT8 *cmac );
823 
824 /*-----------------------------------------------------------------------------------------------*/
849 /*-----------------------------------------------------------------------------------------------*/
850 M2MB_RESULT_E m2mb_crypto_cmac_reset( M2MB_CRYPTO_CMAC_CONTEXT ctx );
851 
852 /*-----------------------------------------------------------------------------------------------*/
875 /*-----------------------------------------------------------------------------------------------*/
876 M2MB_RESULT_E m2mb_crypto_cmac_deinit( M2MB_CRYPTO_CMAC_CONTEXT ctx );
877 
878 /*-----------------------------------------------------------------------------------------------*/
920 /*-----------------------------------------------------------------------------------------------*/
921 UINT8 *m2mb_crypto_cmac( M2MB_CRYPTO_CMAC_ALG_E cmac_alg,
922  const UINT8 *key,
923  const SIZE_T keylen,
924  const UINT8 *input,
925  const SIZE_T inlen,
926  UINT8 *cmac );
927 
928 
938 /* Global declarations ==========================================================================*/
939 
940 
941 
946 typedef enum
947 {
948  M2MB_CRYPTO_AES_MODE_ENCRYPT,
949  M2MB_CRYPTO_AES_MODE_DECRYPT,
950  ENUM_TO_INT( M2MB_CRYPTO_AES_MODE_E )
951 } M2MB_CRYPTO_AES_MODE_E;
952 
954 #define M2MB_CRYPTO_AES_ECB_BLOCK_SIZE 16
955 
957 #define M2MB_CRYPTO_AES_IV_SIZE 16
958 
959 
960 /* Global functions =============================================================================*/
961 
962 /*-----------------------------------------------------------------------------------------------*/
985 /*-----------------------------------------------------------------------------------------------*/
986 M2MB_RESULT_E m2mb_crypto_aes_init( M2MB_CRYPTO_AES_CONTEXT *ctx );
987 
988 /*-----------------------------------------------------------------------------------------------*/
1010 /*-----------------------------------------------------------------------------------------------*/
1011 M2MB_RESULT_E m2mb_crypto_aes_deinit( M2MB_CRYPTO_AES_CONTEXT ctx );
1012 
1013 /*-----------------------------------------------------------------------------------------------*/
1040 /*-----------------------------------------------------------------------------------------------*/
1041 M2MB_RESULT_E m2mb_crypto_aes_generate_key( M2MB_CRYPTO_AES_CONTEXT ctx,
1042  UINT32 keybits );
1043 
1044 /*-----------------------------------------------------------------------------------------------*/
1099 /*-----------------------------------------------------------------------------------------------*/
1100 M2MB_RESULT_E m2mb_crypto_aes_keyblob_export( M2MB_CRYPTO_AES_CONTEXT ctx,
1101  UINT8 *keyblob,
1102  UINT32 *keyblob_length );
1103 
1104 /*-----------------------------------------------------------------------------------------------*/
1137 /*-----------------------------------------------------------------------------------------------*/
1138 M2MB_RESULT_E m2mb_crypto_aes_keyblob_import( M2MB_CRYPTO_AES_CONTEXT ctx,
1139  const UINT8 *keyblob,
1140  UINT32 keyblob_length );
1141 
1142 /*-----------------------------------------------------------------------------------------------*/
1175 /*-----------------------------------------------------------------------------------------------*/
1176 M2MB_RESULT_E m2mb_crypto_aes_externalkey_import ( M2MB_CRYPTO_AES_CONTEXT ctx,
1177  const UINT8 *key,
1178  UINT32 keylength );
1179 
1180 /*-----------------------------------------------------------------------------------------------*/
1212 /*-----------------------------------------------------------------------------------------------*/
1213 M2MB_RESULT_E m2mb_crypto_aes_ecb_encdec( M2MB_CRYPTO_AES_CONTEXT ctx,
1214  M2MB_CRYPTO_AES_MODE_E mode,
1215  const UINT8 in[M2MB_CRYPTO_AES_ECB_BLOCK_SIZE],
1216  UINT8 out[M2MB_CRYPTO_AES_ECB_BLOCK_SIZE] );
1217 
1218 /*-----------------------------------------------------------------------------------------------*/
1259 /*-----------------------------------------------------------------------------------------------*/
1260 M2MB_RESULT_E m2mb_crypto_aes_cbc_encdec( M2MB_CRYPTO_AES_CONTEXT ctx,
1261  M2MB_CRYPTO_AES_MODE_E mode,
1262  const UINT8 *in,
1263  UINT8 *out,
1264  SIZE_T inlen,
1265  UINT8 ivec[M2MB_CRYPTO_AES_IV_SIZE] );
1266 
1276 /* Global declarations ==========================================================================*/
1277 
1278 
1279 
1281 typedef enum
1282 {
1283  M2MB_CRYPTO_ALG_DES,
1284  M2MB_CRYPTO_ALG_3DES,
1285  ENUM_TO_INT( M2MB_CRYPTO_DES_ALG_TYPE_E )
1286 } M2MB_CRYPTO_DES_ALG_TYPE_E;
1287 
1289 typedef enum
1290 {
1291  M2MB_CRYPTO_DES_MODE_ENCRYPT,
1292  M2MB_CRYPTO_DES_MODE_DECRYPT,
1293  ENUM_TO_INT( M2MB_CRYPTO_DES_MODE_E )
1294 } M2MB_CRYPTO_DES_MODE_E;
1295 
1297 #define M2MB_CRYPTO_DES_KEY_SIZE 8
1298 
1300 #define M2MB_CRYPTO_3DES_KEY2_SIZE 16
1301 
1303 #define M2MB_CRYPTO_3DES_KEY3_SIZE 24
1304 
1306 #define M2MB_CRYPTO_DES_BLOCK_BYTE_LEN 8
1307 
1309 #define M2MB_CRYPTO_DES_IV_BYTE_LEN 8
1310 
1311 /* Global functions =============================================================================*/
1312 
1313 /*-----------------------------------------------------------------------------------------------*/
1340 /*-----------------------------------------------------------------------------------------------*/
1341 M2MB_RESULT_E m2mb_crypto_des_init( M2MB_CRYPTO_DES_CONTEXT *ctx,
1342  M2MB_CRYPTO_DES_ALG_TYPE_E des_alg );
1343 
1344 /*-----------------------------------------------------------------------------------------------*/
1367 /*-----------------------------------------------------------------------------------------------*/
1368 M2MB_RESULT_E m2mb_crypto_des_deinit( M2MB_CRYPTO_DES_CONTEXT ctx );
1369 
1370 /*-----------------------------------------------------------------------------------------------*/
1397 /*-----------------------------------------------------------------------------------------------*/
1398 M2MB_RESULT_E m2mb_crypto_des_generate_key( M2MB_CRYPTO_DES_CONTEXT ctx,
1399  UINT32 keybits );
1400 
1401 /*-----------------------------------------------------------------------------------------------*/
1429 /*-----------------------------------------------------------------------------------------------*/
1430 M2MB_RESULT_E m2mb_crypto_des_externalkey_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1431  const UINT8 key[M2MB_CRYPTO_DES_KEY_SIZE] );
1432 
1433 /*-----------------------------------------------------------------------------------------------*/
1461 /*-----------------------------------------------------------------------------------------------*/
1462 M2MB_RESULT_E m2mb_crypto_3des_2externalkey_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1463  const UINT8 key[M2MB_CRYPTO_3DES_KEY2_SIZE] );
1464 
1465 /*-----------------------------------------------------------------------------------------------*/
1493 /*-----------------------------------------------------------------------------------------------*/
1494 M2MB_RESULT_E m2mb_crypto_3des_3externalkey_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1495  const UINT8 key[M2MB_CRYPTO_3DES_KEY3_SIZE] );
1496 
1497 /*-----------------------------------------------------------------------------------------------*/
1529 /*-----------------------------------------------------------------------------------------------*/
1530 M2MB_RESULT_E m2mb_crypto_des_keyblob_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1531  const UINT8 *keyblob,
1532  UINT32 keyblob_length );
1533 
1534 /*-----------------------------------------------------------------------------------------------*/
1566 /*-----------------------------------------------------------------------------------------------*/
1567 M2MB_RESULT_E m2mb_crypto_des_keyblob_export( M2MB_CRYPTO_DES_CONTEXT ctx,
1568  UINT8 *keyblob,
1569  UINT32 *keyblob_length );
1570 
1571 /*-----------------------------------------------------------------------------------------------*/
1603 /*-----------------------------------------------------------------------------------------------*/
1604 M2MB_RESULT_E m2mb_crypto_des_ecb_encdec( M2MB_CRYPTO_DES_CONTEXT ctx,
1605  M2MB_CRYPTO_DES_MODE_E mode,
1606  const UINT8 in[M2MB_CRYPTO_DES_BLOCK_BYTE_LEN],
1607  UINT8 out[M2MB_CRYPTO_DES_BLOCK_BYTE_LEN] );
1608 
1609 /*-----------------------------------------------------------------------------------------------*/
1650 /*-----------------------------------------------------------------------------------------------*/
1651 M2MB_RESULT_E m2mb_crypto_des_cbc_encdec( M2MB_CRYPTO_DES_CONTEXT ctx,
1652  M2MB_CRYPTO_DES_MODE_E mode,
1653  const UINT8 *in,
1654  UINT8 *out,
1655  SIZE_T inlen,
1656  UINT8 ivec[M2MB_CRYPTO_DES_IV_BYTE_LEN] );
1657 
1675 /* Global declarations ==========================================================================*/
1676 
1677 
1678 /* Padding types for encryption. */
1683 typedef enum
1684 {
1686  M2MB_CRYPTO_RSA_PADDING_PKCS1_V15,
1688  M2MB_CRYPTO_RSA_PADDING_PKCS1_OAEP,
1690  M2MB_CRYPTO_RSA_PADDING_PKCS1_PSS,
1692  M2MB_CRYPTO_RSA_PADDING_PKCS1_PSS_AUTORECOVER_SALTLEN,
1694  M2MB_CRYPTO_RSA_PADDING_NONE,
1695 
1696  ENUM_TO_INT( M2MB_CRYPTO_RSA_PADDING_TYPE_E )
1697 } M2MB_CRYPTO_RSA_PADDING_TYPE_E;
1698 
1703 typedef enum
1704 {
1705  M2MB_CRYPTO_RSA_PUBLIC,
1706  M2MB_CRYPTO_RSA_PRIVATE,
1707  ENUM_TO_INT( M2MB_CRYPTO_RSA_MODE_E )
1708 } M2MB_CRYPTO_RSA_MODE_E;
1709 
1710 /* Global functions =============================================================================*/
1711 
1712 /*-----------------------------------------------------------------------------------------------*/
1743 /*-----------------------------------------------------------------------------------------------*/
1744 M2MB_RESULT_E m2mb_crypto_rsa_init( M2MB_CRYPTO_RSA_CONTEXT *ctx,
1745  M2MB_CRYPTO_RSA_PADDING_TYPE_E padding_type,
1746  M2MB_CRYPTO_MD_ALG_E hash_id );
1747 
1748 /*-----------------------------------------------------------------------------------------------*/
1771 /*-----------------------------------------------------------------------------------------------*/
1772 M2MB_RESULT_E m2mb_crypto_rsa_deinit( M2MB_CRYPTO_RSA_CONTEXT ctx );
1773 
1774 /*-----------------------------------------------------------------------------------------------*/
1807 /*-----------------------------------------------------------------------------------------------*/
1808 M2MB_RESULT_E m2mb_crypto_rsa_public( M2MB_CRYPTO_RSA_CONTEXT ctx,
1809  const UINT8 *in,
1810  UINT8 *out );
1811 
1812 /*-----------------------------------------------------------------------------------------------*/
1843 /*-----------------------------------------------------------------------------------------------*/
1844 M2MB_RESULT_E m2mb_crypto_rsa_private( M2MB_CRYPTO_RSA_CONTEXT ctx,
1845  const UINT8 *in,
1846  UINT8 *out );
1847 
1848 /*-----------------------------------------------------------------------------------------------*/
1878 /*-----------------------------------------------------------------------------------------------*/
1879 M2MB_RESULT_E m2mb_crypto_rsa_generate_key( M2MB_CRYPTO_RSA_CONTEXT ctx,
1880  UINT32 key_size,
1881  UINT32 public_exponent );
1882 
1883 /*-----------------------------------------------------------------------------------------------*/
1915 /*-----------------------------------------------------------------------------------------------*/
1916 M2MB_RESULT_E m2mb_crypto_rsa_keyblob_export( M2MB_CRYPTO_RSA_CONTEXT ctx,
1917  UINT8 *keyblob,
1918  UINT32 *keyblob_length );
1919 
1920 /*-----------------------------------------------------------------------------------------------*/
1952 /*-----------------------------------------------------------------------------------------------*/
1953 M2MB_RESULT_E m2mb_crypto_rsa_keyblob_import( M2MB_CRYPTO_RSA_CONTEXT ctx,
1954  const UINT8 *keyblob,
1955  UINT32 keyblob_length );
1956 
1957 /*-----------------------------------------------------------------------------------------------*/
1995 /*-----------------------------------------------------------------------------------------------*/
1996 M2MB_RESULT_E m2mb_crypto_rsa_public_key_export( M2MB_CRYPTO_RSA_CONTEXT ctx,
1997  UINT8 *modulus,
1998  UINT32 *modulus_size,
1999  UINT8 *public_exponent,
2000  UINT32 *public_exponent_size );
2001 
2002 /*-----------------------------------------------------------------------------------------------*/
2040 /*-----------------------------------------------------------------------------------------------*/
2041 M2MB_RESULT_E m2mb_crypto_rsa_public_key_import( M2MB_CRYPTO_RSA_CONTEXT ctx,
2042  const UINT8 *modulus,
2043  UINT32 modulus_size,
2044  const UINT8 *public_exponent,
2045  UINT32 public_exponent_size );
2046 
2047 /*-----------------------------------------------------------------------------------------------*/
2106 /*-----------------------------------------------------------------------------------------------*/
2107 M2MB_RESULT_E m2mb_crypto_rsa_externalkey_import( M2MB_CRYPTO_RSA_CONTEXT ctx,
2108  const UINT8 *modulus,
2109  UINT32 modulus_size,
2110  const UINT8 *p_factor,
2111  UINT32 p_factor_size,
2112  const UINT8 *q_factor,
2113  UINT32 q_factor_size,
2114  const UINT8 *public_exponent,
2115  UINT32 public_exponent_size,
2116  const UINT8 *private_exponent,
2117  UINT32 private_exponent_size,
2118  M2MB_CRYPTO_RSA_PADDING_TYPE_E padding_type );
2119 
2120 /*-----------------------------------------------------------------------------------------------*/
2156 /*-----------------------------------------------------------------------------------------------*/
2157 M2MB_RESULT_E m2mb_crypto_rsa_encrypt( M2MB_CRYPTO_RSA_CONTEXT ctx,
2158  M2MB_CRYPTO_RSA_MODE_E mode,
2159  SIZE_T inlen,
2160  const UINT8 *in,
2161  UINT8 *out );
2162 
2163 
2164 /*-----------------------------------------------------------------------------------------------*/
2205 /*-----------------------------------------------------------------------------------------------*/
2206 M2MB_RESULT_E m2mb_crypto_rsa_decrypt( M2MB_CRYPTO_RSA_CONTEXT ctx,
2207  M2MB_CRYPTO_RSA_MODE_E mode,
2208  SIZE_T *outlen,
2209  UINT8 *out,
2210  SIZE_T out_max_len,
2211  const UINT8 *in );
2212 
2213 /*-----------------------------------------------------------------------------------------------*/
2254 /*-----------------------------------------------------------------------------------------------*/
2255 M2MB_RESULT_E m2mb_crypto_rsa_sign( M2MB_CRYPTO_RSA_CONTEXT ctx,
2256  M2MB_CRYPTO_RSA_MODE_E mode,
2257  M2MB_CRYPTO_MD_ALG_E md_alg,
2258  UINT32 hashlen,
2259  const UINT8 *hash,
2260  UINT8 *sig );
2261 
2262 /*-----------------------------------------------------------------------------------------------*/
2306 /*-----------------------------------------------------------------------------------------------*/
2307 M2MB_RESULT_E m2mb_crypto_rsa_verify( M2MB_CRYPTO_RSA_CONTEXT ctx,
2308  UINT8 *pubkey,
2309  UINT32 pubkey_length,
2310  M2MB_CRYPTO_MD_ALG_E md_alg,
2311  UINT32 hashlen,
2312  const UINT8 *hash,
2313  const UINT8 *sig );
2314 
2324 /* Global declarations ==========================================================================*/
2325 
2326 
2327 
2335 typedef enum
2336 {
2337  M2MB_CRYPTO_ECC_DP_BP256R1,
2338  M2MB_CRYPTO_ECC_DP_SECP256R1,
2339  M2MB_CRYPTO_ECC_DP_CUSTOM,
2341  ENUM_TO_INT( M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E )
2342 } M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E;
2343 
2348 //#define M2MB_CRYPTO_ECC_BIGLEN 9
2349 #define M2MB_CRYPTO_ECC_BIGLEN 18
2350 
2355 #define M2MB_MAX_ECC_KEY_SIZE 32
2356 
2364 typedef struct
2365 {
2366  UINT8 x[M2MB_MAX_ECC_KEY_SIZE+1];
2367  UINT8 y[M2MB_MAX_ECC_KEY_SIZE+1];
2368  INT32 flags;
2369  INT32 key_size_bytes;
2370 } M2MB_CRYPTO_ECC_AFFINE_POINT_T;
2371 
2376 typedef enum
2377 {
2378  M2MB_CRYPTO_ECC_DP_P,
2379  M2MB_CRYPTO_ECC_DP_A,
2380  M2MB_CRYPTO_ECC_DP_B,
2381  M2MB_CRYPTO_ECC_DP_G_X,
2382  M2MB_CRYPTO_ECC_DP_G_Y,
2383  M2MB_CRYPTO_ECC_DP_N,
2384  M2MB_CRYPTO_ECC_DP_H,
2385  ENUM_TO_INT( M2MB_CRYPTO_ECC_DP_E )
2386 } M2MB_CRYPTO_ECC_DP_E;
2387 
2388 /* Global functions =============================================================================*/
2389 
2390 /*-----------------------------------------------------------------------------------------------*/
2417 /*-----------------------------------------------------------------------------------------------*/
2418 
2419 M2MB_RESULT_E m2mb_crypto_ecc_init( M2MB_CRYPTO_ECC_CONTEXT *ctx,
2420  M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E curve_domain_params );
2421 
2422 /*-----------------------------------------------------------------------------------------------*/
2467 /*-----------------------------------------------------------------------------------------------*/
2468 
2469 M2MB_RESULT_E m2mb_crypto_ecc_dp_init( M2MB_CRYPTO_ECC_CONTEXT ctx,
2470  UINT8 *p,
2471  UINT8 *a,
2472  UINT8 *b,
2473  UINT8 *g_x,
2474  UINT8 *g_y,
2475  UINT8 *n,
2476  UINT32 *h );
2477 
2478 /*-----------------------------------------------------------------------------------------------*/
2510 /*-----------------------------------------------------------------------------------------------*/
2511 M2MB_RESULT_E m2mb_crypto_ecc_dp_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
2512  M2MB_CRYPTO_ECC_DP_E domain,
2513  UINT32 len,
2514  const UINT8 *param);
2515 
2516 /*-----------------------------------------------------------------------------------------------*/
2554 /*-----------------------------------------------------------------------------------------------*/
2555 M2MB_RESULT_E m2mb_crypto_ecdsa_sign( M2MB_CRYPTO_ECC_CONTEXT ctx,
2556  UINT8 *msg,
2557  UINT32 msg_len,
2558  UINT8 *sig,
2559  SIZE_T sig_len );
2560 
2561 
2562 /*-----------------------------------------------------------------------------------------------*/
2603 /*-----------------------------------------------------------------------------------------------*/
2604 M2MB_RESULT_E m2mb_crypto_ecdsa_verify( M2MB_CRYPTO_ECC_CONTEXT ctx,
2605  UINT8 *msg,
2606  UINT32 msg_len,
2607  M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey,
2608  UINT8 *sig,
2609  SIZE_T sig_len );
2610 
2611 /*-----------------------------------------------------------------------------------------------*/
2650 /*-----------------------------------------------------------------------------------------------*/
2651 M2MB_RESULT_E m2mb_crypto_ecdh_shared_key_derive( M2MB_CRYPTO_ECC_CONTEXT ctx,
2652  UINT8 *shared_keyblob,
2653  UINT16 *shared_keyblob_len,
2654  const M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey );
2655 
2656 /*-----------------------------------------------------------------------------------------------*/
2682 /*-----------------------------------------------------------------------------------------------*/
2683 M2MB_RESULT_E m2mb_crypto_ecc_keypair_generate( M2MB_CRYPTO_ECC_CONTEXT ctx );
2684 
2685 /*-----------------------------------------------------------------------------------------------*/
2717 /*-----------------------------------------------------------------------------------------------*/
2718 M2MB_RESULT_E m2mb_crypto_ecc_keyblob_export( M2MB_CRYPTO_ECC_CONTEXT ctx,
2719  UINT8 *keyblob,
2720  UINT16 *keyblob_length );
2721 
2722 /*-----------------------------------------------------------------------------------------------*/
2754 /*-----------------------------------------------------------------------------------------------*/
2755 M2MB_RESULT_E m2mb_crypto_ecc_keyblob_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
2756  const UINT8 *keyblob,
2757  UINT32 keyblob_length );
2758 
2759 
2760 /*-----------------------------------------------------------------------------------------------*/
2788 /*-----------------------------------------------------------------------------------------------*/
2789 M2MB_RESULT_E m2mb_crypto_ecc_public_key_export( M2MB_CRYPTO_ECC_CONTEXT ctx,
2790  M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey );
2791 
2792 /*-----------------------------------------------------------------------------------------------*/
2820 /*-----------------------------------------------------------------------------------------------*/
2821 M2MB_RESULT_E m2mb_crypto_ecc_public_key_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
2822  const M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey );
2823 
2824 
2825 #ifdef TZ_DEBUG
2826 /*-----------------------------------------------------------------------------------------------*/
2858 /*-----------------------------------------------------------------------------------------------*/
2859 M2MB_RESULT_E m2mb_crypto_ecc_private_key_export( M2MB_CRYPTO_ECC_CONTEXT ctx,
2860  UINT8 *private_key,
2861  UINT16 *private_key_len);
2862 
2863 #endif
2864 
2865 /*-----------------------------------------------------------------------------------------------*/
2895 /*-----------------------------------------------------------------------------------------------*/
2896 M2MB_RESULT_E m2mb_crypto_ecc_private_key_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
2897  const UINT8 *privkey,
2898  UINT16 privkey_len );
2899 
2900 /*-----------------------------------------------------------------------------------------------*/
2923 /*-----------------------------------------------------------------------------------------------*/
2924 M2MB_RESULT_E m2mb_crypto_ecc_deinit( M2MB_CRYPTO_ECC_CONTEXT ctx );
2925 
2936 /* Global declarations ==========================================================================*/
2937 
2939 #define M2MB_CRYPTO_PRNG_MAX_BYTES 512
2940 
2941 /* Global functions =============================================================================*/
2942 
2943 /*-----------------------------------------------------------------------------------------------*/
2969 /*-----------------------------------------------------------------------------------------------*/
2970 UINT32 m2mb_crypto_prng_get_data( UINT8 *prng_data,
2971  UINT32 prng_data_len );
2975 #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 (create...
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 ke...
M2MB_CRYPTO_RSA_PADDING_PKCS1_PSS
Definition: m2mb_crypto.h:1690
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:1688
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:957
M2MB_CRYPTO_ECC_DP_SECP256R1
Definition: m2mb_crypto.h:2338
M2MB_CRYPTO_DES_KEY_SIZE
#define M2MB_CRYPTO_DES_KEY_SIZE
Definition: m2mb_crypto.h:1297
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:1289
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:946
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:2335
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.
M2MB_CRYPTO_RSA_PADDING_NONE
Definition: m2mb_crypto.h:1694
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.
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:2337
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:1703
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 ke...
M2MB_CRYPTO_DES_BLOCK_BYTE_LEN
#define M2MB_CRYPTO_DES_BLOCK_BYTE_LEN
Definition: m2mb_crypto.h:1306
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:2364
m2mb_crypto_retrieve_ctx
M2MB_CRYPTO_GEN_CONTEXT m2mb_crypto_retrieve_ctx(UINT8 *info)
Returns the context pointer for the given context ID.
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:2355
M2MB_CRYPTO_DES_ALG_TYPE_E
M2MB_CRYPTO_DES_ALG_TYPE_E
Definition: m2mb_crypto.h:1281
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:2376
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.
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 multipl...
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:1309
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:1300
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:1683
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:2339
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 ...
m2mb_crypto_hmac_reset
M2MB_RESULT_E m2mb_crypto_hmac_reset(M2MB_CRYPTO_HMAC_CONTEXT ctx)
Prepare to run HMAC for a new message.
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.
M2MB_CRYPTO_RSA_PADDING_PKCS1_V15
Definition: m2mb_crypto.h:1686
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:1303
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:1692
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:954
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.