cryptographer_impl_unittest.cc 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157
  1. // Copyright 2019 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/sync/nigori/cryptographer_impl.h"
  5. #include "components/sync/engine/nigori/key_derivation_params.h"
  6. #include "components/sync/protocol/nigori_local_data.pb.h"
  7. #include "testing/gmock/include/gmock/gmock.h"
  8. #include "testing/gtest/include/gtest/gtest.h"
  9. namespace syncer {
  10. namespace {
  11. using testing::Eq;
  12. using testing::Ne;
  13. using testing::NotNull;
  14. } // namespace
  15. TEST(CryptographerImplTest, ShouldCreateEmpty) {
  16. std::unique_ptr<CryptographerImpl> cryptographer =
  17. CryptographerImpl::CreateEmpty();
  18. ASSERT_THAT(cryptographer, NotNull());
  19. EXPECT_FALSE(cryptographer->CanEncrypt());
  20. sync_pb::EncryptedData encrypted;
  21. encrypted.set_key_name("foo");
  22. encrypted.set_blob("bar");
  23. EXPECT_FALSE(cryptographer->CanDecrypt(encrypted));
  24. std::string output;
  25. EXPECT_FALSE(cryptographer->DecryptToString(encrypted, &output));
  26. }
  27. TEST(CryptographerImplTest, ShouldEmplaceKey) {
  28. std::unique_ptr<CryptographerImpl> cryptographer =
  29. CryptographerImpl::CreateEmpty();
  30. ASSERT_THAT(cryptographer, NotNull());
  31. ASSERT_FALSE(cryptographer->CanEncrypt());
  32. const std::string key_name = cryptographer->EmplaceKey(
  33. "password1", KeyDerivationParams::CreateForPbkdf2());
  34. EXPECT_THAT(key_name, Ne(std::string()));
  35. sync_pb::EncryptedData encrypted;
  36. encrypted.set_key_name(key_name);
  37. encrypted.set_blob("fakeblob");
  38. EXPECT_TRUE(cryptographer->CanDecrypt(encrypted));
  39. EXPECT_FALSE(cryptographer->CanEncrypt());
  40. }
  41. TEST(CryptographerImplTest, ShouldEmplaceExistingKey) {
  42. std::unique_ptr<CryptographerImpl> cryptographer =
  43. CryptographerImpl::CreateEmpty();
  44. ASSERT_THAT(cryptographer, NotNull());
  45. const std::string key_name = cryptographer->EmplaceKey(
  46. "password1", KeyDerivationParams::CreateForPbkdf2());
  47. ASSERT_THAT(key_name, Ne(std::string()));
  48. EXPECT_THAT(cryptographer->EmplaceKey("password1",
  49. KeyDerivationParams::CreateForPbkdf2()),
  50. Eq(key_name));
  51. }
  52. TEST(CryptographerImplTest, ShouldEmplaceSecondKey) {
  53. std::unique_ptr<CryptographerImpl> cryptographer =
  54. CryptographerImpl::CreateEmpty();
  55. ASSERT_THAT(cryptographer, NotNull());
  56. const std::string key_name1 = cryptographer->EmplaceKey(
  57. "password1", KeyDerivationParams::CreateForPbkdf2());
  58. const std::string key_name2 = cryptographer->EmplaceKey(
  59. "password2", KeyDerivationParams::CreateForPbkdf2());
  60. EXPECT_THAT(key_name1, Ne(std::string()));
  61. EXPECT_THAT(key_name2, Ne(std::string()));
  62. EXPECT_THAT(key_name1, Ne(key_name2));
  63. }
  64. TEST(CryptographerImplTest, ShouldSelectDefaultEncryptionKey) {
  65. std::unique_ptr<CryptographerImpl> cryptographer =
  66. CryptographerImpl::CreateEmpty();
  67. ASSERT_THAT(cryptographer, NotNull());
  68. ASSERT_FALSE(cryptographer->CanEncrypt());
  69. const std::string key_name = cryptographer->EmplaceKey(
  70. "password1", KeyDerivationParams::CreateForPbkdf2());
  71. ASSERT_THAT(key_name, Ne(std::string()));
  72. cryptographer->SelectDefaultEncryptionKey(key_name);
  73. ASSERT_TRUE(cryptographer->CanEncrypt());
  74. sync_pb::EncryptedData encrypted;
  75. EXPECT_TRUE(cryptographer->EncryptString("foo", &encrypted));
  76. EXPECT_THAT(encrypted.key_name(), Eq(key_name));
  77. }
  78. TEST(CryptographerImplTest, ShouldSerializeToAndFromProto) {
  79. const std::string kText1 = "foo";
  80. const std::string kText2 = "bar";
  81. std::unique_ptr<CryptographerImpl> original_cryptographer =
  82. CryptographerImpl::CreateEmpty();
  83. ASSERT_THAT(original_cryptographer, NotNull());
  84. const std::string key_name1 = original_cryptographer->EmplaceKey(
  85. "password1", KeyDerivationParams::CreateForPbkdf2());
  86. const std::string key_name2 = original_cryptographer->EmplaceKey(
  87. "password2", KeyDerivationParams::CreateForPbkdf2());
  88. original_cryptographer->SelectDefaultEncryptionKey(key_name1);
  89. sync_pb::EncryptedData encrypted1;
  90. EXPECT_TRUE(original_cryptographer->EncryptString(kText1, &encrypted1));
  91. original_cryptographer->SelectDefaultEncryptionKey(key_name2);
  92. sync_pb::EncryptedData encrypted2;
  93. EXPECT_TRUE(original_cryptographer->EncryptString(kText2, &encrypted2));
  94. // Restore a new cryptographer from proto.
  95. std::unique_ptr<CryptographerImpl> restored_cryptographer =
  96. CryptographerImpl::FromProto(original_cryptographer->ToProto());
  97. ASSERT_THAT(restored_cryptographer, NotNull());
  98. EXPECT_TRUE(restored_cryptographer->CanEncrypt());
  99. std::string decrypted;
  100. EXPECT_TRUE(restored_cryptographer->DecryptToString(encrypted1, &decrypted));
  101. EXPECT_THAT(decrypted, Eq(kText1));
  102. EXPECT_TRUE(restored_cryptographer->DecryptToString(encrypted2, &decrypted));
  103. EXPECT_THAT(decrypted, Eq(kText2));
  104. }
  105. TEST(CryptographerImplTest, ShouldExportDefaultKey) {
  106. std::unique_ptr<CryptographerImpl> cryptographer =
  107. CryptographerImpl::CreateEmpty();
  108. ASSERT_THAT(cryptographer, NotNull());
  109. const std::string key_name = cryptographer->EmplaceKey(
  110. "password1", KeyDerivationParams::CreateForPbkdf2());
  111. ASSERT_THAT(key_name, Ne(std::string()));
  112. cryptographer->SelectDefaultEncryptionKey(key_name);
  113. ASSERT_TRUE(cryptographer->CanEncrypt());
  114. sync_pb::NigoriKey exported_key = cryptographer->ExportDefaultKey();
  115. EXPECT_FALSE(exported_key.has_deprecated_name());
  116. // The exported key, even without name, should be importable, and the
  117. // resulting key name should match the original.
  118. EXPECT_THAT(NigoriKeyBag::CreateEmpty().AddKeyFromProto(exported_key),
  119. Eq(key_name));
  120. }
  121. } // namespace syncer