FreeRDP
Loading...
Searching...
No Matches
TestCryptoHash.c
1
2#include <winpr/crt.h>
3#include <winpr/print.h>
4#include <winpr/crypto.h>
5#include <winpr/ssl.h>
6
7static const char TEST_MD5_DATA[] = "test";
8static const BYTE TEST_MD5_HASH[] =
9 "\x09\x8f\x6b\xcd\x46\x21\xd3\x73\xca\xde\x4e\x83\x26\x27\xb4\xf6";
10
11static BOOL test_crypto_hash_md5(void)
12{
13 BOOL result = FALSE;
14 BYTE hash[WINPR_MD5_DIGEST_LENGTH] = { 0 };
15 WINPR_DIGEST_CTX* ctx = NULL;
16
17 if (!(ctx = winpr_Digest_New()))
18 {
19 (void)fprintf(stderr, "%s: winpr_Digest_New failed\n", __func__);
20 return FALSE;
21 }
22 if (!winpr_Digest_Init(ctx, WINPR_MD_MD5))
23 {
24 (void)fprintf(stderr, "%s: winpr_Digest_Init failed\n", __func__);
25 goto out;
26 }
27 if (!winpr_Digest_Update(ctx, (const BYTE*)TEST_MD5_DATA,
28 strnlen(TEST_MD5_DATA, sizeof(TEST_MD5_DATA))))
29 {
30 (void)fprintf(stderr, "%s: winpr_Digest_Update failed\n", __func__);
31 goto out;
32 }
33 if (!winpr_Digest_Final(ctx, hash, sizeof(hash)))
34 {
35 (void)fprintf(stderr, "%s: winpr_Digest_Final failed\n", __func__);
36 goto out;
37 }
38 if (memcmp(hash, TEST_MD5_HASH, WINPR_MD5_DIGEST_LENGTH) != 0)
39 {
40 char* actual = NULL;
41 char* expected = NULL;
42
43 actual = winpr_BinToHexString(hash, WINPR_MD5_DIGEST_LENGTH, FALSE);
44 expected = winpr_BinToHexString(TEST_MD5_HASH, WINPR_MD5_DIGEST_LENGTH, FALSE);
45
46 (void)fprintf(stderr, "unexpected MD5 hash: Actual: %s Expected: %s\n", actual, expected);
47
48 free(actual);
49 free(expected);
50
51 goto out;
52 }
53
54 result = TRUE;
55out:
56 winpr_Digest_Free(ctx);
57 return result;
58}
59
60static const char TEST_MD4_DATA[] = "test";
61static const BYTE TEST_MD4_HASH[] =
62 "\xdb\x34\x6d\x69\x1d\x7a\xcc\x4d\xc2\x62\x5d\xb1\x9f\x9e\x3f\x52";
63
64static BOOL test_crypto_hash_md4(void)
65{
66 BOOL result = FALSE;
67 BYTE hash[WINPR_MD4_DIGEST_LENGTH] = { 0 };
68 WINPR_DIGEST_CTX* ctx = NULL;
69
70 if (!(ctx = winpr_Digest_New()))
71 {
72 (void)fprintf(stderr, "%s: winpr_Digest_New failed\n", __func__);
73 return FALSE;
74 }
75 if (!winpr_Digest_Init(ctx, WINPR_MD_MD4))
76 {
77 (void)fprintf(stderr, "%s: winpr_Digest_Init failed\n", __func__);
78 goto out;
79 }
80 if (!winpr_Digest_Update(ctx, (const BYTE*)TEST_MD4_DATA,
81 strnlen(TEST_MD4_DATA, sizeof(TEST_MD4_DATA))))
82 {
83 (void)fprintf(stderr, "%s: winpr_Digest_Update failed\n", __func__);
84 goto out;
85 }
86 if (!winpr_Digest_Final(ctx, hash, sizeof(hash)))
87 {
88 (void)fprintf(stderr, "%s: winpr_Digest_Final failed\n", __func__);
89 goto out;
90 }
91 if (memcmp(hash, TEST_MD4_HASH, WINPR_MD4_DIGEST_LENGTH) != 0)
92 {
93 char* actual = NULL;
94 char* expected = NULL;
95
96 actual = winpr_BinToHexString(hash, WINPR_MD4_DIGEST_LENGTH, FALSE);
97 expected = winpr_BinToHexString(TEST_MD4_HASH, WINPR_MD4_DIGEST_LENGTH, FALSE);
98
99 (void)fprintf(stderr, "unexpected MD4 hash: Actual: %s Expected: %s\n", actual, expected);
100
101 free(actual);
102 free(expected);
103
104 goto out;
105 }
106
107 result = TRUE;
108out:
109 winpr_Digest_Free(ctx);
110 return result;
111}
112
113static const char TEST_SHA1_DATA[] = "test";
114static const BYTE TEST_SHA1_HASH[] =
115 "\xa9\x4a\x8f\xe5\xcc\xb1\x9b\xa6\x1c\x4c\x08\x73\xd3\x91\xe9\x87\x98\x2f\xbb\xd3";
116
117static BOOL test_crypto_hash_sha1(void)
118{
119 BOOL result = FALSE;
120 BYTE hash[WINPR_SHA1_DIGEST_LENGTH] = { 0 };
121 WINPR_DIGEST_CTX* ctx = NULL;
122
123 if (!(ctx = winpr_Digest_New()))
124 {
125 (void)fprintf(stderr, "%s: winpr_Digest_New failed\n", __func__);
126 return FALSE;
127 }
128 if (!winpr_Digest_Init(ctx, WINPR_MD_SHA1))
129 {
130 (void)fprintf(stderr, "%s: winpr_Digest_Init failed\n", __func__);
131 goto out;
132 }
133 if (!winpr_Digest_Update(ctx, (const BYTE*)TEST_SHA1_DATA,
134 strnlen(TEST_SHA1_DATA, sizeof(TEST_SHA1_DATA))))
135 {
136 (void)fprintf(stderr, "%s: winpr_Digest_Update failed\n", __func__);
137 goto out;
138 }
139 if (!winpr_Digest_Final(ctx, hash, sizeof(hash)))
140 {
141 (void)fprintf(stderr, "%s: winpr_Digest_Final failed\n", __func__);
142 goto out;
143 }
144
145 if (memcmp(hash, TEST_SHA1_HASH, WINPR_MD5_DIGEST_LENGTH) != 0)
146 {
147 char* actual = NULL;
148 char* expected = NULL;
149
150 actual = winpr_BinToHexString(hash, WINPR_SHA1_DIGEST_LENGTH, FALSE);
151 expected = winpr_BinToHexString(TEST_SHA1_HASH, WINPR_SHA1_DIGEST_LENGTH, FALSE);
152
153 (void)fprintf(stderr, "unexpected SHA1 hash: Actual: %s Expected: %s\n", actual, expected);
154
155 free(actual);
156 free(expected);
157
158 goto out;
159 }
160
161 result = TRUE;
162out:
163 winpr_Digest_Free(ctx);
164 return result;
165}
166
167static const char TEST_HMAC_MD5_DATA[] = "Hi There";
168static const BYTE TEST_HMAC_MD5_KEY[] =
169 "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b";
170static const BYTE TEST_HMAC_MD5_HASH[] =
171 "\xb5\x79\x91\xa2\x20\x3d\x49\x2d\x73\xfb\x71\x43\xdf\xc5\x08\x28";
172
173static BOOL test_crypto_hash_hmac_md5(void)
174{
175 BYTE hash[WINPR_MD5_DIGEST_LENGTH] = { 0 };
176 WINPR_HMAC_CTX* ctx = NULL;
177 BOOL result = FALSE;
178
179 if (!(ctx = winpr_HMAC_New()))
180 {
181 (void)fprintf(stderr, "%s: winpr_HMAC_New failed\n", __func__);
182 return FALSE;
183 }
184
185 if (!winpr_HMAC_Init(ctx, WINPR_MD_MD5, TEST_HMAC_MD5_KEY, WINPR_MD5_DIGEST_LENGTH))
186 {
187 (void)fprintf(stderr, "%s: winpr_HMAC_Init failed\n", __func__);
188 goto out;
189 }
190 if (!winpr_HMAC_Update(ctx, (const BYTE*)TEST_HMAC_MD5_DATA,
191 strnlen(TEST_HMAC_MD5_DATA, sizeof(TEST_HMAC_MD5_DATA))))
192 {
193 (void)fprintf(stderr, "%s: winpr_HMAC_Update failed\n", __func__);
194 goto out;
195 }
196 if (!winpr_HMAC_Update(ctx, (const BYTE*)TEST_HMAC_MD5_DATA,
197 strnlen(TEST_HMAC_MD5_DATA, sizeof(TEST_HMAC_MD5_DATA))))
198 {
199 (void)fprintf(stderr, "%s: winpr_HMAC_Update failed\n", __func__);
200 goto out;
201 }
202 if (!winpr_HMAC_Final(ctx, hash, sizeof(hash)))
203 {
204 (void)fprintf(stderr, "%s: winpr_HMAC_Final failed\n", __func__);
205 goto out;
206 }
207
208 if (memcmp(hash, TEST_HMAC_MD5_HASH, WINPR_MD5_DIGEST_LENGTH) != 0)
209 {
210 char* actual = NULL;
211 char* expected = NULL;
212
213 actual = winpr_BinToHexString(hash, WINPR_MD5_DIGEST_LENGTH, FALSE);
214 expected = winpr_BinToHexString(TEST_HMAC_MD5_HASH, WINPR_MD5_DIGEST_LENGTH, FALSE);
215
216 (void)fprintf(stderr, "unexpected HMAC-MD5 hash: Actual: %s Expected: %s\n", actual,
217 expected);
218
219 free(actual);
220 free(expected);
221
222 goto out;
223 }
224
225 result = TRUE;
226out:
227 winpr_HMAC_Free(ctx);
228 return result;
229}
230
231static const char TEST_HMAC_SHA1_DATA[] = "Hi There";
232static const BYTE TEST_HMAC_SHA1_KEY[] =
233 "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b";
234static const BYTE TEST_HMAC_SHA1_HASH[] =
235 "\xab\x23\x08\x2d\xca\x0c\x75\xea\xca\x60\x09\xc0\xb8\x8c\x2d\xf4\xf4\xbf\x88\xee";
236
237static BOOL test_crypto_hash_hmac_sha1(void)
238{
239 BYTE hash[WINPR_SHA1_DIGEST_LENGTH] = { 0 };
240 WINPR_HMAC_CTX* ctx = NULL;
241 BOOL result = FALSE;
242
243 if (!(ctx = winpr_HMAC_New()))
244 {
245 (void)fprintf(stderr, "%s: winpr_HMAC_New failed\n", __func__);
246 return FALSE;
247 }
248
249 if (!winpr_HMAC_Init(ctx, WINPR_MD_SHA1, TEST_HMAC_SHA1_KEY, WINPR_SHA1_DIGEST_LENGTH))
250 {
251 (void)fprintf(stderr, "%s: winpr_HMAC_Init failed\n", __func__);
252 goto out;
253 }
254 if (!winpr_HMAC_Update(ctx, (const BYTE*)TEST_HMAC_SHA1_DATA,
255 strnlen(TEST_HMAC_SHA1_DATA, sizeof(TEST_HMAC_SHA1_DATA))))
256 {
257 (void)fprintf(stderr, "%s: winpr_HMAC_Update failed\n", __func__);
258 goto out;
259 }
260 if (!winpr_HMAC_Update(ctx, (const BYTE*)TEST_HMAC_SHA1_DATA,
261 strnlen(TEST_HMAC_SHA1_DATA, sizeof(TEST_HMAC_SHA1_DATA))))
262 {
263 (void)fprintf(stderr, "%s: winpr_HMAC_Update failed\n", __func__);
264 goto out;
265 }
266 if (!winpr_HMAC_Final(ctx, hash, sizeof(hash)))
267 {
268 (void)fprintf(stderr, "%s: winpr_HMAC_Final failed\n", __func__);
269 goto out;
270 }
271
272 if (memcmp(hash, TEST_HMAC_SHA1_HASH, WINPR_SHA1_DIGEST_LENGTH) != 0)
273 {
274 char* actual = NULL;
275 char* expected = NULL;
276
277 actual = winpr_BinToHexString(hash, WINPR_SHA1_DIGEST_LENGTH, FALSE);
278 expected = winpr_BinToHexString(TEST_HMAC_SHA1_HASH, WINPR_SHA1_DIGEST_LENGTH, FALSE);
279
280 (void)fprintf(stderr, "unexpected HMAC-SHA1 hash: Actual: %s Expected: %s\n", actual,
281 expected);
282
283 free(actual);
284 free(expected);
285
286 goto out;
287 }
288
289 result = TRUE;
290out:
291 winpr_HMAC_Free(ctx);
292 return result;
293}
294
295int TestCryptoHash(int argc, char* argv[])
296{
297 WINPR_UNUSED(argc);
298 WINPR_UNUSED(argv);
299
300 winpr_InitializeSSL(WINPR_SSL_INIT_DEFAULT);
301
302 if (!test_crypto_hash_md5())
303 return -1;
304
305 if (!test_crypto_hash_md4())
306 return -1;
307
308 if (!test_crypto_hash_sha1())
309 return -1;
310
311 if (!test_crypto_hash_hmac_md5())
312 return -1;
313
314 if (!test_crypto_hash_hmac_sha1())
315 return -1;
316
317 return 0;
318}