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 } 781