• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/* BEGIN_HEADER */
2#include "mbedtls/sha1.h"
3#include "mbedtls/sha256.h"
4#include "mbedtls/sha512.h"
5/* END_HEADER */
6
7/* BEGIN_CASE depends_on:MBEDTLS_SHA1_C */
8void sha1_valid_param()
9{
10    TEST_VALID_PARAM(mbedtls_sha1_free(NULL));
11}
12/* END_CASE */
13
14/* BEGIN_CASE depends_on:MBEDTLS_SHA1_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
15void sha1_invalid_param()
16{
17    mbedtls_sha1_context ctx;
18    unsigned char buf[64] = { 0 };
19    size_t const buflen = sizeof(buf);
20
21    TEST_INVALID_PARAM(mbedtls_sha1_init(NULL));
22
23    TEST_INVALID_PARAM(mbedtls_sha1_clone(NULL, &ctx));
24    TEST_INVALID_PARAM(mbedtls_sha1_clone(&ctx, NULL));
25
26    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
27                           mbedtls_sha1_starts_ret(NULL));
28
29    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
30                           mbedtls_sha1_update_ret(NULL, buf, buflen));
31    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
32                           mbedtls_sha1_update_ret(&ctx, NULL, buflen));
33
34    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
35                           mbedtls_sha1_finish_ret(NULL, buf));
36    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
37                           mbedtls_sha1_finish_ret(&ctx, NULL));
38
39    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
40                           mbedtls_internal_sha1_process(NULL, buf));
41    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
42                           mbedtls_internal_sha1_process(&ctx, NULL));
43
44    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
45                           mbedtls_sha1_ret(NULL, buflen, buf));
46    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
47                           mbedtls_sha1_ret(buf, buflen, NULL));
48
49exit:
50    return;
51}
52/* END_CASE */
53
54/* BEGIN_CASE depends_on:MBEDTLS_SHA1_C */
55void mbedtls_sha1(data_t *src_str, data_t *hash)
56{
57    unsigned char output[41];
58
59    memset(output, 0x00, 41);
60
61
62    TEST_ASSERT(mbedtls_sha1_ret(src_str->x, src_str->len, output) == 0);
63
64    TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x, 20, hash->len) == 0);
65}
66/* END_CASE */
67
68/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
69void sha256_valid_param()
70{
71    TEST_VALID_PARAM(mbedtls_sha256_free(NULL));
72}
73/* END_CASE */
74
75/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
76void sha256_invalid_param()
77{
78    mbedtls_sha256_context ctx;
79    unsigned char buf[64] = { 0 };
80    size_t const buflen = sizeof(buf);
81    int valid_type = 0;
82    int invalid_type = 42;
83
84    TEST_INVALID_PARAM(mbedtls_sha256_init(NULL));
85
86    TEST_INVALID_PARAM(mbedtls_sha256_clone(NULL, &ctx));
87    TEST_INVALID_PARAM(mbedtls_sha256_clone(&ctx, NULL));
88
89    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
90                           mbedtls_sha256_starts_ret(NULL, valid_type));
91    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
92                           mbedtls_sha256_starts_ret(&ctx, invalid_type));
93
94    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
95                           mbedtls_sha256_update_ret(NULL, buf, buflen));
96    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
97                           mbedtls_sha256_update_ret(&ctx, NULL, buflen));
98
99    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
100                           mbedtls_sha256_finish_ret(NULL, buf));
101    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
102                           mbedtls_sha256_finish_ret(&ctx, NULL));
103
104    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
105                           mbedtls_internal_sha256_process(NULL, buf));
106    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
107                           mbedtls_internal_sha256_process(&ctx, NULL));
108
109    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
110                           mbedtls_sha256_ret(NULL, buflen,
111                                              buf, valid_type));
112    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
113                           mbedtls_sha256_ret(buf, buflen,
114                                              NULL, valid_type));
115    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
116                           mbedtls_sha256_ret(buf, buflen,
117                                              buf, invalid_type));
118
119exit:
120    return;
121}
122/* END_CASE */
123
124/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
125void sha224(data_t *src_str, data_t *hash)
126{
127    unsigned char output[57];
128
129    memset(output, 0x00, 57);
130
131
132    TEST_ASSERT(mbedtls_sha256_ret(src_str->x, src_str->len, output, 1) == 0);
133
134    TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x, 28, hash->len) == 0);
135}
136/* END_CASE */
137
138/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
139void mbedtls_sha256(data_t *src_str, data_t *hash)
140{
141    unsigned char output[65];
142
143    memset(output, 0x00, 65);
144
145
146    TEST_ASSERT(mbedtls_sha256_ret(src_str->x, src_str->len, output, 0) == 0);
147
148    TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x, 32, hash->len) == 0);
149}
150/* END_CASE */
151
152/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C */
153void sha512_valid_param()
154{
155    TEST_VALID_PARAM(mbedtls_sha512_free(NULL));
156}
157/* END_CASE */
158
159/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
160void sha512_invalid_param()
161{
162    mbedtls_sha512_context ctx;
163    unsigned char buf[64] = { 0 };
164    size_t const buflen = sizeof(buf);
165    int valid_type = 0;
166    int invalid_type = 42;
167
168    TEST_INVALID_PARAM(mbedtls_sha512_init(NULL));
169
170    TEST_INVALID_PARAM(mbedtls_sha512_clone(NULL, &ctx));
171    TEST_INVALID_PARAM(mbedtls_sha512_clone(&ctx, NULL));
172
173    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
174                           mbedtls_sha512_starts_ret(NULL, valid_type));
175    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
176                           mbedtls_sha512_starts_ret(&ctx, invalid_type));
177
178    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
179                           mbedtls_sha512_update_ret(NULL, buf, buflen));
180    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
181                           mbedtls_sha512_update_ret(&ctx, NULL, buflen));
182
183    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
184                           mbedtls_sha512_finish_ret(NULL, buf));
185    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
186                           mbedtls_sha512_finish_ret(&ctx, NULL));
187
188    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
189                           mbedtls_internal_sha512_process(NULL, buf));
190    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
191                           mbedtls_internal_sha512_process(&ctx, NULL));
192
193    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
194                           mbedtls_sha512_ret(NULL, buflen,
195                                              buf, valid_type));
196    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
197                           mbedtls_sha512_ret(buf, buflen,
198                                              NULL, valid_type));
199    TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
200                           mbedtls_sha512_ret(buf, buflen,
201                                              buf, invalid_type));
202
203exit:
204    return;
205}
206/* END_CASE */
207
208/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C */
209void sha384(data_t *src_str, data_t *hash)
210{
211    unsigned char output[97];
212
213    memset(output, 0x00, 97);
214
215
216    TEST_ASSERT(mbedtls_sha512_ret(src_str->x, src_str->len, output, 1) == 0);
217
218    TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x, 48, hash->len) == 0);
219}
220/* END_CASE */
221
222/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C */
223void mbedtls_sha512(data_t *src_str, data_t *hash)
224{
225    unsigned char output[129];
226
227    memset(output, 0x00, 129);
228
229
230    TEST_ASSERT(mbedtls_sha512_ret(src_str->x, src_str->len, output, 0) == 0);
231
232    TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x, 64, hash->len) == 0);
233}
234/* END_CASE */
235
236/* BEGIN_CASE depends_on:MBEDTLS_SHA1_C:MBEDTLS_SELF_TEST */
237void sha1_selftest()
238{
239    TEST_ASSERT(mbedtls_sha1_self_test(1) == 0);
240}
241/* END_CASE */
242
243/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C:MBEDTLS_SELF_TEST */
244void sha256_selftest()
245{
246    TEST_ASSERT(mbedtls_sha256_self_test(1) == 0);
247}
248/* END_CASE */
249
250/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C:MBEDTLS_SELF_TEST */
251void sha512_selftest()
252{
253    TEST_ASSERT(mbedtls_sha512_self_test(1) == 0);
254}
255/* END_CASE */
256