FreeRDP
TestCryptoHash.c
1 
2 #include <winpr/crt.h>
3 #include <winpr/print.h>
4 #include <winpr/crypto.h>
5 #include <winpr/ssl.h>
6 
7 static const char TEST_MD5_DATA[] = "test";
8 static const BYTE TEST_MD5_HASH[] =
9  "\x09\x8f\x6b\xcd\x46\x21\xd3\x73\xca\xde\x4e\x83\x26\x27\xb4\xf6";
10 
11 static 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;
55 out:
56  winpr_Digest_Free(ctx);
57  return result;
58 }
59 
60 static const char TEST_MD4_DATA[] = "test";
61 static const BYTE TEST_MD4_HASH[] =
62  "\xdb\x34\x6d\x69\x1d\x7a\xcc\x4d\xc2\x62\x5d\xb1\x9f\x9e\x3f\x52";
63 
64 static 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;
108 out:
109  winpr_Digest_Free(ctx);
110  return result;
111 }
112 
113 static const char TEST_SHA1_DATA[] = "test";
114 static 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 
117 static 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;
162 out:
163  winpr_Digest_Free(ctx);
164  return result;
165 }
166 
167 static const char TEST_HMAC_MD5_DATA[] = "Hi There";
168 static const BYTE TEST_HMAC_MD5_KEY[] =
169  "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b";
170 static const BYTE TEST_HMAC_MD5_HASH[] =
171  "\xb5\x79\x91\xa2\x20\x3d\x49\x2d\x73\xfb\x71\x43\xdf\xc5\x08\x28";
172 
173 static 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;
226 out:
227  winpr_HMAC_Free(ctx);
228  return result;
229 }
230 
231 static const char TEST_HMAC_SHA1_DATA[] = "Hi There";
232 static 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";
234 static 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 
237 static 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;
290 out:
291  winpr_HMAC_Free(ctx);
292  return result;
293 }
294 
295 int 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 }