nacl_validation_cache_unittest.cc 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194
  1. // Copyright 2013 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 "base/pickle.h"
  5. #include "components/nacl/browser/nacl_validation_cache.h"
  6. #include "testing/gtest/include/gtest/gtest.h"
  7. namespace nacl {
  8. const char key1[65] =
  9. "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF";
  10. const char key2[65] =
  11. "a 64-byte string of various junk................................";
  12. const char sig1[33] = "0123456789ABCDEF0123456789ABCDEF";
  13. const char sig2[33] = "a 32-byte string of various junk";
  14. class NaClValidationCacheTest : public ::testing::Test {
  15. protected:
  16. NaClValidationCache cache1;
  17. NaClValidationCache cache2;
  18. void SetUp() override {
  19. // The compiler chokes if std::string(key1) is passed directly as an arg.
  20. std::string key(key1);
  21. cache1.SetValidationCacheKey(key);
  22. cache2.SetValidationCacheKey(key);
  23. }
  24. bool IsIdentical(const NaClValidationCache& a,
  25. const NaClValidationCache& b) const {
  26. if (a.GetValidationCacheKey() != b.GetValidationCacheKey())
  27. return false;
  28. if (a.size() != b.size())
  29. return false;
  30. return a.GetContents() == b.GetContents();
  31. }
  32. };
  33. TEST_F(NaClValidationCacheTest, Sanity) {
  34. ASSERT_EQ(0, (int) cache1.size());
  35. ASSERT_FALSE(cache1.QueryKnownToValidate(sig1, true));
  36. ASSERT_FALSE(cache1.QueryKnownToValidate(sig2, true));
  37. }
  38. TEST_F(NaClValidationCacheTest, Sig1) {
  39. cache1.SetKnownToValidate(sig1);
  40. ASSERT_EQ(1, (int) cache1.size());
  41. ASSERT_TRUE(cache1.QueryKnownToValidate(sig1, true));
  42. ASSERT_FALSE(cache1.QueryKnownToValidate(sig2, true));
  43. }
  44. TEST_F(NaClValidationCacheTest, Sig2) {
  45. cache1.SetKnownToValidate(sig2);
  46. ASSERT_EQ(1, (int) cache1.size());
  47. ASSERT_FALSE(cache1.QueryKnownToValidate(sig1, true));
  48. ASSERT_TRUE(cache1.QueryKnownToValidate(sig2, true));
  49. }
  50. TEST_F(NaClValidationCacheTest, SigBoth) {
  51. cache1.SetKnownToValidate(sig1);
  52. cache1.SetKnownToValidate(sig2);
  53. ASSERT_EQ(2, (int) cache1.size());
  54. ASSERT_TRUE(cache1.QueryKnownToValidate(sig1, true));
  55. ASSERT_TRUE(cache1.QueryKnownToValidate(sig2, true));
  56. }
  57. TEST_F(NaClValidationCacheTest, DoubleSet) {
  58. cache1.SetKnownToValidate(sig1);
  59. cache1.SetKnownToValidate(sig1);
  60. ASSERT_EQ(1, (int) cache1.size());
  61. ASSERT_TRUE(cache1.QueryKnownToValidate(sig1, true));
  62. }
  63. TEST_F(NaClValidationCacheTest, EmptyIdentical) {
  64. ASSERT_TRUE(IsIdentical(cache1, cache2));
  65. }
  66. TEST_F(NaClValidationCacheTest, DifferentKeysNotIdentical) {
  67. std::string key(key2);
  68. cache2.SetValidationCacheKey(key);
  69. ASSERT_FALSE(IsIdentical(cache1, cache2));
  70. }
  71. TEST_F(NaClValidationCacheTest, DifferentSizesNotIdentical) {
  72. cache1.SetKnownToValidate(sig1);
  73. ASSERT_FALSE(IsIdentical(cache1, cache2));
  74. }
  75. TEST_F(NaClValidationCacheTest, SameSigsIdentical) {
  76. cache1.SetKnownToValidate(sig1);
  77. cache2.SetKnownToValidate(sig1);
  78. ASSERT_TRUE(IsIdentical(cache1, cache2));
  79. }
  80. TEST_F(NaClValidationCacheTest, DifferentSigsNotIdentical) {
  81. cache1.SetKnownToValidate(sig1);
  82. cache2.SetKnownToValidate(sig2);
  83. ASSERT_FALSE(IsIdentical(cache1, cache2));
  84. }
  85. TEST_F(NaClValidationCacheTest, InOrderIdentical) {
  86. cache1.SetKnownToValidate(sig1);
  87. cache1.SetKnownToValidate(sig2);
  88. cache2.SetKnownToValidate(sig1);
  89. cache2.SetKnownToValidate(sig2);
  90. ASSERT_TRUE(IsIdentical(cache1, cache2));
  91. }
  92. TEST_F(NaClValidationCacheTest, QueryReorders) {
  93. cache1.SetKnownToValidate(sig1);
  94. cache1.SetKnownToValidate(sig2);
  95. cache2.SetKnownToValidate(sig2);
  96. cache2.SetKnownToValidate(sig1);
  97. ASSERT_FALSE(IsIdentical(cache1, cache2));
  98. cache2.QueryKnownToValidate(sig2, true);
  99. ASSERT_TRUE(IsIdentical(cache1, cache2));
  100. }
  101. TEST_F(NaClValidationCacheTest, ForceNoReorder) {
  102. cache1.SetKnownToValidate(sig1);
  103. cache1.SetKnownToValidate(sig2);
  104. cache2.SetKnownToValidate(sig2);
  105. cache2.SetKnownToValidate(sig1);
  106. cache2.QueryKnownToValidate(sig2, false);
  107. ASSERT_FALSE(IsIdentical(cache1, cache2));
  108. }
  109. TEST_F(NaClValidationCacheTest, SerializeDeserialize) {
  110. std::string key(key2);
  111. cache1.SetValidationCacheKey(key);
  112. cache1.SetKnownToValidate(sig1);
  113. cache1.SetKnownToValidate(sig2);
  114. base::Pickle pickle;
  115. cache1.Serialize(&pickle);
  116. ASSERT_TRUE(cache2.Deserialize(&pickle));
  117. ASSERT_EQ(2, (int) cache2.size());
  118. ASSERT_TRUE(IsIdentical(cache1, cache2));
  119. }
  120. TEST_F(NaClValidationCacheTest, SerializeDeserializeTruncated) {
  121. std::string key(key2);
  122. cache1.SetValidationCacheKey(key);
  123. cache1.SetKnownToValidate(sig1);
  124. cache1.SetKnownToValidate(sig2);
  125. base::Pickle pickle;
  126. cache1.Serialize(&pickle);
  127. base::Pickle truncated(static_cast<const char*>(pickle.data()),
  128. pickle.size() - 20);
  129. ASSERT_FALSE(cache2.Deserialize(&truncated));
  130. ASSERT_EQ(0, (int) cache2.size());
  131. }
  132. TEST_F(NaClValidationCacheTest, DeserializeBadKey) {
  133. std::string key(sig1); // Too short, will cause the deserialization to error.
  134. cache1.SetValidationCacheKey(key);
  135. cache1.SetKnownToValidate(sig1);
  136. cache1.SetKnownToValidate(sig2);
  137. base::Pickle pickle;
  138. cache1.Serialize(&pickle);
  139. ASSERT_FALSE(cache2.Deserialize(&pickle));
  140. ASSERT_EQ(0, (int) cache2.size());
  141. }
  142. TEST_F(NaClValidationCacheTest, DeserializeNothing) {
  143. cache1.SetKnownToValidate(sig1);
  144. base::Pickle pickle("", 0);
  145. ASSERT_FALSE(cache1.Deserialize(&pickle));
  146. ASSERT_EQ(0, (int) cache1.size());
  147. }
  148. TEST_F(NaClValidationCacheTest, DeserializeJunk) {
  149. cache1.SetKnownToValidate(sig1);
  150. base::Pickle pickle(key1, strlen(key1));
  151. ASSERT_FALSE(cache1.Deserialize(&pickle));
  152. ASSERT_EQ(0, (int) cache1.size());
  153. }
  154. }