nigori_key_bag_unittest.cc 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161
  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/nigori_key_bag.h"
  5. #include "components/sync/engine/nigori/key_derivation_params.h"
  6. #include "components/sync/engine/nigori/nigori.h"
  7. #include "components/sync/protocol/nigori_specifics.pb.h"
  8. #include "testing/gmock/include/gmock/gmock.h"
  9. #include "testing/gtest/include/gtest/gtest.h"
  10. namespace syncer {
  11. namespace {
  12. using testing::Eq;
  13. using testing::Ne;
  14. using testing::SizeIs;
  15. std::unique_ptr<Nigori> CreateTestNigori(const std::string& password) {
  16. return Nigori::CreateByDerivation(KeyDerivationParams::CreateForPbkdf2(),
  17. password);
  18. }
  19. TEST(NigoriKeyBagTest, ShouldCreateEmpty) {
  20. const NigoriKeyBag key_bag = NigoriKeyBag::CreateEmpty();
  21. EXPECT_THAT(key_bag, SizeIs(0));
  22. EXPECT_FALSE(key_bag.HasKey("foo"));
  23. }
  24. TEST(NigoriKeyBagTest, ShouldAddKeys) {
  25. NigoriKeyBag key_bag = NigoriKeyBag::CreateEmpty();
  26. ASSERT_THAT(key_bag, SizeIs(0));
  27. const std::string key_name1 = key_bag.AddKey(CreateTestNigori("password1"));
  28. EXPECT_THAT(key_name1, Ne(""));
  29. EXPECT_THAT(key_bag, SizeIs(1));
  30. EXPECT_TRUE(key_bag.HasKey(key_name1));
  31. const std::string key_name2 = key_bag.AddKey(CreateTestNigori("password2"));
  32. EXPECT_THAT(key_name2, Ne(""));
  33. EXPECT_THAT(key_name2, Ne(key_name1));
  34. EXPECT_THAT(key_bag, SizeIs(2));
  35. EXPECT_TRUE(key_bag.HasKey(key_name1));
  36. EXPECT_TRUE(key_bag.HasKey(key_name2));
  37. }
  38. TEST(NigoriKeyBagTest, ShouldExportKey) {
  39. NigoriKeyBag key_bag = NigoriKeyBag::CreateEmpty();
  40. const std::string key_name1 = key_bag.AddKey(CreateTestNigori("password1"));
  41. ASSERT_THAT(key_bag, SizeIs(1));
  42. ASSERT_THAT(key_name1, Ne(""));
  43. ASSERT_TRUE(key_bag.HasKey(key_name1));
  44. sync_pb::NigoriKey exported_key = key_bag.ExportKey(key_name1);
  45. // Callers of ExportKey() rely on the deprecated field *NOT* being populated.
  46. EXPECT_FALSE(exported_key.has_deprecated_name());
  47. // The exported key, even without name, should be importable, and the
  48. // resulting key name should match the original.
  49. EXPECT_THAT(NigoriKeyBag::CreateEmpty().AddKeyFromProto(exported_key),
  50. Eq(key_name1));
  51. }
  52. TEST(NigoriKeyBagTest, ShouldConvertEmptyToProto) {
  53. EXPECT_EQ(sync_pb::NigoriKeyBag().SerializeAsString(),
  54. NigoriKeyBag::CreateEmpty().ToProto().SerializeAsString());
  55. }
  56. TEST(NigoriKeyBagTest, ShouldConvertNonEmptyToProto) {
  57. NigoriKeyBag key_bag = NigoriKeyBag::CreateEmpty();
  58. const std::string key_name = key_bag.AddKey(CreateTestNigori("password1"));
  59. sync_pb::NigoriKeyBag proto = key_bag.ToProto();
  60. ASSERT_THAT(proto.key(), SizeIs(1));
  61. // Callers of ToProto() rely on the deprecated name field being populated,
  62. // since it gets exposed to the sync protocol, and hence subject to backward
  63. // compatibility.
  64. EXPECT_THAT(proto.key(0).deprecated_name(), Eq(key_name));
  65. EXPECT_THAT(proto.key(0).deprecated_user_key(), Ne(""));
  66. EXPECT_THAT(proto.key(0).encryption_key(), Ne(""));
  67. EXPECT_THAT(proto.key(0).mac_key(), Ne(""));
  68. }
  69. TEST(NigoriKeyBagTest, ShouldCreateEmptyFromProto) {
  70. EXPECT_THAT(NigoriKeyBag::CreateFromProto(sync_pb::NigoriKeyBag()),
  71. SizeIs(0));
  72. }
  73. TEST(NigoriKeyBagTest, ShouldCreateNonEmptyFromProto) {
  74. NigoriKeyBag original_key_bag = NigoriKeyBag::CreateEmpty();
  75. const std::string key_name1 =
  76. original_key_bag.AddKey(CreateTestNigori("password1"));
  77. const std::string key_name2 =
  78. original_key_bag.AddKey(CreateTestNigori("password2"));
  79. ASSERT_THAT(original_key_bag, SizeIs(2));
  80. const NigoriKeyBag restored_key_bag =
  81. NigoriKeyBag::CreateFromProto(original_key_bag.ToProto());
  82. EXPECT_THAT(restored_key_bag, SizeIs(2));
  83. EXPECT_TRUE(restored_key_bag.HasKey(key_name1));
  84. EXPECT_TRUE(restored_key_bag.HasKey(key_name2));
  85. }
  86. TEST(NigoriKeyBagTest, ShouldCreateNonEmptyFromPartiallyInvalidProto) {
  87. NigoriKeyBag original_key_bag = NigoriKeyBag::CreateEmpty();
  88. const std::string key_name1 =
  89. original_key_bag.AddKey(CreateTestNigori("password1"));
  90. const std::string key_name2 =
  91. original_key_bag.AddKey(CreateTestNigori("password2"));
  92. sync_pb::NigoriKeyBag malformed_proto = original_key_bag.ToProto();
  93. ASSERT_THAT(malformed_proto.key(), SizeIs(2));
  94. malformed_proto.mutable_key(1)->set_encryption_key("malformed-key");
  95. NigoriKeyBag restored_key_bag =
  96. NigoriKeyBag::CreateFromProto(malformed_proto);
  97. EXPECT_THAT(restored_key_bag, SizeIs(1));
  98. EXPECT_TRUE(restored_key_bag.HasKey(key_name1));
  99. EXPECT_FALSE(restored_key_bag.HasKey(key_name2));
  100. }
  101. TEST(NigoriKeyBagTest, ShouldClone) {
  102. NigoriKeyBag original_key_bag = NigoriKeyBag::CreateEmpty();
  103. const std::string key_name1 =
  104. original_key_bag.AddKey(CreateTestNigori("password1"));
  105. const std::string key_name2 =
  106. original_key_bag.AddKey(CreateTestNigori("password2"));
  107. ASSERT_THAT(original_key_bag, SizeIs(2));
  108. const NigoriKeyBag cloned_key_bag = original_key_bag.Clone();
  109. EXPECT_THAT(cloned_key_bag, SizeIs(2));
  110. EXPECT_TRUE(cloned_key_bag.HasKey(key_name1));
  111. EXPECT_TRUE(cloned_key_bag.HasKey(key_name2));
  112. }
  113. // This holds true for M79 and above, but older clients rely on the field being
  114. // set.
  115. TEST(NigoriKeyBagTest, ShouldIgnoreDeprecatedKeyNameProtoField) {
  116. NigoriKeyBag original_key_bag = NigoriKeyBag::CreateEmpty();
  117. const std::string real_key_name =
  118. original_key_bag.AddKey(CreateTestNigori("password1"));
  119. ASSERT_THAT(original_key_bag, SizeIs(1));
  120. const std::string actual_key_name_in_proto =
  121. NigoriKeyBag::CreateEmpty().AddKey(CreateTestNigori("password2"));
  122. sync_pb::NigoriKeyBag proto = original_key_bag.ToProto();
  123. proto.mutable_key(0)->set_deprecated_name(actual_key_name_in_proto);
  124. NigoriKeyBag restored_key_bag = NigoriKeyBag::CreateFromProto(proto);
  125. ASSERT_THAT(restored_key_bag, SizeIs(1));
  126. EXPECT_TRUE(restored_key_bag.HasKey(real_key_name));
  127. EXPECT_FALSE(restored_key_bag.HasKey(actual_key_name_in_proto));
  128. }
  129. } // namespace
  130. } // namespace syncer