ReactOS  0.4.15-dev-1049-g1062a29
bcrypt.c
Go to the documentation of this file.
1 /*
2  * Unit test for bcrypt functions
3  *
4  * Copyright 2014 Bruno Jesus
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20 
21 #include <stdio.h>
22 #include <ntstatus.h>
23 #define WIN32_NO_STATUS
24 #include <windows.h>
25 #include <bcrypt.h>
26 
27 #include "wine/test.h"
28 
29 static NTSTATUS (WINAPI *pBCryptHash)( BCRYPT_ALG_HANDLE algorithm, UCHAR *secret, ULONG secretlen,
30  UCHAR *input, ULONG inputlen, UCHAR *output, ULONG outputlen );
31 
32 static void test_BCryptGenRandom(void)
33 {
34  NTSTATUS ret;
35  UCHAR buffer[256];
36 
37  ret = BCryptGenRandom(NULL, NULL, 0, 0);
38  ok(ret == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got 0x%x\n", ret);
39  ret = BCryptGenRandom(NULL, buffer, 0, 0);
40  ok(ret == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got 0x%x\n", ret);
41  ret = BCryptGenRandom(NULL, buffer, sizeof(buffer), 0);
42  ok(ret == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got 0x%x\n", ret);
43  ret = BCryptGenRandom(NULL, buffer, sizeof(buffer), BCRYPT_USE_SYSTEM_PREFERRED_RNG);
44  ok(ret == STATUS_SUCCESS, "Expected success, got 0x%x\n", ret);
45  ret = BCryptGenRandom(NULL, buffer, sizeof(buffer),
46  BCRYPT_USE_SYSTEM_PREFERRED_RNG|BCRYPT_RNG_USE_ENTROPY_IN_BUFFER);
47  ok(ret == STATUS_SUCCESS, "Expected success, got 0x%x\n", ret);
48  ret = BCryptGenRandom(NULL, NULL, sizeof(buffer), BCRYPT_USE_SYSTEM_PREFERRED_RNG);
49  ok(ret == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got 0x%x\n", ret);
50 
51  /* Zero sized buffer should work too */
52  ret = BCryptGenRandom(NULL, buffer, 0, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
53  ok(ret == STATUS_SUCCESS, "Expected success, got 0x%x\n", ret);
54 
55  /* Test random number generation - It's impossible for a sane RNG to return 8 zeros */
56  memset(buffer, 0, 16);
57  ret = BCryptGenRandom(NULL, buffer, 8, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
58  ok(ret == STATUS_SUCCESS, "Expected success, got 0x%x\n", ret);
59  ok(memcmp(buffer, buffer + 8, 8), "Expected a random number, got 0\n");
60 }
61 
62 static void test_BCryptGetFipsAlgorithmMode(void)
63 {
64  static const WCHAR policyKeyVistaW[] = {
65  'S','y','s','t','e','m','\\',
66  'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
67  'C','o','n','t','r','o','l','\\',
68  'L','s','a','\\',
69  'F','I','P','S','A','l','g','o','r','i','t','h','m','P','o','l','i','c','y',0};
70  static const WCHAR policyValueVistaW[] = {'E','n','a','b','l','e','d',0};
71  static const WCHAR policyKeyXPW[] = {
72  'S','y','s','t','e','m','\\',
73  'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
74  'C','o','n','t','r','o','l','\\',
75  'L','s','a',0};
76  static const WCHAR policyValueXPW[] = {
77  'F','I','P','S','A','l','g','o','r','i','t','h','m','P','o','l','i','c','y',0};
78  BOOLEAN expected;
79  BOOLEAN enabled;
80  DWORD value, count[2] = {sizeof(value), sizeof(value)};
81  NTSTATUS ret;
82 
83  if (!RegGetValueW(HKEY_LOCAL_MACHINE, policyKeyVistaW, policyValueVistaW,
84  RRF_RT_REG_DWORD, NULL, &value, &count[0]))
85  {
86  expected = !!value;
87  }
88  else if (!RegGetValueW(HKEY_LOCAL_MACHINE, policyKeyXPW, policyValueXPW,
89  RRF_RT_REG_DWORD, NULL, &value, &count[1]))
90  {
91  expected = !!value;
92  }
93  else
94  {
95  expected = FALSE;
96 todo_wine
97  ok(0, "Neither XP or Vista key is present\n");
98  }
99 
100  ret = BCryptGetFipsAlgorithmMode(&enabled);
101  ok(ret == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got 0x%x\n", ret);
102  ok(enabled == expected, "expected result %d, got %d\n", expected, enabled);
103 
104  ret = BCryptGetFipsAlgorithmMode(NULL);
105  ok(ret == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got 0x%x\n", ret);
106 }
107 
108 static void format_hash(const UCHAR *bytes, ULONG size, char *buf)
109 {
110  ULONG i;
111  buf[0] = '\0';
112  for (i = 0; i < size; i++)
113  {
114  sprintf(buf + i * 2, "%02x", bytes[i]);
115  }
116  return;
117 }
118 
119 static int strcmp_wa(const WCHAR *strw, const char *stra)
120 {
121  WCHAR buf[512];
122  MultiByteToWideChar(CP_ACP, 0, stra, -1, buf, sizeof(buf)/sizeof(buf[0]));
123  return lstrcmpW(strw, buf);
124 }
125 
126 #define test_hash_length(a,b) _test_hash_length(__LINE__,a,b)
127 static void _test_hash_length(unsigned line, void *handle, ULONG exlen)
128 {
129  ULONG len = 0xdeadbeef, size = 0xdeadbeef;
130  NTSTATUS status;
131 
132  status = BCryptGetProperty(handle, BCRYPT_HASH_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
133  ok_(__FILE__,line)(status == STATUS_SUCCESS, "BCryptGetProperty failed: %08x\n", status);
134  ok_(__FILE__,line)(size == sizeof(len), "got %u\n", size);
135  ok_(__FILE__,line)(len == exlen, "len = %u, expected %u\n", len, exlen);
136 }
137 
138 #define test_alg_name(a,b) _test_alg_name(__LINE__,a,b)
139 static void _test_alg_name(unsigned line, void *handle, const char *exname)
140 {
141  ULONG size = 0xdeadbeef;
142  UCHAR buf[256];
143  const WCHAR *name = (const WCHAR*)buf;
144  NTSTATUS status;
145 
146  status = BCryptGetProperty(handle, BCRYPT_ALGORITHM_NAME, buf, sizeof(buf), &size, 0);
147  ok_(__FILE__,line)(status == STATUS_SUCCESS, "BCryptGetProperty failed: %08x\n", status);
148  ok_(__FILE__,line)(size == (strlen(exname)+1)*sizeof(WCHAR), "got %u\n", size);
149  ok_(__FILE__,line)(!strcmp_wa(name, exname), "alg name = %s, expected %s\n", wine_dbgstr_w(name), exname);
150 }
151 
152 static void test_sha1(void)
153 {
154  static const char expected[] = "961fa64958818f767707072755d7018dcd278e94";
155  static const char expected_hmac[] = "2472cf65d0e090618d769d3e46f0d9446cf212da";
156  BCRYPT_ALG_HANDLE alg;
157  BCRYPT_HASH_HANDLE hash;
158  UCHAR buf[512], buf_hmac[1024], sha1[20], sha1_hmac[20];
159  ULONG size, len;
160  char str[41];
161  NTSTATUS ret;
162 
163  alg = NULL;
164  ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA1_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
165  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
166  ok(alg != NULL, "alg not set\n");
167 
168  len = size = 0xdeadbeef;
169  ret = BCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
170  ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
171 
172  len = size = 0xdeadbeef;
173  ret = BCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
174  ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
175 
176  len = size = 0xdeadbeef;
177  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
178  ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
179 
180  len = size = 0xdeadbeef;
181  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
182  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
183  ok(size == sizeof(len), "got %u\n", size);
184 
185  len = size = 0xdeadbeef;
186  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
187  ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
188  ok(len == 0xdeadbeef, "got %u\n", len);
189  ok(size == sizeof(len), "got %u\n", size);
190 
191  len = size = 0xdeadbeef;
192  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
193  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
194  ok(len != 0xdeadbeef, "len not set\n");
195  ok(size == sizeof(len), "got %u\n", size);
196 
197  test_hash_length(alg, 20);
198  test_alg_name(alg, "SHA1");
199 
200  hash = NULL;
201  len = sizeof(buf);
202  ret = BCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
203  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
204  ok(hash != NULL, "hash not set\n");
205 
206  ret = BCryptHashData(hash, NULL, 0, 0);
207  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
208 
209  ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
210  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
211 
212  test_hash_length(hash, 20);
213  test_alg_name(hash, "SHA1");
214 
215  memset(sha1, 0, sizeof(sha1));
216  ret = BCryptFinishHash(hash, sha1, sizeof(sha1), 0);
217  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
218  format_hash( sha1, sizeof(sha1), str );
219  ok(!strcmp(str, expected), "got %s\n", str);
220 
221  ret = BCryptDestroyHash(hash);
222  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
223 
224  ret = BCryptCloseAlgorithmProvider(alg, 0);
225  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
226 
227  alg = NULL;
228  ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA1_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
229  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
230  ok(alg != NULL, "alg not set\n");
231 
232  hash = NULL;
233  len = sizeof(buf_hmac);
234  ret = BCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
235  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
236  ok(hash != NULL, "hash not set\n");
237 
238  ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
239  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
240 
241  test_hash_length(hash, 20);
242  test_alg_name(hash, "SHA1");
243 
244  memset(sha1_hmac, 0, sizeof(sha1_hmac));
245  ret = BCryptFinishHash(hash, sha1_hmac, sizeof(sha1_hmac), 0);
246  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
247  format_hash( sha1_hmac, sizeof(sha1_hmac), str );
248  ok(!strcmp(str, expected_hmac), "got %s\n", str);
249 
250  ret = BCryptDestroyHash(hash);
251  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
252 
253  ret = BCryptCloseAlgorithmProvider(alg, 0);
254  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
255 }
256 
257 static void test_sha256(void)
258 {
259  static const char expected[] =
260  "ceb73749c899693706ede1e30c9929b3fd5dd926163831c2fb8bd41e6efb1126";
261  static const char expected_hmac[] =
262  "34c1aa473a4468a91d06e7cdbc75bc4f93b830ccfc2a47ffd74e8e6ed29e4c72";
263  BCRYPT_ALG_HANDLE alg;
264  BCRYPT_HASH_HANDLE hash;
265  UCHAR buf[512], buf_hmac[1024], sha256[32], sha256_hmac[32];
266  ULONG size, len;
267  char str[65];
268  NTSTATUS ret;
269 
270  alg = NULL;
271  ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA256_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
272  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
273  ok(alg != NULL, "alg not set\n");
274 
275  len = size = 0xdeadbeef;
276  ret = BCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
277  ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
278 
279  len = size = 0xdeadbeef;
280  ret = BCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
281  ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
282 
283  len = size = 0xdeadbeef;
284  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
285  ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
286 
287  len = size = 0xdeadbeef;
288  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
289  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
290  ok(size == sizeof(len), "got %u\n", size);
291 
292  len = size = 0xdeadbeef;
293  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
294  ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
295  ok(len == 0xdeadbeef, "got %u\n", len);
296  ok(size == sizeof(len), "got %u\n", size);
297 
298  len = size = 0xdeadbeef;
299  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
300  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
301  ok(len != 0xdeadbeef, "len not set\n");
302  ok(size == sizeof(len), "got %u\n", size);
303 
304  test_hash_length(alg, 32);
305  test_alg_name(alg, "SHA256");
306 
307  hash = NULL;
308  len = sizeof(buf);
309  ret = BCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
310  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
311  ok(hash != NULL, "hash not set\n");
312 
313  ret = BCryptHashData(hash, NULL, 0, 0);
314  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
315 
316  ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
317  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
318 
319  test_hash_length(hash, 32);
320  test_alg_name(hash, "SHA256");
321 
322  memset(sha256, 0, sizeof(sha256));
323  ret = BCryptFinishHash(hash, sha256, sizeof(sha256), 0);
324  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
325  format_hash( sha256, sizeof(sha256), str );
326  ok(!strcmp(str, expected), "got %s\n", str);
327 
328  ret = BCryptDestroyHash(hash);
329  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
330 
331  ret = BCryptCloseAlgorithmProvider(alg, 0);
332  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
333 
334  alg = NULL;
335  ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA256_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
336  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
337  ok(alg != NULL, "alg not set\n");
338 
339  hash = NULL;
340  len = sizeof(buf_hmac);
341  ret = BCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
342  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
343  ok(hash != NULL, "hash not set\n");
344 
345  ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
346  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
347 
348  test_hash_length(hash, 32);
349  test_alg_name(hash, "SHA256");
350 
351  memset(sha256_hmac, 0, sizeof(sha256_hmac));
352  ret = BCryptFinishHash(hash, sha256_hmac, sizeof(sha256_hmac), 0);
353  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
354  format_hash( sha256_hmac, sizeof(sha256_hmac), str );
355  ok(!strcmp(str, expected_hmac), "got %s\n", str);
356 
357  ret = BCryptDestroyHash(hash);
358  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
359 
360  ret = BCryptCloseAlgorithmProvider(alg, 0);
361  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
362 }
363 
364 static void test_sha384(void)
365 {
366  static const char expected[] =
367  "62b21e90c9022b101671ba1f808f8631a8149f0f12904055839a35c1ca78ae5363eed1e743a692d70e0504b0cfd12ef9";
368  static const char expected_hmac[] =
369  "4b3e6d6ff2da121790ab7e7b9247583e3a7eed2db5bd4dabc680303b1608f37dfdc836d96a704c03283bc05b4f6c5eb8";
370  BCRYPT_ALG_HANDLE alg;
371  BCRYPT_HASH_HANDLE hash;
372  UCHAR buf[512], buf_hmac[1024], sha384[48], sha384_hmac[48];
373  ULONG size, len;
374  char str[97];
375  NTSTATUS ret;
376 
377  alg = NULL;
378  ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA384_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
379  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
380  ok(alg != NULL, "alg not set\n");
381 
382  len = size = 0xdeadbeef;
383  ret = BCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
384  ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
385 
386  len = size = 0xdeadbeef;
387  ret = BCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
388  ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
389 
390  len = size = 0xdeadbeef;
391  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
392  ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
393 
394  len = size = 0xdeadbeef;
395  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
396  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
397  ok(size == sizeof(len), "got %u\n", size);
398 
399  len = size = 0xdeadbeef;
400  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
401  ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
402  ok(len == 0xdeadbeef, "got %u\n", len);
403  ok(size == sizeof(len), "got %u\n", size);
404 
405  len = size = 0xdeadbeef;
406  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
407  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
408  ok(len != 0xdeadbeef, "len not set\n");
409  ok(size == sizeof(len), "got %u\n", size);
410 
411  test_hash_length(alg, 48);
412  test_alg_name(alg, "SHA384");
413 
414  hash = NULL;
415  len = sizeof(buf);
416  ret = BCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
417  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
418  ok(hash != NULL, "hash not set\n");
419 
420  ret = BCryptHashData(hash, NULL, 0, 0);
421  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
422 
423  ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
424  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
425 
426  test_hash_length(hash, 48);
427  test_alg_name(hash, "SHA384");
428 
429  memset(sha384, 0, sizeof(sha384));
430  ret = BCryptFinishHash(hash, sha384, sizeof(sha384), 0);
431  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
432  format_hash( sha384, sizeof(sha384), str );
433  ok(!strcmp(str, expected), "got %s\n", str);
434 
435  ret = BCryptDestroyHash(hash);
436  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
437 
438  ret = BCryptCloseAlgorithmProvider(alg, 0);
439  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
440 
441  alg = NULL;
442  ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA384_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
443  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
444  ok(alg != NULL, "alg not set\n");
445 
446  hash = NULL;
447  len = sizeof(buf_hmac);
448  ret = BCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
449  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
450  ok(hash != NULL, "hash not set\n");
451 
452  ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
453  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
454 
455  test_hash_length(hash, 48);
456  test_alg_name(hash, "SHA384");
457 
458  memset(sha384_hmac, 0, sizeof(sha384_hmac));
459  ret = BCryptFinishHash(hash, sha384_hmac, sizeof(sha384_hmac), 0);
460  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
461  format_hash( sha384_hmac, sizeof(sha384_hmac), str );
462  ok(!strcmp(str, expected_hmac), "got %s\n", str);
463 
464  ret = BCryptDestroyHash(hash);
465  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
466 
467  ret = BCryptCloseAlgorithmProvider(alg, 0);
468  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
469 }
470 
471 static void test_sha512(void)
472 {
473  static const char expected[] =
474  "d55ced17163bf5386f2cd9ff21d6fd7fe576a915065c24744d09cfae4ec84ee1e"
475  "f6ef11bfbc5acce3639bab725b50a1fe2c204f8c820d6d7db0df0ecbc49c5ca";
476  static const char expected_hmac[] =
477  "415fb6b10018ca03b38a1b1399c42ac0be5e8aceddb9a73103f5e543bf2d888f2"
478  "eecf91373941f9315dd730a77937fa92444450fbece86f409d9cb5ec48c6513";
479  BCRYPT_ALG_HANDLE alg;
480  BCRYPT_HASH_HANDLE hash;
481  UCHAR buf[512], buf_hmac[1024], sha512[64], sha512_hmac[64];
482  ULONG size, len;
483  char str[129];
484  NTSTATUS ret;
485 
486  alg = NULL;
487  ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA512_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
488  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
489  ok(alg != NULL, "alg not set\n");
490 
491  len = size = 0xdeadbeef;
492  ret = BCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
493  ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
494 
495  len = size = 0xdeadbeef;
496  ret = BCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
497  ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
498 
499  len = size = 0xdeadbeef;
500  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
501  ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
502 
503  len = size = 0xdeadbeef;
504  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
505  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
506  ok(size == sizeof(len), "got %u\n", size);
507 
508  len = size = 0xdeadbeef;
509  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
510  ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
511  ok(len == 0xdeadbeef, "got %u\n", len);
512  ok(size == sizeof(len), "got %u\n", size);
513 
514  len = size = 0xdeadbeef;
515  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
516  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
517  ok(len != 0xdeadbeef, "len not set\n");
518  ok(size == sizeof(len), "got %u\n", size);
519 
520  test_hash_length(alg, 64);
521  test_alg_name(alg, "SHA512");
522 
523  hash = NULL;
524  len = sizeof(buf);
525  ret = BCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
526  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
527  ok(hash != NULL, "hash not set\n");
528 
529  ret = BCryptHashData(hash, NULL, 0, 0);
530  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
531 
532  ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
533  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
534 
535  test_hash_length(hash, 64);
536  test_alg_name(hash, "SHA512");
537 
538  memset(sha512, 0, sizeof(sha512));
539  ret = BCryptFinishHash(hash, sha512, sizeof(sha512), 0);
540  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
541  format_hash( sha512, sizeof(sha512), str );
542  ok(!strcmp(str, expected), "got %s\n", str);
543 
544  ret = BCryptDestroyHash(hash);
545  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
546 
547  ret = BCryptCloseAlgorithmProvider(alg, 0);
548  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
549 
550  alg = NULL;
551  ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA512_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
552  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
553  ok(alg != NULL, "alg not set\n");
554 
555  hash = NULL;
556  len = sizeof(buf_hmac);
557  ret = BCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
558  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
559  ok(hash != NULL, "hash not set\n");
560 
561  ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
562  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
563 
564  test_hash_length(hash, 64);
565  test_alg_name(hash, "SHA512");
566 
567  memset(sha512_hmac, 0, sizeof(sha512_hmac));
568  ret = BCryptFinishHash(hash, sha512_hmac, sizeof(sha512_hmac), 0);
569  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
570  format_hash( sha512_hmac, sizeof(sha512_hmac), str );
571  ok(!strcmp(str, expected_hmac), "got %s\n", str);
572 
573  ret = BCryptDestroyHash(hash);
574  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
575 
576  ret = BCryptCloseAlgorithmProvider(alg, 0);
577  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
578 
579 }
580 
581 static void test_md5(void)
582 {
583  static const char expected[] =
584  "e2a3e68d23ce348b8f68b3079de3d4c9";
585  static const char expected_hmac[] =
586  "7bda029b93fa8d817fcc9e13d6bdf092";
587  BCRYPT_ALG_HANDLE alg;
588  BCRYPT_HASH_HANDLE hash;
589  UCHAR buf[512], buf_hmac[1024], md5[16], md5_hmac[16];
590  ULONG size, len;
591  char str[65];
592  NTSTATUS ret;
593 
594  alg = NULL;
595  ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
596  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
597  ok(alg != NULL, "alg not set\n");
598 
599  len = size = 0xdeadbeef;
600  ret = BCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
601  ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
602 
603  len = size = 0xdeadbeef;
604  ret = BCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
605  ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
606 
607  len = size = 0xdeadbeef;
608  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
609  ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
610 
611  len = size = 0xdeadbeef;
612  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
613  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
614  ok(size == sizeof(len), "got %u\n", size);
615 
616  len = size = 0xdeadbeef;
617  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
618  ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
619  ok(len == 0xdeadbeef, "got %u\n", len);
620  ok(size == sizeof(len), "got %u\n", size);
621 
622  len = size = 0xdeadbeef;
623  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
624  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
625  ok(len != 0xdeadbeef, "len not set\n");
626  ok(size == sizeof(len), "got %u\n", size);
627 
628  test_hash_length(alg, 16);
629  test_alg_name(alg, "MD5");
630 
631  hash = NULL;
632  len = sizeof(buf);
633  ret = BCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
634  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
635  ok(hash != NULL, "hash not set\n");
636 
637  ret = BCryptHashData(hash, NULL, 0, 0);
638  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
639 
640  ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
641  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
642 
643  test_hash_length(hash, 16);
644  test_alg_name(hash, "MD5");
645 
646  memset(md5, 0, sizeof(md5));
647  ret = BCryptFinishHash(hash, md5, sizeof(md5), 0);
648  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
649  format_hash( md5, sizeof(md5), str );
650  ok(!strcmp(str, expected), "got %s\n", str);
651 
652  ret = BCryptDestroyHash(hash);
653  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
654 
655  ret = BCryptCloseAlgorithmProvider(alg, 0);
656  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
657 
658  alg = NULL;
659  ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
660  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
661  ok(alg != NULL, "alg not set\n");
662 
663  hash = NULL;
664  len = sizeof(buf_hmac);
665  ret = BCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
666  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
667  ok(hash != NULL, "hash not set\n");
668 
669  ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
670  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
671 
672  test_hash_length(hash, 16);
673  test_alg_name(hash, "MD5");
674 
675  memset(md5_hmac, 0, sizeof(md5_hmac));
676  ret = BCryptFinishHash(hash, md5_hmac, sizeof(md5_hmac), 0);
677  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
678  format_hash( md5_hmac, sizeof(md5_hmac), str );
679  ok(!strcmp(str, expected_hmac), "got %s\n", str);
680 
681  ret = BCryptDestroyHash(hash);
682  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
683 
684  ret = BCryptCloseAlgorithmProvider(alg, 0);
685  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
686 }
687 
688 static void test_BcryptHash(void)
689 {
690  static const char expected[] =
691  "e2a3e68d23ce348b8f68b3079de3d4c9";
692  static const char expected_hmac[] =
693  "7bda029b93fa8d817fcc9e13d6bdf092";
694  BCRYPT_ALG_HANDLE alg;
695  UCHAR md5[16], md5_hmac[16];
696  char str[65];
697  NTSTATUS ret;
698 
699  alg = NULL;
700  ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
701  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
702  ok(alg != NULL, "alg not set\n");
703 
704  test_hash_length(alg, 16);
705  test_alg_name(alg, "MD5");
706 
707  memset(md5, 0, sizeof(md5));
708  ret = pBCryptHash(alg, NULL, 0, (UCHAR *)"test", sizeof("test"), md5, sizeof(md5));
709  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
710  format_hash( md5, sizeof(md5), str );
711  ok(!strcmp(str, expected), "got %s\n", str);
712 
713  ret = BCryptCloseAlgorithmProvider(alg, 0);
714  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
715 
716  alg = NULL;
717  memset(md5_hmac, 0, sizeof(md5_hmac));
718  ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
719  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
720  ok(alg != NULL, "alg not set\n");
721 
722  ret = pBCryptHash(alg, (UCHAR *)"key", sizeof("key"), (UCHAR *)"test", sizeof("test"), md5_hmac, sizeof(md5_hmac));
723  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
724  format_hash( md5_hmac, sizeof(md5_hmac), str );
725  ok(!strcmp(str, expected_hmac), "got %s\n", str);
726 
727  ret = BCryptCloseAlgorithmProvider(alg, 0);
728  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
729 }
730 
731 static void test_rng(void)
732 {
733  BCRYPT_ALG_HANDLE alg;
734  ULONG size, len;
735  UCHAR buf[16];
736  NTSTATUS ret;
737 
738  alg = NULL;
739  ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_RNG_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
740  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
741  ok(alg != NULL, "alg not set\n");
742 
743  len = size = 0xdeadbeef;
744  ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
745  ok(ret == STATUS_NOT_SUPPORTED, "got %08x\n", ret);
746 
747  test_alg_name(alg, "RNG");
748 
749  memset(buf, 0, 16);
750  ret = BCryptGenRandom(alg, buf, 8, 0);
751  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
752  ok(memcmp(buf, buf + 8, 8), "got zeroes\n");
753 
754  ret = BCryptCloseAlgorithmProvider(alg, 0);
755  ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
756 }
757 
758 
759 START_TEST(bcrypt)
760 {
761  HMODULE module;
762 
763  module = GetModuleHandleA( "bcrypt.dll" );
764 
765  test_BCryptGenRandom();
766  test_BCryptGetFipsAlgorithmMode();
767  test_sha1();
768  test_sha256();
769  test_sha384();
770  test_sha512();
771  test_md5();
772  test_rng();
773 
774  pBCryptHash = (void *)GetProcAddress( module, "BCryptHash" );
775 
776  if (pBCryptHash)
777  test_BcryptHash();
778  else
779  win_skip("BCryptHash is not available\n");
780 }
RegGetValueW
LSTATUS WINAPI RegGetValueW(HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData)
Definition: reg.c:1965
outputlen
static UCHAR ULONG UCHAR ULONG UCHAR ULONG outputlen
Definition: bcrypt.c:29
MS_PRIMITIVE_PROVIDER
#define MS_PRIMITIVE_PROVIDER
Definition: bcrypt.h:69
output
static UCHAR ULONG UCHAR ULONG UCHAR * output
Definition: bcrypt.c:29
BCryptGenRandom
NTSTATUS WINAPI BCryptGenRandom(BCRYPT_ALG_HANDLE handle, UCHAR *buffer, ULONG count, ULONG flags)
Definition: bcrypt_main.c:291
module
HMODULE module
Definition: main.cpp:47
BCRYPT_USE_SYSTEM_PREFERRED_RNG
#define BCRYPT_USE_SYSTEM_PREFERRED_RNG
Definition: bcrypt.h:171
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
test_alg_name
#define test_alg_name(a, b)
Definition: bcrypt.c:138
BCRYPT_OBJECT_LENGTH
#define BCRYPT_OBJECT_LENGTH
Definition: bcrypt.h:56
strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
sha512
#define sha512
Definition: compat-1.3.h:2284
wine_dbgstr_w
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: atltest.h:87
CP_ACP
#define CP_ACP
Definition: compat.h:109
lstrcmpW
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
BCRYPT_MD5_ALGORITHM
#define BCRYPT_MD5_ALGORITHM
Definition: bcrypt.h:72
test_sha256
static void test_sha256(void)
Definition: bcrypt.c:257
BCryptCloseAlgorithmProvider
NTSTATUS WINAPI BCryptCloseAlgorithmProvider(BCRYPT_ALG_HANDLE handle, DWORD flags)
Definition: bcrypt_main.c:374
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
input
static UCHAR ULONG UCHAR * input
Definition: bcrypt.c:29
BCryptHashData
NTSTATUS WINAPI BCryptHashData(BCRYPT_HASH_HANDLE handle, UCHAR *input, ULONG size, ULONG flags)
Definition: bcrypt_main.c:1052
_test_alg_name
static void _test_alg_name(unsigned line, void *handle, const char *exname)
Definition: bcrypt.c:139
buffer
GLuint buffer
Definition: glext.h:5915
BCRYPT_SHA256_ALGORITHM
#define BCRYPT_SHA256_ALGORITHM
Definition: bcrypt.h:75
BCryptFinishHash
NTSTATUS WINAPI BCryptFinishHash(BCRYPT_HASH_HANDLE handle, UCHAR *output, ULONG size, ULONG flags)
Definition: bcrypt_main.c:1071
enabled
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition: glext.h:7750
STATUS_INVALID_HANDLE
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
STATUS_BUFFER_TOO_SMALL
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
test_sha384
static void test_sha384(void)
Definition: bcrypt.c:364
BCRYPT_ALG_HANDLE_HMAC_FLAG
#define BCRYPT_ALG_HANDLE_HMAC_FLAG
Definition: bcrypt.h:172
strcmp_wa
static int strcmp_wa(const WCHAR *strw, const char *stra)
Definition: bcrypt.c:119
sprintf
#define sprintf(buf, format,...)
Definition: sprintf.c:55
_test_hash_length
static void _test_hash_length(unsigned line, void *handle, ULONG exlen)
Definition: bcrypt.c:127
secretlen
static UCHAR ULONG secretlen
Definition: bcrypt.c:29
BCRYPT_ALGORITHM_NAME
#define BCRYPT_ALGORITHM_NAME
Definition: bcrypt.h:43
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
bytes
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
BCryptOpenAlgorithmProvider
NTSTATUS WINAPI BCryptOpenAlgorithmProvider(BCRYPT_ALG_HANDLE *handle, LPCWSTR id, LPCWSTR implementation, DWORD flags)
Definition: bcrypt_main.c:332
FALSE
#define FALSE
Definition: types.h:117
test_hash_length
#define test_hash_length(a, b)
Definition: bcrypt.c:126
hash
int hash
Definition: main.c:58
test_BCryptGenRandom
static void test_BCryptGenRandom(void)
Definition: bcrypt.c:32
str
const WCHAR * str
Definition: rpc_transport.c:2472
test_BcryptHash
static void test_BcryptHash(void)
Definition: bcrypt.c:688
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
NULL
smooth NULL
Definition: ftsmooth.c:416
line
Definition: parser.c:48
test_sha512
static void test_sha512(void)
Definition: bcrypt.c:471
size
GLsizeiptr size
Definition: glext.h:5919
BCryptGetFipsAlgorithmMode
NTSTATUS WINAPI BCryptGetFipsAlgorithmMode(BOOLEAN *enabled)
Definition: bcrypt_main.c:385
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
sha1
#define sha1
Definition: compat-1.3.h:2262
test_sha1
static void test_sha1(void)
Definition: bcrypt.c:152
WINAPI
#define WINAPI
Definition: msvc.h:6
sha256
#define sha256
Definition: compat-1.3.h:2273
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
BCRYPT_SHA384_ALGORITHM
#define BCRYPT_SHA384_ALGORITHM
Definition: bcrypt.h:76
UCHAR
unsigned char UCHAR
Definition: xmlstorage.h:181
secret
static UCHAR * secret
Definition: bcrypt.c:29
ret
int ret
Definition: wcstombs-tests.c:31
todo_wine
#define todo_wine
Definition: test.h:162
len
GLenum GLsizei len
Definition: glext.h:6722
GetModuleHandleA
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
format_hash
static void format_hash(const UCHAR *bytes, ULONG size, char *buf)
Definition: bcrypt.c:108
test_rng
static void test_rng(void)
Definition: bcrypt.c:731
value
GLsizei const GLfloat * value
Definition: glext.h:6069
START_TEST
START_TEST(bcrypt)
Definition: bcrypt.c:759
BCRYPT_SHA512_ALGORITHM
#define BCRYPT_SHA512_ALGORITHM
Definition: bcrypt.h:77
test_md5
static void test_md5(void)
Definition: bcrypt.c:581
ok
#define ok(value,...)
Definition: atltest.h:57
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
BCryptGetProperty
NTSTATUS WINAPI BCryptGetProperty(BCRYPT_HANDLE handle, LPCWSTR prop, UCHAR *buffer, ULONG count, ULONG *res, ULONG flags)
Definition: bcrypt_main.c:972
name
Definition: name.c:38
inputlen
static UCHAR ULONG UCHAR ULONG inputlen
Definition: bcrypt.c:29
STATUS_NOT_SUPPORTED
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:423
ULONG
unsigned int ULONG
Definition: retypes.h:1
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
md5
#define md5
Definition: compat-1.3.h:2035
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:501
test_BCryptGetFipsAlgorithmMode
static void test_BCryptGetFipsAlgorithmMode(void)
Definition: bcrypt.c:62
BCRYPT_RNG_USE_ENTROPY_IN_BUFFER
#define BCRYPT_RNG_USE_ENTROPY_IN_BUFFER
Definition: bcrypt.h:170
BCRYPT_RNG_ALGORITHM
#define BCRYPT_RNG_ALGORITHM
Definition: bcrypt.h:73
sha384
static const WCHAR sha384[]
Definition: oid.c:1221
STATUS_SUCCESS
return STATUS_SUCCESS
Definition: btrfs.c:3014
hash
Definition: _hash_fun.h:40
BCRYPT_SHA1_ALGORITHM
#define BCRYPT_SHA1_ALGORITHM
Definition: bcrypt.h:74
memset
#define memset(x, y, z)
Definition: compat.h:39
status
static SERVICE_STATUS status
Definition: service.c:31
strw
static const char * strw(LPCWSTR x)
Definition: actctx.c:49
RRF_RT_REG_DWORD
#define RRF_RT_REG_DWORD
Definition: driver.c:578
win_skip
#define win_skip
Definition: test.h:149
BCRYPT_HASH_LENGTH
#define BCRYPT_HASH_LENGTH
Definition: bcrypt.h:50
expected
BOOL expected
Definition: store.c:2063
NTSTATUS
static NTSTATUS(WINAPI *pBCryptHash)(BCRYPT_ALG_HANDLE algorithm
ok_
#define ok_(x1, x2)
Definition: atltest.h:61
BCryptDestroyHash
NTSTATUS WINAPI BCryptDestroyHash(BCRYPT_HASH_HANDLE handle)
Definition: bcrypt_main.c:1041
BCryptCreateHash
NTSTATUS WINAPI BCryptCreateHash(BCRYPT_ALG_HANDLE algorithm, BCRYPT_HASH_HANDLE *handle, UCHAR *object, ULONG objectlen, UCHAR *secret, ULONG secretlen, ULONG flags)
Definition: bcrypt_main.c:999
HKEY_LOCAL_MACHINE
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
status
Definition: ps.c:97