m2mb API docs  25.20.008
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 
28 
29 /* Global declarations ==========================================================================*/
30 
31 #define TZ_LOGGING
32 
33 /* free choice to use free or deinit in Telit style */
34 #define m2mb_crypto_md_free m2mb_crypto_md_deinit
35 #define m2mb_crypto_hmac_free m2mb_crypto_hmac_deinit
36 #define m2mb_crypto_cmac_free m2mb_crypto_cmac_deinit
37 #define m2mb_crypto_aes_free m2mb_crypto_aes_deinit
38 #define m2mb_crypto_des_free m2mb_crypto_des_deinit
39 #define m2mb_crypto_rsa_free m2mb_crypto_rsa_deinit
40 #define m2mb_crypto_ecc_free m2mb_crypto_ecc_deinit
41 
42 
43 #ifdef M2M_PFM_LINUX
44 // following macro only used for compile purposes.
45 //------------------------------------------------------------------------
46 // Object_invoke return codes
47 //------------------------------------------------------------------------
48 
49 #define Object_isOK(err) ((err) == 0)
50 #define Object_isERROR(err) ((err) != 0)
51 
52 // Generic error codes
53 
54 #define Object_OK 0 // non-specific success code
55 #define Object_ERROR 1 // non-specific error
56 #define Object_ERROR_INVALID 2 // unsupported/unrecognized request
57 #define Object_ERROR_SIZE_IN 3 // supplied buffer/string too large
58 #define Object_ERROR_SIZE_OUT 4 // supplied output buffer too small
59 
60 #define Object_ERROR_USERBASE 10 // start of user-defined error range
61 
62 // Transport layer error codes
63 
64 #define Object_ERROR_DEFUNCT -90 // object no longer exists
65 #define Object_ERROR_ABORT -91 // calling thread must exit
66 #define Object_ERROR_BADOBJ -92 // invalid object context
67 #define Object_ERROR_NOSLOTS -93 // caller's object table full
68 #define Object_ERROR_MAXARGS -94 // too many args
69 #define Object_ERROR_MAXDATA -95 // buffers too large
70 #define Object_ERROR_UNAVAIL -96 // the request could not be processed
71 #define Object_ERROR_KMEM -97 // kernel out of memory
72 #define Object_ERROR_REMOTE -98 // local method sent to remote object
73 #endif /* M2M_PFM_LINUX */
74 
75 
76 
77 /* Global typedef ==========================================================================*/
78 
83 typedef enum
84 {
85  M2MB_CRYPTO_CTX_ALG_NONE=0,
86  M2MB_CRYPTO_CTX_ALG_MD2,
87  M2MB_CRYPTO_CTX_ALG_MD4,
88  M2MB_CRYPTO_CTX_ALG_MD5,
89  M2MB_CRYPTO_CTX_ALG_SHA1,
90  M2MB_CRYPTO_CTX_ALG_SHA224,
91  M2MB_CRYPTO_CTX_ALG_SHA256,
92  M2MB_CRYPTO_CTX_ALG_SHA384,
93  M2MB_CRYPTO_CTX_ALG_SHA512,
94  M2MB_CRYPTO_CTX_ALG_HMAC,
95  M2MB_CRYPTO_CTX_ALG_CMAC,
96  M2MB_CRYPTO_CTX_ALG_RSA,
97  M2MB_CRYPTO_CTX_ALG_ECC,
98  M2MB_CRYPTO_CTX_ALG_AES,
99  M2MB_CRYPTO_CTX_ALG_DES,
100  ENUM_TO_INT( M2MB_CRYPTO_CTX_ALG_E )
101 } M2MB_CRYPTO_CTX_ALG_E;
102 
107 typedef struct M2MB_CRYPTO_GEN_CONTEXT_TAG *M2MB_CRYPTO_GEN_CONTEXT;
108 
109 
114 typedef struct M2MB_CRYPTO_MD_CONTEXT_TAG *M2MB_CRYPTO_MD_CONTEXT;
115 
120 typedef struct M2MB_CRYPTO_HMAC_CONTEXT_TAG *M2MB_CRYPTO_HMAC_CONTEXT;
121 
126 typedef struct M2MB_CRYPTO_CMAC_CONTEXT_TAG *M2MB_CRYPTO_CMAC_CONTEXT;
127 
132 typedef struct M2MB_CRYPTO_AES_CONTEXT_TAG *M2MB_CRYPTO_AES_CONTEXT;
133 
138 typedef struct M2MB_CRYPTO_DES_CONTEXT_TAG *M2MB_CRYPTO_DES_CONTEXT;
139 
144 typedef struct M2MB_CRYPTO_RSA_CONTEXT_TAG *M2MB_CRYPTO_RSA_CONTEXT;
145 
150 typedef struct M2MB_CRYPTO_ECC_CONTEXT_TAG *M2MB_CRYPTO_ECC_CONTEXT;
151 
156 typedef enum
157 {
158  M2MB_CRYPTO_MD_ALG_NONE=0,
159  M2MB_CRYPTO_MD_ALG_MD2,
160  M2MB_CRYPTO_MD_ALG_MD4,
161  M2MB_CRYPTO_MD_ALG_MD5,
162  M2MB_CRYPTO_MD_ALG_SHA1,
163  M2MB_CRYPTO_MD_ALG_SHA224,
164  M2MB_CRYPTO_MD_ALG_SHA256,
165  M2MB_CRYPTO_MD_ALG_SHA384,
166  M2MB_CRYPTO_MD_ALG_SHA512,
167  ENUM_TO_INT( M2MB_CRYPTO_MD_ALG_E )
168 } M2MB_CRYPTO_MD_ALG_E;
169 
170 /* Global functions =============================================================================*/
171 
172 /*-----------------------------------------------------------------------------------------------*/
192 /*-----------------------------------------------------------------------------------------------*/
193 M2MB_CRYPTO_CTX_ALG_E m2mb_crypto_get_algo( M2MB_CRYPTO_GEN_CONTEXT ctx );
194 
195 /*-----------------------------------------------------------------------------------------------*/
219 /*-----------------------------------------------------------------------------------------------*/
220 UINT32 m2mb_crypto_ctx_info_for_tee( M2MB_CRYPTO_GEN_CONTEXT ctx, UINT8 *info );
221 
222 /*-----------------------------------------------------------------------------------------------*/
242 /*-----------------------------------------------------------------------------------------------*/
243 M2MB_CRYPTO_GEN_CONTEXT m2mb_crypto_retrieve_ctx( UINT8 *info );
244 
245 /*-----------------------------------------------------------------------------------------------*/
269 /*-----------------------------------------------------------------------------------------------*/
270 M2MB_RESULT_E m2mb_crypto_md_init( M2MB_CRYPTO_MD_CONTEXT *ctx );
271 
297 /*-----------------------------------------------------------------------------------------------*/
298 M2MB_RESULT_E m2mb_crypto_md_setup( M2MB_CRYPTO_MD_CONTEXT ctx,
299  const M2MB_CRYPTO_MD_ALG_E md_info );
300 
301 /*-----------------------------------------------------------------------------------------------*/
332 /*-----------------------------------------------------------------------------------------------*/
333 M2MB_RESULT_E m2mb_crypto_md_update( M2MB_CRYPTO_MD_CONTEXT ctx,
334  const UINT8 *data,
335  SIZE_T len );
336 
337 /*-----------------------------------------------------------------------------------------------*/
365 /*-----------------------------------------------------------------------------------------------*/
366 M2MB_RESULT_E m2mb_crypto_md_final( M2MB_CRYPTO_MD_CONTEXT ctx,
367  UINT8 *md );
368 
369 /*-----------------------------------------------------------------------------------------------*/
393 /*-----------------------------------------------------------------------------------------------*/
394 M2MB_RESULT_E m2mb_crypto_md_deinit( M2MB_CRYPTO_MD_CONTEXT ctx );
395 
396 /*-----------------------------------------------------------------------------------------------*/
437 /*-----------------------------------------------------------------------------------------------*/
438 UINT8 *m2mb_crypto_md( const M2MB_CRYPTO_MD_ALG_E md_info,
439  const UINT8 *data,
440  SIZE_T len,
441  UINT8 *md );
442 
443 
444 /* Global declarations ==========================================================================*/
445 
452 /* Global functions =============================================================================*/
453 
454 /*-----------------------------------------------------------------------------------------------*/
478 /*-----------------------------------------------------------------------------------------------*/
479 M2MB_RESULT_E m2mb_crypto_hmac_init( M2MB_CRYPTO_HMAC_CONTEXT *ctx );
480 
514 /*-----------------------------------------------------------------------------------------------*/
515 M2MB_RESULT_E m2mb_crypto_hmac_setup( M2MB_CRYPTO_HMAC_CONTEXT ctx,
516  M2MB_CRYPTO_MD_ALG_E md_info,
517  const UINT8 *key,
518  SIZE_T keylen );
519 
520 /*-----------------------------------------------------------------------------------------------*/
552 /*-----------------------------------------------------------------------------------------------*/
553 M2MB_RESULT_E m2mb_crypto_hmac_update( M2MB_CRYPTO_HMAC_CONTEXT ctx,
554  const UINT8 *data,
555  SIZE_T len );
556 
557 /*-----------------------------------------------------------------------------------------------*/
586 /*-----------------------------------------------------------------------------------------------*/
587 M2MB_RESULT_E m2mb_crypto_hmac_final( M2MB_CRYPTO_HMAC_CONTEXT ctx,
588  UINT8 *hmac );
589 
590 /*-----------------------------------------------------------------------------------------------*/
615 /*-----------------------------------------------------------------------------------------------*/
616 M2MB_RESULT_E m2mb_crypto_hmac_reset( M2MB_CRYPTO_HMAC_CONTEXT ctx );
617 
618 /*-----------------------------------------------------------------------------------------------*/
641 /*-----------------------------------------------------------------------------------------------*/
642 M2MB_RESULT_E m2mb_crypto_hmac_deinit( M2MB_CRYPTO_HMAC_CONTEXT ctx );
643 
644 /*-----------------------------------------------------------------------------------------------*/
689 /*-----------------------------------------------------------------------------------------------*/
690 UINT8 *m2mb_crypto_hmac( M2MB_CRYPTO_MD_ALG_E md_info,
691  const UINT8 *key,
692  const SIZE_T keylen,
693  const UINT8 *input,
694  const SIZE_T inlen,
695  UINT8 *hmac );
696 
706 /* Global declarations ==========================================================================*/
707 
708 
709 typedef enum
710 {
711  M2MB_CRYPTO_CMAC_ALG_AES_128 = 1,
712  M2MB_CRYPTO_CMAC_ALG_AES_192 = 2,
713  M2MB_CRYPTO_CMAC_ALG_AES_256 = 3,
714  ENUM_TO_INT( M2MB_CRYPTO_CMAC_ALG_E )
715 } M2MB_CRYPTO_CMAC_ALG_E;
716 
717 /* Global functions =============================================================================*/
718 
719 /*-----------------------------------------------------------------------------------------------*/
743 /*-----------------------------------------------------------------------------------------------*/
744 M2MB_RESULT_E m2mb_crypto_cmac_init( M2MB_CRYPTO_CMAC_CONTEXT *ctx );
745 
777 /*-----------------------------------------------------------------------------------------------*/
778 M2MB_RESULT_E m2mb_crypto_cmac_setup( M2MB_CRYPTO_CMAC_CONTEXT ctx,
779  const UINT8 *key,
780  SIZE_T keylen );
781 
782 /*-----------------------------------------------------------------------------------------------*/
814 /*-----------------------------------------------------------------------------------------------*/
815 M2MB_RESULT_E m2mb_crypto_cmac_update( M2MB_CRYPTO_CMAC_CONTEXT ctx,
816  const UINT8 *data,
817  SIZE_T len );
818 
819 /*-----------------------------------------------------------------------------------------------*/
848 /*-----------------------------------------------------------------------------------------------*/
849 M2MB_RESULT_E m2mb_crypto_cmac_final( M2MB_CRYPTO_CMAC_CONTEXT ctx,
850  UINT8 *cmac );
851 
852 /*-----------------------------------------------------------------------------------------------*/
877 /*-----------------------------------------------------------------------------------------------*/
878 M2MB_RESULT_E m2mb_crypto_cmac_reset( M2MB_CRYPTO_CMAC_CONTEXT ctx );
879 
880 /*-----------------------------------------------------------------------------------------------*/
903 /*-----------------------------------------------------------------------------------------------*/
904 M2MB_RESULT_E m2mb_crypto_cmac_deinit( M2MB_CRYPTO_CMAC_CONTEXT ctx );
905 
906 /*-----------------------------------------------------------------------------------------------*/
948 /*-----------------------------------------------------------------------------------------------*/
949 UINT8 *m2mb_crypto_cmac( M2MB_CRYPTO_CMAC_ALG_E cmac_alg,
950  const UINT8 *key,
951  const SIZE_T keylen,
952  const UINT8 *input,
953  const SIZE_T inlen,
954  UINT8 *cmac );
955 
956 
966 /* Global declarations ==========================================================================*/
967 
968 
969 
974 typedef enum
975 {
976  M2MB_CRYPTO_AES_MODE_ENCRYPT,
977  M2MB_CRYPTO_AES_MODE_DECRYPT,
978  ENUM_TO_INT( M2MB_CRYPTO_AES_MODE_E )
979 } M2MB_CRYPTO_AES_MODE_E;
980 
982 #define M2MB_CRYPTO_AES_ECB_BLOCK_SIZE 16
983 
985 #define M2MB_CRYPTO_AES_IV_SIZE 16
986 
987 
988 /* Global functions =============================================================================*/
989 
990 /*-----------------------------------------------------------------------------------------------*/
1013 /*-----------------------------------------------------------------------------------------------*/
1014 M2MB_RESULT_E m2mb_crypto_aes_init( M2MB_CRYPTO_AES_CONTEXT *ctx );
1015 
1016 /*-----------------------------------------------------------------------------------------------*/
1038 /*-----------------------------------------------------------------------------------------------*/
1039 M2MB_RESULT_E m2mb_crypto_aes_deinit( M2MB_CRYPTO_AES_CONTEXT ctx );
1040 
1041 /*-----------------------------------------------------------------------------------------------*/
1068 /*-----------------------------------------------------------------------------------------------*/
1069 M2MB_RESULT_E m2mb_crypto_aes_generate_key( M2MB_CRYPTO_AES_CONTEXT ctx,
1070  UINT32 keybits );
1071 
1072 /*-----------------------------------------------------------------------------------------------*/
1127 /*-----------------------------------------------------------------------------------------------*/
1128 M2MB_RESULT_E m2mb_crypto_aes_keyblob_export( M2MB_CRYPTO_AES_CONTEXT ctx,
1129  UINT8 *keyblob,
1130  UINT32 *keyblob_length );
1131 
1132 /*-----------------------------------------------------------------------------------------------*/
1165 /*-----------------------------------------------------------------------------------------------*/
1166 M2MB_RESULT_E m2mb_crypto_aes_keyblob_import( M2MB_CRYPTO_AES_CONTEXT ctx,
1167  const UINT8 *keyblob,
1168  UINT32 keyblob_length );
1169 
1170 /*-----------------------------------------------------------------------------------------------*/
1203 /*-----------------------------------------------------------------------------------------------*/
1204 M2MB_RESULT_E m2mb_crypto_aes_externalkey_import ( M2MB_CRYPTO_AES_CONTEXT ctx,
1205  const UINT8 *key,
1206  UINT32 keylength );
1207 
1208 /*-----------------------------------------------------------------------------------------------*/
1240 /*-----------------------------------------------------------------------------------------------*/
1241 M2MB_RESULT_E m2mb_crypto_aes_ecb_encdec( M2MB_CRYPTO_AES_CONTEXT ctx,
1242  M2MB_CRYPTO_AES_MODE_E mode,
1243  const UINT8 in[M2MB_CRYPTO_AES_ECB_BLOCK_SIZE],
1244  UINT8 out[M2MB_CRYPTO_AES_ECB_BLOCK_SIZE] );
1245 
1246 /*-----------------------------------------------------------------------------------------------*/
1287 /*-----------------------------------------------------------------------------------------------*/
1288 M2MB_RESULT_E m2mb_crypto_aes_cbc_encdec( M2MB_CRYPTO_AES_CONTEXT ctx,
1289  M2MB_CRYPTO_AES_MODE_E mode,
1290  const UINT8 *in,
1291  UINT8 *out,
1292  SIZE_T inlen,
1293  UINT8 ivec[M2MB_CRYPTO_AES_IV_SIZE] );
1294 
1304 /* Global declarations ==========================================================================*/
1305 
1306 
1307 
1309 typedef enum
1310 {
1311  M2MB_CRYPTO_ALG_DES,
1312  M2MB_CRYPTO_ALG_3DES,
1313  ENUM_TO_INT( M2MB_CRYPTO_DES_ALG_TYPE_E )
1314 } M2MB_CRYPTO_DES_ALG_TYPE_E;
1315 
1317 typedef enum
1318 {
1319  M2MB_CRYPTO_DES_MODE_ENCRYPT,
1320  M2MB_CRYPTO_DES_MODE_DECRYPT,
1321  ENUM_TO_INT( M2MB_CRYPTO_DES_MODE_E )
1322 } M2MB_CRYPTO_DES_MODE_E;
1323 
1325 #define M2MB_CRYPTO_DES_KEY_SIZE 8
1326 
1328 #define M2MB_CRYPTO_3DES_KEY2_SIZE 16
1329 
1331 #define M2MB_CRYPTO_3DES_KEY3_SIZE 24
1332 
1334 #define M2MB_CRYPTO_DES_BLOCK_BYTE_LEN 8
1335 
1337 #define M2MB_CRYPTO_DES_IV_BYTE_LEN 8
1338 
1339 /* Global functions =============================================================================*/
1340 
1341 /*-----------------------------------------------------------------------------------------------*/
1368 /*-----------------------------------------------------------------------------------------------*/
1369 M2MB_RESULT_E m2mb_crypto_des_init( M2MB_CRYPTO_DES_CONTEXT *ctx,
1370  M2MB_CRYPTO_DES_ALG_TYPE_E des_alg );
1371 
1372 /*-----------------------------------------------------------------------------------------------*/
1395 /*-----------------------------------------------------------------------------------------------*/
1396 M2MB_RESULT_E m2mb_crypto_des_deinit( M2MB_CRYPTO_DES_CONTEXT ctx );
1397 
1398 /*-----------------------------------------------------------------------------------------------*/
1425 /*-----------------------------------------------------------------------------------------------*/
1426 M2MB_RESULT_E m2mb_crypto_des_generate_key( M2MB_CRYPTO_DES_CONTEXT ctx,
1427  UINT32 keybits );
1428 
1429 /*-----------------------------------------------------------------------------------------------*/
1457 /*-----------------------------------------------------------------------------------------------*/
1458 M2MB_RESULT_E m2mb_crypto_des_externalkey_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1459  const UINT8 key[M2MB_CRYPTO_DES_KEY_SIZE] );
1460 
1461 /*-----------------------------------------------------------------------------------------------*/
1489 /*-----------------------------------------------------------------------------------------------*/
1490 M2MB_RESULT_E m2mb_crypto_3des_2externalkey_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1491  const UINT8 key[M2MB_CRYPTO_3DES_KEY2_SIZE] );
1492 
1493 /*-----------------------------------------------------------------------------------------------*/
1521 /*-----------------------------------------------------------------------------------------------*/
1522 M2MB_RESULT_E m2mb_crypto_3des_3externalkey_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1523  const UINT8 key[M2MB_CRYPTO_3DES_KEY3_SIZE] );
1524 
1525 /*-----------------------------------------------------------------------------------------------*/
1557 /*-----------------------------------------------------------------------------------------------*/
1558 M2MB_RESULT_E m2mb_crypto_des_keyblob_import( M2MB_CRYPTO_DES_CONTEXT ctx,
1559  const UINT8 *keyblob,
1560  UINT32 keyblob_length );
1561 
1562 /*-----------------------------------------------------------------------------------------------*/
1594 /*-----------------------------------------------------------------------------------------------*/
1595 M2MB_RESULT_E m2mb_crypto_des_keyblob_export( M2MB_CRYPTO_DES_CONTEXT ctx,
1596  UINT8 *keyblob,
1597  UINT32 *keyblob_length );
1598 
1599 /*-----------------------------------------------------------------------------------------------*/
1631 /*-----------------------------------------------------------------------------------------------*/
1632 M2MB_RESULT_E m2mb_crypto_des_ecb_encdec( M2MB_CRYPTO_DES_CONTEXT ctx,
1633  M2MB_CRYPTO_DES_MODE_E mode,
1634  const UINT8 in[M2MB_CRYPTO_DES_BLOCK_BYTE_LEN],
1635  UINT8 out[M2MB_CRYPTO_DES_BLOCK_BYTE_LEN] );
1636 
1637 /*-----------------------------------------------------------------------------------------------*/
1678 /*-----------------------------------------------------------------------------------------------*/
1679 M2MB_RESULT_E m2mb_crypto_des_cbc_encdec( M2MB_CRYPTO_DES_CONTEXT ctx,
1680  M2MB_CRYPTO_DES_MODE_E mode,
1681  const UINT8 *in,
1682  UINT8 *out,
1683  SIZE_T inlen,
1684  UINT8 ivec[M2MB_CRYPTO_DES_IV_BYTE_LEN] );
1685 
1703 /* Global declarations ==========================================================================*/
1704 
1705 
1706 /* Padding types for encryption. */
1711 typedef enum
1712 {
1714  M2MB_CRYPTO_RSA_PADDING_PKCS1_V15,
1716  M2MB_CRYPTO_RSA_PADDING_PKCS1_OAEP,
1718  M2MB_CRYPTO_RSA_PADDING_PKCS1_PSS,
1720  M2MB_CRYPTO_RSA_PADDING_PKCS1_PSS_AUTORECOVER_SALTLEN,
1722  M2MB_CRYPTO_RSA_PADDING_NONE,
1723 
1724  ENUM_TO_INT( M2MB_CRYPTO_RSA_PADDING_TYPE_E )
1725 } M2MB_CRYPTO_RSA_PADDING_TYPE_E;
1726 
1731 typedef enum
1732 {
1733  M2MB_CRYPTO_RSA_PUBLIC,
1734  M2MB_CRYPTO_RSA_PRIVATE,
1735  ENUM_TO_INT( M2MB_CRYPTO_RSA_MODE_E )
1736 } M2MB_CRYPTO_RSA_MODE_E;
1737 
1738 /* Global functions =============================================================================*/
1739 
1740 /*-----------------------------------------------------------------------------------------------*/
1771 /*-----------------------------------------------------------------------------------------------*/
1772 M2MB_RESULT_E m2mb_crypto_rsa_init( M2MB_CRYPTO_RSA_CONTEXT *ctx,
1773  M2MB_CRYPTO_RSA_PADDING_TYPE_E padding_type,
1774  M2MB_CRYPTO_MD_ALG_E hash_id );
1775 
1776 /*-----------------------------------------------------------------------------------------------*/
1799 /*-----------------------------------------------------------------------------------------------*/
1800 M2MB_RESULT_E m2mb_crypto_rsa_deinit( M2MB_CRYPTO_RSA_CONTEXT ctx );
1801 
1802 /*-----------------------------------------------------------------------------------------------*/
1835 /*-----------------------------------------------------------------------------------------------*/
1836 M2MB_RESULT_E m2mb_crypto_rsa_public( M2MB_CRYPTO_RSA_CONTEXT ctx,
1837  const UINT8 *in,
1838  UINT8 *out );
1839 
1840 /*-----------------------------------------------------------------------------------------------*/
1871 /*-----------------------------------------------------------------------------------------------*/
1872 M2MB_RESULT_E m2mb_crypto_rsa_private( M2MB_CRYPTO_RSA_CONTEXT ctx,
1873  const UINT8 *in,
1874  UINT8 *out );
1875 
1876 /*-----------------------------------------------------------------------------------------------*/
1906 /*-----------------------------------------------------------------------------------------------*/
1907 M2MB_RESULT_E m2mb_crypto_rsa_generate_key( M2MB_CRYPTO_RSA_CONTEXT ctx,
1908  UINT32 key_size,
1909  UINT32 public_exponent );
1910 
1911 /*-----------------------------------------------------------------------------------------------*/
1943 /*-----------------------------------------------------------------------------------------------*/
1944 M2MB_RESULT_E m2mb_crypto_rsa_keyblob_export( M2MB_CRYPTO_RSA_CONTEXT ctx,
1945  UINT8 *keyblob,
1946  UINT32 *keyblob_length );
1947 
1948 /*-----------------------------------------------------------------------------------------------*/
1980 /*-----------------------------------------------------------------------------------------------*/
1981 M2MB_RESULT_E m2mb_crypto_rsa_keyblob_import( M2MB_CRYPTO_RSA_CONTEXT ctx,
1982  const UINT8 *keyblob,
1983  UINT32 keyblob_length );
1984 
1985 /*-----------------------------------------------------------------------------------------------*/
2023 /*-----------------------------------------------------------------------------------------------*/
2024 M2MB_RESULT_E m2mb_crypto_rsa_public_key_export( M2MB_CRYPTO_RSA_CONTEXT ctx,
2025  UINT8 *modulus,
2026  UINT32 *modulus_size,
2027  UINT8 *public_exponent,
2028  UINT32 *public_exponent_size );
2029 
2030 /*-----------------------------------------------------------------------------------------------*/
2068 /*-----------------------------------------------------------------------------------------------*/
2069 M2MB_RESULT_E m2mb_crypto_rsa_public_key_import( M2MB_CRYPTO_RSA_CONTEXT ctx,
2070  const UINT8 *modulus,
2071  UINT32 modulus_size,
2072  const UINT8 *public_exponent,
2073  UINT32 public_exponent_size );
2074 
2075 /*-----------------------------------------------------------------------------------------------*/
2134 /*-----------------------------------------------------------------------------------------------*/
2135 M2MB_RESULT_E m2mb_crypto_rsa_externalkey_import( M2MB_CRYPTO_RSA_CONTEXT ctx,
2136  const UINT8 *modulus,
2137  UINT32 modulus_size,
2138  const UINT8 *p_factor,
2139  UINT32 p_factor_size,
2140  const UINT8 *q_factor,
2141  UINT32 q_factor_size,
2142  const UINT8 *public_exponent,
2143  UINT32 public_exponent_size,
2144  const UINT8 *private_exponent,
2145  UINT32 private_exponent_size,
2146  M2MB_CRYPTO_RSA_PADDING_TYPE_E padding_type );
2147 
2148 /*-----------------------------------------------------------------------------------------------*/
2184 /*-----------------------------------------------------------------------------------------------*/
2185 M2MB_RESULT_E m2mb_crypto_rsa_encrypt( M2MB_CRYPTO_RSA_CONTEXT ctx,
2186  M2MB_CRYPTO_RSA_MODE_E mode,
2187  SIZE_T inlen,
2188  const UINT8 *in,
2189  UINT8 *out );
2190 
2191 
2192 /*-----------------------------------------------------------------------------------------------*/
2233 /*-----------------------------------------------------------------------------------------------*/
2234 M2MB_RESULT_E m2mb_crypto_rsa_decrypt( M2MB_CRYPTO_RSA_CONTEXT ctx,
2235  M2MB_CRYPTO_RSA_MODE_E mode,
2236  SIZE_T *outlen,
2237  UINT8 *out,
2238  SIZE_T out_max_len,
2239  const UINT8 *in );
2240 
2241 /*-----------------------------------------------------------------------------------------------*/
2282 /*-----------------------------------------------------------------------------------------------*/
2283 M2MB_RESULT_E m2mb_crypto_rsa_sign( M2MB_CRYPTO_RSA_CONTEXT ctx,
2284  M2MB_CRYPTO_RSA_MODE_E mode,
2285  M2MB_CRYPTO_MD_ALG_E md_alg,
2286  UINT32 hashlen,
2287  const UINT8 *hash,
2288  UINT8 *sig );
2289 
2290 /*-----------------------------------------------------------------------------------------------*/
2334 /*-----------------------------------------------------------------------------------------------*/
2335 M2MB_RESULT_E m2mb_crypto_rsa_verify( M2MB_CRYPTO_RSA_CONTEXT ctx,
2336  UINT8 *pubkey,
2337  UINT32 pubkey_length,
2338  M2MB_CRYPTO_MD_ALG_E md_alg,
2339  UINT32 hashlen,
2340  const UINT8 *hash,
2341  const UINT8 *sig );
2342 
2352 /* Global declarations ==========================================================================*/
2353 
2354 
2355 
2363 typedef enum
2364 {
2365  M2MB_CRYPTO_ECC_DP_BP256R1,
2366  M2MB_CRYPTO_ECC_DP_SECP256R1,
2367  M2MB_CRYPTO_ECC_DP_CUSTOM,
2369  ENUM_TO_INT( M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E )
2370 } M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E;
2371 
2376 //#define M2MB_CRYPTO_ECC_BIGLEN 9
2377 #define M2MB_CRYPTO_ECC_BIGLEN 18
2378 
2383 #define M2MB_MAX_ECC_KEY_SIZE 32
2384 
2392 typedef struct
2393 {
2394  UINT8 x[M2MB_MAX_ECC_KEY_SIZE+1];
2395  UINT8 y[M2MB_MAX_ECC_KEY_SIZE+1];
2396  INT32 flags;
2397  INT32 key_size_bytes;
2398 } M2MB_CRYPTO_ECC_AFFINE_POINT_T;
2399 
2404 typedef enum
2405 {
2406  M2MB_CRYPTO_ECC_DP_P,
2407  M2MB_CRYPTO_ECC_DP_A,
2408  M2MB_CRYPTO_ECC_DP_B,
2409  M2MB_CRYPTO_ECC_DP_G_X,
2410  M2MB_CRYPTO_ECC_DP_G_Y,
2411  M2MB_CRYPTO_ECC_DP_N,
2412  M2MB_CRYPTO_ECC_DP_H,
2413  ENUM_TO_INT( M2MB_CRYPTO_ECC_DP_E )
2414 } M2MB_CRYPTO_ECC_DP_E;
2415 
2416 /* Global functions =============================================================================*/
2417 
2418 /*-----------------------------------------------------------------------------------------------*/
2445 /*-----------------------------------------------------------------------------------------------*/
2446 
2447 M2MB_RESULT_E m2mb_crypto_ecc_init( M2MB_CRYPTO_ECC_CONTEXT *ctx,
2448  M2MB_CRYPTO_ECC_DOMAIN_GROUP_ID_E curve_domain_params );
2449 
2450 /*-----------------------------------------------------------------------------------------------*/
2495 /*-----------------------------------------------------------------------------------------------*/
2496 
2497 M2MB_RESULT_E m2mb_crypto_ecc_dp_init( M2MB_CRYPTO_ECC_CONTEXT ctx,
2498  UINT8 *p,
2499  UINT8 *a,
2500  UINT8 *b,
2501  UINT8 *g_x,
2502  UINT8 *g_y,
2503  UINT8 *n,
2504  UINT32 *h );
2505 
2506 /*-----------------------------------------------------------------------------------------------*/
2538 /*-----------------------------------------------------------------------------------------------*/
2539 M2MB_RESULT_E m2mb_crypto_ecc_dp_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
2540  M2MB_CRYPTO_ECC_DP_E domain,
2541  UINT32 len,
2542  const UINT8 *param);
2543 
2544 /*-----------------------------------------------------------------------------------------------*/
2582 /*-----------------------------------------------------------------------------------------------*/
2583 M2MB_RESULT_E m2mb_crypto_ecdsa_sign( M2MB_CRYPTO_ECC_CONTEXT ctx,
2584  UINT8 *msg,
2585  UINT32 msg_len,
2586  UINT8 *sig,
2587  SIZE_T sig_len );
2588 
2589 
2590 /*-----------------------------------------------------------------------------------------------*/
2631 /*-----------------------------------------------------------------------------------------------*/
2632 M2MB_RESULT_E m2mb_crypto_ecdsa_verify( M2MB_CRYPTO_ECC_CONTEXT ctx,
2633  UINT8 *msg,
2634  UINT32 msg_len,
2635  M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey,
2636  UINT8 *sig,
2637  SIZE_T sig_len );
2638 
2639 /*-----------------------------------------------------------------------------------------------*/
2678 /*-----------------------------------------------------------------------------------------------*/
2679 M2MB_RESULT_E m2mb_crypto_ecdh_shared_key_derive( M2MB_CRYPTO_ECC_CONTEXT ctx,
2680  UINT8 *shared_keyblob,
2681  UINT16 *shared_keyblob_len,
2682  const M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey );
2683 
2684 /*-----------------------------------------------------------------------------------------------*/
2710 /*-----------------------------------------------------------------------------------------------*/
2711 M2MB_RESULT_E m2mb_crypto_ecc_keypair_generate( M2MB_CRYPTO_ECC_CONTEXT ctx );
2712 
2713 /*-----------------------------------------------------------------------------------------------*/
2745 /*-----------------------------------------------------------------------------------------------*/
2746 M2MB_RESULT_E m2mb_crypto_ecc_keyblob_export( M2MB_CRYPTO_ECC_CONTEXT ctx,
2747  UINT8 *keyblob,
2748  UINT16 *keyblob_length );
2749 
2750 /*-----------------------------------------------------------------------------------------------*/
2782 /*-----------------------------------------------------------------------------------------------*/
2783 M2MB_RESULT_E m2mb_crypto_ecc_keyblob_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
2784  const UINT8 *keyblob,
2785  UINT32 keyblob_length );
2786 
2787 
2788 /*-----------------------------------------------------------------------------------------------*/
2816 /*-----------------------------------------------------------------------------------------------*/
2817 M2MB_RESULT_E m2mb_crypto_ecc_public_key_export( M2MB_CRYPTO_ECC_CONTEXT ctx,
2818  M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey );
2819 
2820 /*-----------------------------------------------------------------------------------------------*/
2848 /*-----------------------------------------------------------------------------------------------*/
2849 M2MB_RESULT_E m2mb_crypto_ecc_public_key_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
2850  const M2MB_CRYPTO_ECC_AFFINE_POINT_T *pubkey );
2851 
2852 
2853 #ifdef TZ_DEBUG
2854 /*-----------------------------------------------------------------------------------------------*/
2886 /*-----------------------------------------------------------------------------------------------*/
2887 M2MB_RESULT_E m2mb_crypto_ecc_private_key_export( M2MB_CRYPTO_ECC_CONTEXT ctx,
2888  UINT8 *private_key,
2889  UINT16 *private_key_len);
2890 
2891 #endif
2892 
2893 /*-----------------------------------------------------------------------------------------------*/
2923 /*-----------------------------------------------------------------------------------------------*/
2924 M2MB_RESULT_E m2mb_crypto_ecc_private_key_import( M2MB_CRYPTO_ECC_CONTEXT ctx,
2925  const UINT8 *privkey,
2926  UINT16 privkey_len );
2927 
2928 /*-----------------------------------------------------------------------------------------------*/
2951 /*-----------------------------------------------------------------------------------------------*/
2952 M2MB_RESULT_E m2mb_crypto_ecc_deinit( M2MB_CRYPTO_ECC_CONTEXT ctx );
2953 
2964 /* Global declarations ==========================================================================*/
2965 
2967 #define M2MB_CRYPTO_PRNG_MAX_BYTES 512
2968 
2969 /* Global functions =============================================================================*/
2970 
2971 /*-----------------------------------------------------------------------------------------------*/
2997 /*-----------------------------------------------------------------------------------------------*/
2998 UINT32 m2mb_crypto_prng_get_data( UINT8 *prng_data,
2999  UINT32 prng_data_len );
3000 
3001 
3002 
3007 #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:1718
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:1716
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:132
M2MB_CRYPTO_AES_IV_SIZE
#define M2MB_CRYPTO_AES_IV_SIZE
Definition: m2mb_crypto.h:985
M2MB_CRYPTO_ECC_DP_SECP256R1
Definition: m2mb_crypto.h:2366
M2MB_CRYPTO_DES_KEY_SIZE
#define M2MB_CRYPTO_DES_KEY_SIZE
Definition: m2mb_crypto.h:1325
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:1317
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:974
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:2363
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:1722
M2MB_CRYPTO_DES_CONTEXT
struct M2MB_CRYPTO_DES_CONTEXT_TAG * M2MB_CRYPTO_DES_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:138
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:2365
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:1731
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:114
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:1334
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:144
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:2392
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:2383
M2MB_CRYPTO_DES_ALG_TYPE_E
M2MB_CRYPTO_DES_ALG_TYPE_E
Definition: m2mb_crypto.h:1309
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:150
M2MB_CRYPTO_ECC_DP_E
M2MB_CRYPTO_ECC_DP_E
Enumeration representing all the ECC Domain Parameters.
Definition: m2mb_crypto.h:2404
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:156
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:83
M2MB_CRYPTO_DES_IV_BYTE_LEN
#define M2MB_CRYPTO_DES_IV_BYTE_LEN
Definition: m2mb_crypto.h:1337
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:1328
M2MB_CRYPTO_CMAC_CONTEXT
struct M2MB_CRYPTO_CMAC_CONTEXT_TAG * M2MB_CRYPTO_CMAC_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:126
M2MB_CRYPTO_HMAC_CONTEXT
struct M2MB_CRYPTO_HMAC_CONTEXT_TAG * M2MB_CRYPTO_HMAC_CONTEXT
Opaque structure for context.
Definition: m2mb_crypto.h:120
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:1711
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:2367
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:1714
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:107
M2MB_CRYPTO_3DES_KEY3_SIZE
#define M2MB_CRYPTO_3DES_KEY3_SIZE
Definition: m2mb_crypto.h:1331
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:1720
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:982
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.