• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/* BEGIN_HEADER */
2#include "mbedtls/hkdf.h"
3#include "md_wrap.h"
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, data_t *ikm, data_t *salt, data_t *info,
13               data_t *expected_okm)
14{
15    int ret;
16    unsigned char okm[128] = { '\0' };
17
18    const mbedtls_md_info_t *md = mbedtls_md_info_from_type(md_alg);
19    TEST_ASSERT(md != NULL);
20
21    TEST_ASSERT(expected_okm->len <= sizeof(okm));
22
23    ret = mbedtls_hkdf(md, salt->x, salt->len, ikm->x, ikm->len,
24                       info->x, info->len, okm, expected_okm->len);
25    TEST_ASSERT(ret == 0);
26
27    ASSERT_COMPARE(okm, expected_okm->len,
28                   expected_okm->x, expected_okm->len);
29}
30/* END_CASE */
31
32/* BEGIN_CASE */
33void test_hkdf_extract(int md_alg,
34                       data_t *ikm,
35                       data_t *salt,
36                       data_t *prk)
37{
38    int ret;
39    unsigned char *output_prk = NULL;
40    size_t output_prk_len;
41
42    const mbedtls_md_info_t *md = mbedtls_md_info_from_type(md_alg);
43    TEST_ASSERT(md != NULL);
44
45    output_prk_len = mbedtls_md_get_size(md);
46    ASSERT_ALLOC(output_prk, output_prk_len);
47
48    ret = mbedtls_hkdf_extract(md, salt->x, salt->len,
49                               ikm->x, ikm->len, output_prk);
50    TEST_ASSERT(ret == 0);
51
52    ASSERT_COMPARE(output_prk, output_prk_len, prk->x, prk->len);
53
54exit:
55    mbedtls_free(output_prk);
56}
57/* END_CASE */
58
59/* BEGIN_CASE */
60void test_hkdf_expand(int md_alg,
61                      data_t *info,
62                      data_t *prk,
63                      data_t *okm)
64{
65    enum { OKM_LEN  = 1024 };
66    int ret;
67    unsigned char *output_okm = NULL;
68
69    const mbedtls_md_info_t *md = mbedtls_md_info_from_type(md_alg);
70    TEST_ASSERT(md != NULL);
71
72    ASSERT_ALLOC(output_okm, OKM_LEN);
73
74    TEST_ASSERT(prk->len == mbedtls_md_get_size(md));
75    TEST_ASSERT(okm->len < OKM_LEN);
76
77    ret = mbedtls_hkdf_expand(md, prk->x, prk->len,
78                              info->x, info->len,
79                              output_okm, OKM_LEN);
80    TEST_ASSERT(ret == 0);
81    ASSERT_COMPARE(output_okm, okm->len, okm->x, okm->len);
82
83exit:
84    mbedtls_free(output_okm);
85}
86/* END_CASE */
87
88/* BEGIN_CASE */
89void test_hkdf_extract_ret(int hash_len, int ret)
90{
91    int output_ret;
92    unsigned char *salt = NULL;
93    unsigned char *ikm = NULL;
94    unsigned char *prk = NULL;
95    size_t salt_len, ikm_len;
96    struct mbedtls_md_info_t fake_md_info;
97
98    memset(&fake_md_info, 0, sizeof(fake_md_info));
99    fake_md_info.type = MBEDTLS_MD_NONE;
100    fake_md_info.size = hash_len;
101
102    ASSERT_ALLOC(prk, MBEDTLS_MD_MAX_SIZE);
103    salt_len = 0;
104    ikm_len = 0;
105
106    output_ret = mbedtls_hkdf_extract(&fake_md_info, salt, salt_len,
107                                      ikm, ikm_len, prk);
108    TEST_ASSERT(output_ret == ret);
109
110exit:
111    mbedtls_free(prk);
112}
113/* END_CASE */
114
115/* BEGIN_CASE */
116void test_hkdf_expand_ret(int hash_len, int prk_len, int okm_len, int ret)
117{
118    int output_ret;
119    unsigned char *info = NULL;
120    unsigned char *prk = NULL;
121    unsigned char *okm = NULL;
122    size_t info_len;
123    struct mbedtls_md_info_t fake_md_info;
124
125    memset(&fake_md_info, 0, sizeof(fake_md_info));
126    fake_md_info.type = MBEDTLS_MD_NONE;
127    fake_md_info.size = hash_len;
128
129    info_len = 0;
130
131    if (prk_len > 0) {
132        ASSERT_ALLOC(prk, prk_len);
133    }
134
135    if (okm_len > 0) {
136        ASSERT_ALLOC(okm, okm_len);
137    }
138
139    output_ret = mbedtls_hkdf_expand(&fake_md_info, prk, prk_len,
140                                     info, info_len, okm, okm_len);
141    TEST_ASSERT(output_ret == ret);
142
143exit:
144    mbedtls_free(prk);
145    mbedtls_free(okm);
146}
147/* END_CASE */
148