TrustedFirmware Git Browser
Code Review Sign In
review.trustedfirmware.org / mirror / mbed-tls / 10e0e4d4ff251f7c34c68a7e7c48a9405d830d9f / . / tests / suites / test_suite_hkdf.function
blob: c85a51a7a94058bf4176a11a169741ea68d9f0cd [file] [log] [blame]
Thomas Fossati656864b2016-07-17 08:51:22 +0100[diff] [blame]1/* BEGIN_HEADER */
2#include "mbedtls/hkdf.h"
Jaeden Amero10e0e4d2018-05-23 19:44:26 +0100[diff] [blame^]3#include "mbedtls/md_internal.h"
Thomas Fossati656864b2016-07-17 08:51:22 +0100[diff] [blame]4/* END_HEADER */
5
6/* BEGIN_DEPENDENCIES
7 * depends_on:MBEDTLS_HKDF_C
8 * END_DEPENDENCIES
9 */
10
11/* BEGIN_CASE */
12void test_hkdf( int md_alg, char *hex_ikm_string, char *hex_salt_string,
13 char *hex_info_string, char *hex_okm_string )
14{
15 int ret;
16 size_t ikm_len, salt_len, info_len, okm_len;
17 unsigned char ikm[1024] = { '\0' };
18 unsigned char salt[1024] = { '\0' };
19 unsigned char info[1024] = { '\0' };
20 unsigned char expected_okm[1024] = { '\0' };
21 unsigned char okm[1024] = { '\0' };
22 unsigned char okm_string[1000] = { '\0' };
23
24 const mbedtls_md_info_t *md = mbedtls_md_info_from_type( md_alg );
25 TEST_ASSERT( md != NULL );
26
27 ikm_len = unhexify( ikm, hex_ikm_string );
28 salt_len = unhexify( salt, hex_salt_string );
29 info_len = unhexify( info, hex_info_string );
30 okm_len = unhexify( expected_okm, hex_okm_string );
31
32 ret = mbedtls_hkdf( md, salt, salt_len, ikm, ikm_len, info, info_len, okm,
33 okm_len);
34 TEST_ASSERT( ret == 0 );
35
36 // Run hexify on it so that it looks nicer if the assertion fails
37 hexify( okm_string, okm, okm_len );
38 TEST_ASSERT( !strcmp( (char *)okm_string, hex_okm_string ) );
39}
40/* END_CASE */
Jaeden Amero36189622018-05-23 18:55:47 +0100[diff] [blame]41
42/* BEGIN_CASE */
43void test_hkdf_extract( int md_alg, char *hex_ikm_string,
44 char *hex_salt_string, char *hex_prk_string )
45{
46 int ret;
47 unsigned char *ikm = NULL;
48 unsigned char *salt = NULL;
49 unsigned char *prk = NULL;
50 unsigned char *output_prk = NULL;
51 size_t ikm_len, salt_len, prk_len, output_prk_len;
52
53 const mbedtls_md_info_t *md = mbedtls_md_info_from_type( md_alg );
54 TEST_ASSERT( md != NULL );
55
56 output_prk_len = mbedtls_md_get_size( md );
57 output_prk = mbedtls_calloc( 1, output_prk_len );
58
59 ikm = unhexify_alloc( hex_ikm_string, &ikm_len );
60 salt = unhexify_alloc( hex_salt_string, &salt_len );
61 prk = unhexify_alloc( hex_prk_string, &prk_len );
62 TEST_ASSERT( prk_len == output_prk_len );
63
64 ret = mbedtls_hkdf_extract( md, salt, salt_len, ikm, ikm_len, output_prk );
65 TEST_ASSERT( ret == 0 );
66
67 TEST_ASSERT( !memcmp( output_prk, prk, prk_len ) );
68
69exit:
70 mbedtls_free(ikm);
71 mbedtls_free(salt);
72 mbedtls_free(prk);
73 mbedtls_free(output_prk);
74}
75/* END_CASE */
76
77/* BEGIN_CASE */
78void test_hkdf_expand( int md_alg, char *hex_info_string,
79 char *hex_prk_string, char *hex_okm_string )
80{
81 enum { OKM_LEN = 1024 };
82 int ret;
83 unsigned char *info = NULL;
84 unsigned char *prk = NULL;
85 unsigned char *okm = NULL;
86 unsigned char *output_okm = NULL;
87 size_t info_len, prk_len, okm_len;
88
89 const mbedtls_md_info_t *md = mbedtls_md_info_from_type( md_alg );
90 TEST_ASSERT( md != NULL );
91
92 output_okm = mbedtls_calloc( OKM_LEN, 1 );
93
94 prk = unhexify_alloc( hex_prk_string, &prk_len );
95 info = unhexify_alloc( hex_info_string, &info_len );
96 okm = unhexify_alloc( hex_okm_string, &okm_len );
97 TEST_ASSERT( prk_len == mbedtls_md_get_size( md ) );
98 TEST_ASSERT( okm_len < OKM_LEN );
99
100 ret = mbedtls_hkdf_expand( md, prk, prk_len, info, info_len,
101 output_okm, OKM_LEN );
102 TEST_ASSERT( ret == 0 );
103 TEST_ASSERT( !memcmp( output_okm, okm, okm_len ) );
104
105exit:
106 mbedtls_free(info);
107 mbedtls_free(prk);
108 mbedtls_free(okm);
109 mbedtls_free(output_okm);
110}
111/* END_CASE */
Jaeden Amero10e0e4d2018-05-23 19:44:26 +0100[diff] [blame^]112
113/* BEGIN_CASE */
114void test_hkdf_extract_ret( int hash_len, int ret )
115{
116 int output_ret;
117 unsigned char *salt = NULL;
118 unsigned char *ikm = NULL;
119 unsigned char *prk = NULL;
120 size_t salt_len, ikm_len;
121 struct mbedtls_md_info_t fake_md_info;
122
123 memset( &fake_md_info, 0, sizeof( fake_md_info ) );
124 fake_md_info.type = MBEDTLS_MD_NONE;
125 fake_md_info.size = hash_len;
126
127 prk = mbedtls_calloc( MBEDTLS_MD_MAX_SIZE, 1 );
128 salt_len = 0;
129 ikm_len = 0;
130
131 output_ret = mbedtls_hkdf_extract( &fake_md_info, salt, salt_len,
132 ikm, ikm_len, prk );
133 TEST_ASSERT( output_ret == ret );
134
135exit:
136 mbedtls_free(prk);
137}
138/* END_CASE */
139
140/* BEGIN_CASE */
141void test_hkdf_expand_ret( int hash_len, int prk_len, int okm_len, int ret )
142{
143 int output_ret;
144 unsigned char *info = NULL;
145 unsigned char *prk = NULL;
146 unsigned char *okm = NULL;
147 size_t info_len;
148 struct mbedtls_md_info_t fake_md_info;
149
150 memset( &fake_md_info, 0, sizeof( fake_md_info ) );
151 fake_md_info.type = MBEDTLS_MD_NONE;
152 fake_md_info.size = hash_len;
153
154 info_len = 0;
155
156 if (prk_len > 0)
157 prk = mbedtls_calloc( prk_len, 1 );
158
159 if (okm_len > 0)
160 okm = mbedtls_calloc( okm_len, 1 );
161
162 output_ret = mbedtls_hkdf_expand( &fake_md_info, prk, prk_len,
163 info, info_len, okm, okm_len );
164 TEST_ASSERT( output_ret == ret );
165
166exit:
167 mbedtls_free(prk);
168 mbedtls_free(okm);
169}
170/* END_CASE */