OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome_elf/nt_registry/nt_registry.h" | 5 #include "chrome_elf/nt_registry/nt_registry.h" |
6 | 6 |
7 #include <windows.h> | 7 #include <windows.h> |
8 #include <rpc.h> | 8 #include <rpc.h> |
9 #include <stddef.h> | 9 #include <stddef.h> |
10 | 10 |
(...skipping 330 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
341 EXPECT_TRUE(nt::DeleteRegKey(key_handle)); | 341 EXPECT_TRUE(nt::DeleteRegKey(key_handle)); |
342 nt::CloseRegKey(key_handle); | 342 nt::CloseRegKey(key_handle); |
343 } | 343 } |
344 | 344 |
345 TEST_F(NtRegistryTest, API_SZ) { | 345 TEST_F(NtRegistryTest, API_SZ) { |
346 HANDLE key_handle; | 346 HANDLE key_handle; |
347 const wchar_t* sz_val_name = L"SzTestValue"; | 347 const wchar_t* sz_val_name = L"SzTestValue"; |
348 std::wstring sz_val = L"blah de blah de blahhhhh."; | 348 std::wstring sz_val = L"blah de blah de blahhhhh."; |
349 const wchar_t* sz_val_name2 = L"SzTestValueEmpty"; | 349 const wchar_t* sz_val_name2 = L"SzTestValueEmpty"; |
350 std::wstring sz_val2 = L""; | 350 std::wstring sz_val2 = L""; |
| 351 const wchar_t* sz_val_name3 = L"SzTestValueMalformed"; |
| 352 const wchar_t* sz_val_name4 = L"SzTestValueMalformed2"; |
| 353 std::wstring sz_val3 = L"malformed"; |
| 354 BYTE* sz_val3_byte = reinterpret_cast<BYTE*>(&sz_val3[0]); |
| 355 std::vector<BYTE> malform; |
| 356 for (size_t i = 0; i < (sz_val3.size() * sizeof(wchar_t)); i++) |
| 357 malform.push_back(sz_val3_byte[i]); |
| 358 const wchar_t* sz_val_name5 = L"SzTestValueSize0"; |
351 | 359 |
352 // Create a subkey to play under. | 360 // Create a subkey to play under. |
| 361 // ------------------------------ |
353 ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, L"NTRegistry\\sz", KEY_ALL_ACCESS, | 362 ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, L"NTRegistry\\sz", KEY_ALL_ACCESS, |
354 &key_handle)); | 363 &key_handle)); |
355 ASSERT_NE(key_handle, INVALID_HANDLE_VALUE); | 364 ASSERT_NE(key_handle, INVALID_HANDLE_VALUE); |
356 ASSERT_NE(key_handle, nullptr); | 365 ASSERT_NE(key_handle, nullptr); |
357 | 366 |
358 std::wstring get_sz; | 367 std::wstring get_sz; |
359 EXPECT_FALSE(nt::QueryRegValueSZ(key_handle, sz_val_name, &get_sz)); | 368 EXPECT_FALSE(nt::QueryRegValueSZ(key_handle, sz_val_name, &get_sz)); |
360 | 369 |
361 // Set | 370 // Set |
| 371 // ------------------------------ |
362 EXPECT_TRUE(nt::SetRegValueSZ(key_handle, sz_val_name, sz_val)); | 372 EXPECT_TRUE(nt::SetRegValueSZ(key_handle, sz_val_name, sz_val)); |
363 EXPECT_TRUE(nt::SetRegValueSZ(key_handle, sz_val_name2, sz_val2)); | 373 EXPECT_TRUE(nt::SetRegValueSZ(key_handle, sz_val_name2, sz_val2)); |
| 374 // No null terminator. |
| 375 EXPECT_TRUE(nt::SetRegKeyValue(key_handle, sz_val_name3, REG_SZ, |
| 376 malform.data(), |
| 377 static_cast<DWORD>(malform.size()))); |
| 378 malform.push_back(0); |
| 379 // Single trailing 0 byte. |
| 380 EXPECT_TRUE(nt::SetRegKeyValue(key_handle, sz_val_name4, REG_SZ, |
| 381 malform.data(), |
| 382 static_cast<DWORD>(malform.size()))); |
| 383 // Size 0 value. |
| 384 EXPECT_TRUE(nt::SetRegKeyValue(key_handle, sz_val_name5, REG_SZ, nullptr, 0)); |
364 | 385 |
365 // Get | 386 // Get |
| 387 // ------------------------------ |
366 EXPECT_TRUE(nt::QueryRegValueSZ(key_handle, sz_val_name, &get_sz)); | 388 EXPECT_TRUE(nt::QueryRegValueSZ(key_handle, sz_val_name, &get_sz)); |
367 EXPECT_TRUE(get_sz.compare(sz_val) == 0); | 389 EXPECT_TRUE(get_sz.compare(sz_val) == 0); |
368 EXPECT_TRUE(nt::QueryRegValueSZ(key_handle, sz_val_name2, &get_sz)); | 390 EXPECT_TRUE(nt::QueryRegValueSZ(key_handle, sz_val_name2, &get_sz)); |
369 EXPECT_TRUE(get_sz.compare(sz_val2) == 0); | 391 EXPECT_TRUE(get_sz.compare(sz_val2) == 0); |
| 392 EXPECT_TRUE(nt::QueryRegValueSZ(key_handle, sz_val_name3, &get_sz)); |
| 393 // Should be adjusted under the hood to equal sz_val3. |
| 394 EXPECT_TRUE(get_sz.compare(sz_val3) == 0); |
| 395 EXPECT_TRUE(nt::QueryRegValueSZ(key_handle, sz_val_name4, &get_sz)); |
| 396 // Should be adjusted under the hood to equal sz_val3. |
| 397 EXPECT_TRUE(get_sz.compare(sz_val3) == 0); |
| 398 EXPECT_TRUE(nt::QueryRegValueSZ(key_handle, sz_val_name5, &get_sz)); |
| 399 // Should be adjusted under the hood to an empty string. |
| 400 EXPECT_TRUE(get_sz.compare(sz_val2) == 0); |
370 | 401 |
371 // Clean up | 402 // Clean up |
| 403 // ------------------------------ |
372 EXPECT_TRUE(nt::DeleteRegKey(key_handle)); | 404 EXPECT_TRUE(nt::DeleteRegKey(key_handle)); |
373 nt::CloseRegKey(key_handle); | 405 nt::CloseRegKey(key_handle); |
374 } | 406 } |
375 | 407 |
376 TEST_F(NtRegistryTest, API_MULTISZ) { | 408 TEST_F(NtRegistryTest, API_MULTISZ) { |
377 HANDLE key_handle; | 409 HANDLE key_handle; |
378 const wchar_t* multisz_val_name = L"SzmultiTestValue"; | 410 const wchar_t* multisz_val_name = L"SzmultiTestValue"; |
379 std::vector<std::wstring> multisz_val; | 411 std::vector<std::wstring> multisz_val; |
380 std::wstring multi1 = L"one"; | 412 std::wstring multi1 = L"one"; |
381 std::wstring multi2 = L"two"; | 413 std::wstring multi2 = L"two"; |
382 std::wstring multi3 = L"three"; | 414 std::wstring multi3 = L"three"; |
383 const wchar_t* multisz_val_name2 = L"SzmultiTestValueBad"; | 415 const wchar_t* multisz_val_name2 = L"SzmultiTestValueBad"; |
384 std::wstring multi_empty = L""; | 416 std::wstring multi_empty = L""; |
| 417 const wchar_t* multisz_val_name3 = L"SzmultiTestValueMalformed"; |
| 418 const wchar_t* multisz_val_name4 = L"SzmultiTestValueMalformed2"; |
| 419 const wchar_t* multisz_val_name5 = L"SzmultiTestValueMalformed3"; |
| 420 const wchar_t* multisz_val_name6 = L"SzmultiTestValueMalformed4"; |
| 421 std::wstring multisz_val3 = L"malformed"; |
| 422 BYTE* multisz_val3_byte = reinterpret_cast<BYTE*>(&multisz_val3[0]); |
| 423 std::vector<BYTE> malform; |
| 424 for (size_t i = 0; i < (multisz_val3.size() * sizeof(wchar_t)); i++) |
| 425 malform.push_back(multisz_val3_byte[i]); |
| 426 const wchar_t* multisz_val_name7 = L"SzmultiTestValueSize0"; |
385 | 427 |
386 // Create a subkey to play under. | 428 // Create a subkey to play under. |
| 429 // ------------------------------ |
387 ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, L"NTRegistry\\multisz", KEY_ALL_ACCESS, | 430 ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, L"NTRegistry\\multisz", KEY_ALL_ACCESS, |
388 &key_handle)); | 431 &key_handle)); |
389 ASSERT_NE(key_handle, INVALID_HANDLE_VALUE); | 432 ASSERT_NE(key_handle, INVALID_HANDLE_VALUE); |
390 ASSERT_NE(key_handle, nullptr); | 433 ASSERT_NE(key_handle, nullptr); |
391 | 434 |
392 multisz_val.push_back(multi1); | 435 multisz_val.push_back(multi1); |
393 multisz_val.push_back(multi2); | 436 multisz_val.push_back(multi2); |
394 multisz_val.push_back(multi3); | 437 multisz_val.push_back(multi3); |
| 438 |
395 // Set | 439 // Set |
| 440 // ------------------------------ |
396 EXPECT_TRUE( | 441 EXPECT_TRUE( |
397 nt::SetRegValueMULTISZ(key_handle, multisz_val_name, multisz_val)); | 442 nt::SetRegValueMULTISZ(key_handle, multisz_val_name, multisz_val)); |
398 multisz_val.clear(); | 443 multisz_val.clear(); |
399 multisz_val.push_back(multi_empty); | 444 multisz_val.push_back(multi_empty); |
400 // Set | 445 |
401 EXPECT_TRUE( | 446 EXPECT_TRUE( |
402 nt::SetRegValueMULTISZ(key_handle, multisz_val_name2, multisz_val)); | 447 nt::SetRegValueMULTISZ(key_handle, multisz_val_name2, multisz_val)); |
403 multisz_val.clear(); | 448 multisz_val.clear(); |
404 | 449 |
| 450 // No null terminator. |
| 451 EXPECT_TRUE(nt::SetRegKeyValue(key_handle, multisz_val_name3, REG_MULTI_SZ, |
| 452 malform.data(), |
| 453 static_cast<DWORD>(malform.size()))); |
| 454 malform.push_back(0); |
| 455 // Single trailing 0 byte. |
| 456 EXPECT_TRUE(nt::SetRegKeyValue(key_handle, multisz_val_name4, REG_MULTI_SZ, |
| 457 malform.data(), |
| 458 static_cast<DWORD>(malform.size()))); |
| 459 malform.push_back(0); |
| 460 // Two trailing 0 bytes. |
| 461 EXPECT_TRUE(nt::SetRegKeyValue(key_handle, multisz_val_name5, REG_MULTI_SZ, |
| 462 malform.data(), |
| 463 static_cast<DWORD>(malform.size()))); |
| 464 malform.push_back(0); |
| 465 // Three trailing 0 bytes. |
| 466 EXPECT_TRUE(nt::SetRegKeyValue(key_handle, multisz_val_name6, REG_MULTI_SZ, |
| 467 malform.data(), |
| 468 static_cast<DWORD>(malform.size()))); |
| 469 |
| 470 // Size 0 value. |
| 471 EXPECT_TRUE(nt::SetRegKeyValue(key_handle, multisz_val_name7, REG_MULTI_SZ, |
| 472 nullptr, 0)); |
| 473 |
405 // Get | 474 // Get |
| 475 // ------------------------------ |
406 EXPECT_TRUE( | 476 EXPECT_TRUE( |
407 nt::QueryRegValueMULTISZ(key_handle, multisz_val_name, &multisz_val)); | 477 nt::QueryRegValueMULTISZ(key_handle, multisz_val_name, &multisz_val)); |
408 if (multisz_val.size() == 3) { | 478 if (multisz_val.size() == 3) { |
409 EXPECT_TRUE(multi1.compare(multisz_val.at(0)) == 0); | 479 EXPECT_TRUE(multi1.compare(multisz_val.at(0)) == 0); |
410 EXPECT_TRUE(multi2.compare(multisz_val.at(1)) == 0); | 480 EXPECT_TRUE(multi2.compare(multisz_val.at(1)) == 0); |
411 EXPECT_TRUE(multi3.compare(multisz_val.at(2)) == 0); | 481 EXPECT_TRUE(multi3.compare(multisz_val.at(2)) == 0); |
412 } else { | 482 } else { |
413 EXPECT_TRUE(false); | 483 EXPECT_TRUE(false); |
414 } | 484 } |
415 multisz_val.clear(); | 485 multisz_val.clear(); |
416 | 486 |
417 // Get | |
418 EXPECT_TRUE( | 487 EXPECT_TRUE( |
419 nt::QueryRegValueMULTISZ(key_handle, multisz_val_name2, &multisz_val)); | 488 nt::QueryRegValueMULTISZ(key_handle, multisz_val_name2, &multisz_val)); |
420 if (multisz_val.size() == 1) { | 489 EXPECT_EQ(multisz_val.size(), static_cast<DWORD>(0)); |
421 EXPECT_TRUE(multi_empty.compare(multisz_val.at(0)) == 0); | 490 multisz_val.clear(); |
| 491 |
| 492 EXPECT_TRUE( |
| 493 nt::QueryRegValueMULTISZ(key_handle, multisz_val_name3, &multisz_val)); |
| 494 if (multisz_val.size(), 1) { |
| 495 // Should be adjusted under the hood to equal sz_val3. |
| 496 EXPECT_TRUE(multisz_val3.compare(multisz_val.at(0)) == 0); |
422 } else { | 497 } else { |
423 EXPECT_TRUE(false); | 498 EXPECT_TRUE(false); |
424 } | 499 } |
425 multisz_val.clear(); | 500 multisz_val.clear(); |
426 | 501 |
| 502 EXPECT_TRUE( |
| 503 nt::QueryRegValueMULTISZ(key_handle, multisz_val_name4, &multisz_val)); |
| 504 if (multisz_val.size(), 1) { |
| 505 // Should be adjusted under the hood to equal sz_val3. |
| 506 EXPECT_TRUE(multisz_val3.compare(multisz_val.at(0)) == 0); |
| 507 } else { |
| 508 EXPECT_TRUE(false); |
| 509 } |
| 510 multisz_val.clear(); |
| 511 |
| 512 EXPECT_TRUE( |
| 513 nt::QueryRegValueMULTISZ(key_handle, multisz_val_name5, &multisz_val)); |
| 514 if (multisz_val.size(), 1) { |
| 515 // Should be adjusted under the hood to equal sz_val3. |
| 516 EXPECT_TRUE(multisz_val3.compare(multisz_val.at(0)) == 0); |
| 517 } else { |
| 518 EXPECT_TRUE(false); |
| 519 } |
| 520 multisz_val.clear(); |
| 521 |
| 522 EXPECT_TRUE( |
| 523 nt::QueryRegValueMULTISZ(key_handle, multisz_val_name6, &multisz_val)); |
| 524 if (multisz_val.size(), 1) { |
| 525 // Should be adjusted under the hood to equal sz_val3. |
| 526 EXPECT_TRUE(multisz_val3.compare(multisz_val.at(0)) == 0); |
| 527 } else { |
| 528 EXPECT_TRUE(false); |
| 529 } |
| 530 multisz_val.clear(); |
| 531 |
| 532 EXPECT_TRUE( |
| 533 nt::QueryRegValueMULTISZ(key_handle, multisz_val_name7, &multisz_val)); |
| 534 // Should be adjusted under the hood to an empty string. |
| 535 EXPECT_TRUE(multisz_val.empty()); |
| 536 |
427 // Clean up | 537 // Clean up |
| 538 // ------------------------------ |
428 EXPECT_TRUE(nt::DeleteRegKey(key_handle)); | 539 EXPECT_TRUE(nt::DeleteRegKey(key_handle)); |
429 nt::CloseRegKey(key_handle); | 540 nt::CloseRegKey(key_handle); |
430 } | 541 } |
431 | 542 |
432 TEST_F(NtRegistryTest, CreateRegKeyRecursion) { | 543 TEST_F(NtRegistryTest, CreateRegKeyRecursion) { |
433 HANDLE key_handle; | 544 HANDLE key_handle; |
434 const wchar_t* sz_new_key_1 = L"test1\\new\\subkey"; | 545 const wchar_t* sz_new_key_1 = L"test1\\new\\subkey"; |
435 const wchar_t* sz_new_key_2 = L"test2\\new\\subkey\\blah\\"; | 546 const wchar_t* sz_new_key_2 = L"test2\\new\\subkey\\blah\\"; |
436 const wchar_t* sz_new_key_3 = L"\\test3\\new\\subkey\\\\blah2"; | 547 const wchar_t* sz_new_key_3 = L"\\test3\\new\\subkey\\\\blah2"; |
437 | 548 |
(...skipping 20 matching lines...) Expand all Loading... |
458 nt::CloseRegKey(key_handle); | 569 nt::CloseRegKey(key_handle); |
459 | 570 |
460 // Subkey path can be null. | 571 // Subkey path can be null. |
461 ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, nullptr, KEY_ALL_ACCESS, &key_handle)); | 572 ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, nullptr, KEY_ALL_ACCESS, &key_handle)); |
462 ASSERT_NE(key_handle, INVALID_HANDLE_VALUE); | 573 ASSERT_NE(key_handle, INVALID_HANDLE_VALUE); |
463 ASSERT_NE(key_handle, nullptr); | 574 ASSERT_NE(key_handle, nullptr); |
464 nt::CloseRegKey(key_handle); | 575 nt::CloseRegKey(key_handle); |
465 } | 576 } |
466 | 577 |
467 } // namespace | 578 } // namespace |
OLD | NEW |