chrome/browser/safe_browsing/safe_browsing_store_unittest.cc

   1 // Copyright (c) 2011 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
   5 #include "chrome/browser/safe_browsing/safe_browsing_store.h"
   6
   7 #include "testing/gtest/include/gtest/gtest.h"
   8
   9 namespace {
  10
  11 const SBFullHash kHash1 = SBFullHashForString("one");
  12 const SBFullHash kHash2 = SBFullHashForString("two");
  13 const SBFullHash kHash3 = SBFullHashForString("three");
  14 const SBFullHash kHash4 = SBFullHashForString("four");
  15 const SBFullHash kHash5 = SBFullHashForString("five");
  16 const SBFullHash kHash6 = SBFullHashForString("six");
  17 const SBFullHash kHash7 = SBFullHashForString("seven");
  18
  19 const int kAddChunk1 = 1;  // Use different chunk numbers just in case.
  20 const int kSubChunk1 = 2;
  21 const int kAddChunk2 = 3;
  22 const int kSubChunk2 = 4;
  23 const int kAddChunk3 = 5;
  24 const int kSubChunk3 = 6;
  25 const int kAddChunk4 = 7;
  26 const int kSubChunk4 = 8;
  27 const int kAddChunk5 = 9;
  28 const int kSubChunk5 = 10;
  29 const int kAddChunk6 = 11;
  30 const int kAddChunk7 = 12;
  31
  32 SBFullHash ModifyHashAfterPrefix(SBFullHash hash, unsigned char mask) {
  33   hash.full_hash[sizeof(hash.full_hash) - 1] ^= mask;
  34   return hash;
  35 }
  36
  37 void ProcessHelper(SBAddPrefixes* add_prefixes,
  38                    SBSubPrefixes* sub_prefixes,
  39                    std::vector<SBAddFullHash>* add_full_hashes,
  40                    std::vector<SBSubFullHash>* sub_full_hashes,
  41                    const base::hash_set<int32>& add_chunks_deleted,
  42                    const base::hash_set<int32>& sub_chunks_deleted) {
  43   std::sort(add_prefixes->begin(), add_prefixes->end(),
  44             SBAddPrefixLess<SBAddPrefix,SBAddPrefix>);
  45   std::sort(sub_prefixes->begin(), sub_prefixes->end(),
  46             SBAddPrefixLess<SBSubPrefix,SBSubPrefix>);
  47   std::sort(add_full_hashes->begin(), add_full_hashes->end(),
  48             SBAddPrefixHashLess<SBAddFullHash,SBAddFullHash>);
  49   std::sort(sub_full_hashes->begin(), sub_full_hashes->end(),
  50             SBAddPrefixHashLess<SBSubFullHash,SBSubFullHash>);
  51
  52   SBProcessSubs(add_prefixes, sub_prefixes, add_full_hashes, sub_full_hashes,
  53                 add_chunks_deleted, sub_chunks_deleted);
  54 }
  55
  56 TEST(SafeBrowsingStoreTest, SBAddPrefixLess) {
  57   // prefix dominates.
  58   EXPECT_TRUE(SBAddPrefixLess(SBAddPrefix(11, 1), SBAddPrefix(10, 2)));
  59   EXPECT_FALSE(SBAddPrefixLess(SBAddPrefix(10, 2), SBAddPrefix(11, 1)));
  60
  61   // After prefix, chunk_id.
  62   EXPECT_TRUE(SBAddPrefixLess(SBAddPrefix(10, 1), SBAddPrefix(11, 1)));
  63   EXPECT_FALSE(SBAddPrefixLess(SBAddPrefix(11, 1), SBAddPrefix(10, 1)));
  64
  65   // Equal is not less-than.
  66   EXPECT_FALSE(SBAddPrefixLess(SBAddPrefix(10, 1), SBAddPrefix(10, 1)));
  67 }
  68
  69 TEST(SafeBrowsingStoreTest, SBAddPrefixHashLess) {
  70   // The first four bytes of SBFullHash can be read as a SBPrefix, which
  71   // means that byte-ordering issues can come up.  To test this, |one|
  72   // and |two| differ in the prefix, while |one| and |onetwo| have the
  73   // same prefix, but differ in the byte after the prefix.
  74   SBFullHash one, onetwo, two;
  75   memset(&one, 0, sizeof(one));
  76   memset(&onetwo, 0, sizeof(onetwo));
  77   memset(&two, 0, sizeof(two));
  78   one.prefix = 1;
  79   one.full_hash[sizeof(SBPrefix)] = 1;
  80   onetwo.prefix = 1;
  81   onetwo.full_hash[sizeof(SBPrefix)] = 2;
  82   two.prefix = 2;
  83
  84   // prefix dominates.
  85   EXPECT_TRUE(SBAddPrefixHashLess(SBAddFullHash(11, one),
  86                                   SBAddFullHash(10, two)));
  87   EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(11, two),
  88                                    SBAddFullHash(10, one)));
  89
  90   // After prefix, add_id.
  91   EXPECT_TRUE(SBAddPrefixHashLess(SBAddFullHash(10, one),
  92                                   SBAddFullHash(11, onetwo)));
  93   EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(11, one),
  94                                    SBAddFullHash(10, onetwo)));
  95
  96   // After add_id, full hash.
  97   EXPECT_TRUE(SBAddPrefixHashLess(SBAddFullHash(10, one),
  98                                   SBAddFullHash(10, onetwo)));
  99   EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(10, onetwo),
 100                                    SBAddFullHash(10, one)));
 101
 102   // Equal is not less-than.
 103   EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(10, one),
 104                                    SBAddFullHash(10, one)));
 105 }
 106
 107 TEST(SafeBrowsingStoreTest, SBSubPrefixLess) {
 108   // prefix dominates.
 109   EXPECT_TRUE(SBAddPrefixLess(SBSubPrefix(12, 11, 1), SBSubPrefix(9, 10, 2)));
 110   EXPECT_FALSE(SBAddPrefixLess(SBSubPrefix(12, 11, 2), SBSubPrefix(9, 10, 1)));
 111
 112   // After prefix, add_id.
 113   EXPECT_TRUE(SBAddPrefixLess(SBSubPrefix(12, 9, 1), SBSubPrefix(9, 10, 1)));
 114   EXPECT_FALSE(SBAddPrefixLess(SBSubPrefix(12, 10, 1), SBSubPrefix(9, 9, 1)));
 115
 116   // Equal is not less-than.
 117   EXPECT_FALSE(SBAddPrefixLess(SBSubPrefix(12, 10, 1), SBSubPrefix(12, 10, 1)));
 118
 119   // chunk_id doesn't matter.
 120 }
 121
 122 TEST(SafeBrowsingStoreTest, SBSubFullHashLess) {
 123   SBFullHash one, onetwo, two;
 124   memset(&one, 0, sizeof(one));
 125   memset(&onetwo, 0, sizeof(onetwo));
 126   memset(&two, 0, sizeof(two));
 127   one.prefix = 1;
 128   one.full_hash[sizeof(SBPrefix)] = 1;
 129   onetwo.prefix = 1;
 130   onetwo.full_hash[sizeof(SBPrefix)] = 2;
 131   two.prefix = 2;
 132
 133   // prefix dominates.
 134   EXPECT_TRUE(SBAddPrefixHashLess(SBSubFullHash(12, 11, one),
 135                                   SBSubFullHash(9, 10, two)));
 136   EXPECT_FALSE(SBAddPrefixHashLess(SBSubFullHash(12, 11, two),
 137                                    SBSubFullHash(9, 10, one)));
 138
 139   // After prefix, add_id.
 140   EXPECT_TRUE(SBAddPrefixHashLess(SBSubFullHash(12, 10, one),
 141                                   SBSubFullHash(9, 11, onetwo)));
 142   EXPECT_FALSE(SBAddPrefixHashLess(SBSubFullHash(12, 11, one),
 143                                    SBSubFullHash(9, 10, onetwo)));
 144
 145   // After add_id, full_hash.
 146   EXPECT_TRUE(SBAddPrefixHashLess(SBSubFullHash(12, 10, one),
 147                                   SBSubFullHash(9, 10, onetwo)));
 148   EXPECT_FALSE(SBAddPrefixHashLess(SBSubFullHash(12, 10, onetwo),
 149                                    SBSubFullHash(9, 10, one)));
 150
 151   // Equal is not less-than.
 152   EXPECT_FALSE(SBAddPrefixHashLess(SBSubFullHash(12, 10, one),
 153                                    SBSubFullHash(9, 10, one)));
 154 }
 155
 156 // SBProcessSubs does a lot of iteration, run through empty just to
 157 // make sure degenerate cases work.
 158 TEST(SafeBrowsingStoreTest, SBProcessSubsEmpty) {
 159   SBAddPrefixes add_prefixes;
 160   std::vector<SBAddFullHash> add_hashes;
 161   SBSubPrefixes sub_prefixes;
 162   std::vector<SBSubFullHash> sub_hashes;
 163
 164   const base::hash_set<int32> no_deletions;
 165   SBProcessSubs(&add_prefixes, &sub_prefixes, &add_hashes, &sub_hashes,
 166                 no_deletions, no_deletions);
 167   EXPECT_TRUE(add_prefixes.empty());
 168   EXPECT_TRUE(sub_prefixes.empty());
 169   EXPECT_TRUE(add_hashes.empty());
 170   EXPECT_TRUE(sub_hashes.empty());
 171 }
 172
 173 // Test that subs knock out adds.
 174 TEST(SafeBrowsingStoreTest, SBProcessSubsKnockout) {
 175   // A full hash which shares prefix with another.
 176   const SBFullHash kHash1mod = ModifyHashAfterPrefix(kHash1, 1);
 177
 178   // A second full-hash for the full-hash-sub test.
 179   const SBFullHash kHash4mod = ModifyHashAfterPrefix(kHash4, 1);
 180
 181   SBAddPrefixes add_prefixes;
 182   std::vector<SBAddFullHash> add_hashes;
 183   SBSubPrefixes sub_prefixes;
 184   std::vector<SBSubFullHash> sub_hashes;
 185
 186   // An add prefix plus a sub to knock it out.
 187   add_prefixes.push_back(SBAddPrefix(kAddChunk1, kHash5.prefix));
 188   sub_prefixes.push_back(SBSubPrefix(kSubChunk1, kAddChunk1, kHash5.prefix));
 189
 190   // Add hashes with same prefix, plus subs to knock them out.
 191   add_hashes.push_back(SBAddFullHash(kAddChunk2, kHash1));
 192   add_hashes.push_back(SBAddFullHash(kAddChunk2, kHash1mod));
 193   sub_hashes.push_back(SBSubFullHash(kSubChunk2, kAddChunk2, kHash1));
 194   sub_hashes.push_back(SBSubFullHash(kSubChunk2, kAddChunk2, kHash1mod));
 195
 196   // Adds with no corresponding sub.  Both items should be retained.
 197   add_hashes.push_back(SBAddFullHash(kAddChunk6, kHash6));
 198   add_prefixes.push_back(SBAddPrefix(kAddChunk7, kHash2.prefix));
 199
 200   // Subs with no corresponding add.  Both items should be retained.
 201   sub_hashes.push_back(SBSubFullHash(kSubChunk3, kAddChunk3, kHash7));
 202   sub_prefixes.push_back(SBSubPrefix(kSubChunk4, kAddChunk4, kHash3.prefix));
 203
 204   // Add hashes with the same prefix, with a sub that will knock one of them
 205   // out.
 206   add_hashes.push_back(SBAddFullHash(kAddChunk5, kHash4));
 207   add_hashes.push_back(SBAddFullHash(kAddChunk5, kHash4mod));
 208   sub_hashes.push_back(SBSubFullHash(kSubChunk5, kAddChunk5, kHash4mod));
 209
 210   const base::hash_set<int32> no_deletions;
 211   ProcessHelper(&add_prefixes, &sub_prefixes, &add_hashes, &sub_hashes,
 212                 no_deletions, no_deletions);
 213
 214   ASSERT_EQ(1U, add_prefixes.size());
 215   EXPECT_EQ(kAddChunk7, add_prefixes[0].chunk_id);
 216   EXPECT_EQ(kHash2.prefix, add_prefixes[0].prefix);
 217
 218   ASSERT_EQ(2U, add_hashes.size());
 219   EXPECT_EQ(kAddChunk5, add_hashes[0].chunk_id);
 220   EXPECT_TRUE(SBFullHashEqual(kHash4, add_hashes[0].full_hash));
 221   EXPECT_EQ(kAddChunk6, add_hashes[1].chunk_id);
 222   EXPECT_TRUE(SBFullHashEqual(kHash6, add_hashes[1].full_hash));
 223
 224   ASSERT_EQ(1U, sub_prefixes.size());
 225   EXPECT_EQ(kSubChunk4, sub_prefixes[0].chunk_id);
 226   EXPECT_EQ(kAddChunk4, sub_prefixes[0].add_chunk_id);
 227   EXPECT_EQ(kHash3.prefix, sub_prefixes[0].add_prefix);
 228
 229   ASSERT_EQ(1U, sub_hashes.size());
 230   EXPECT_EQ(kSubChunk3, sub_hashes[0].chunk_id);
 231   EXPECT_EQ(kAddChunk3, sub_hashes[0].add_chunk_id);
 232   EXPECT_TRUE(SBFullHashEqual(kHash7, sub_hashes[0].full_hash));
 233 }
 234
 235 // Test chunk deletions, and ordering of deletions WRT subs knocking
 236 // out adds.
 237 TEST(SafeBrowsingStoreTest, SBProcessSubsDeleteChunk) {
 238   // A full hash which shares prefix with another.
 239   const SBFullHash kHash1mod = ModifyHashAfterPrefix(kHash1, 1);
 240
 241   SBAddPrefixes add_prefixes;
 242   std::vector<SBAddFullHash> add_hashes;
 243   SBSubPrefixes sub_prefixes;
 244   std::vector<SBSubFullHash> sub_hashes;
 245
 246   // An add prefix plus a sub to knock it out.
 247   add_prefixes.push_back(SBAddPrefix(kAddChunk1, kHash5.prefix));
 248   sub_prefixes.push_back(SBSubPrefix(kSubChunk1, kAddChunk1, kHash5.prefix));
 249
 250   // Add hashes with same prefix, plus subs to knock them out.
 251   add_hashes.push_back(SBAddFullHash(kAddChunk1, kHash1));
 252   add_hashes.push_back(SBAddFullHash(kAddChunk1, kHash1mod));
 253   sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash1));
 254   sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash1mod));
 255
 256   // Adds with no corresponding sub.  Both items should be retained.
 257   add_hashes.push_back(SBAddFullHash(kAddChunk1, kHash6));
 258   add_prefixes.push_back(SBAddPrefix(kAddChunk1, kHash2.prefix));
 259
 260   // Subs with no corresponding add.  Both items should be retained.
 261   sub_hashes.push_back(SBSubFullHash(kSubChunk1, kAddChunk1, kHash7));
 262   sub_prefixes.push_back(SBSubPrefix(kSubChunk1, kAddChunk1, kHash3.prefix));
 263
 264   // Subs apply before being deleted.
 265   const base::hash_set<int32> no_deletions;
 266   base::hash_set<int32> sub_deletions;
 267   sub_deletions.insert(kSubChunk1);
 268   ProcessHelper(&add_prefixes, &sub_prefixes, &add_hashes, &sub_hashes,
 269                 no_deletions, sub_deletions);
 270
 271   ASSERT_EQ(1U, add_prefixes.size());
 272   EXPECT_EQ(kAddChunk1, add_prefixes[0].chunk_id);
 273   EXPECT_EQ(kHash2.prefix, add_prefixes[0].prefix);
 274
 275   ASSERT_EQ(1U, add_hashes.size());
 276   EXPECT_EQ(kAddChunk1, add_hashes[0].chunk_id);
 277   EXPECT_TRUE(SBFullHashEqual(kHash6, add_hashes[0].full_hash));
 278
 279   EXPECT_TRUE(sub_prefixes.empty());
 280   EXPECT_TRUE(sub_hashes.empty());
 281
 282   // Delete the adds, also.
 283   base::hash_set<int32> add_deletions;
 284   add_deletions.insert(kAddChunk1);
 285   ProcessHelper(&add_prefixes, &sub_prefixes, &add_hashes, &sub_hashes,
 286                 add_deletions, no_deletions);
 287
 288   EXPECT_TRUE(add_prefixes.empty());
 289   EXPECT_TRUE(add_hashes.empty());
 290   EXPECT_TRUE(sub_prefixes.empty());
 291   EXPECT_TRUE(sub_hashes.empty());
 292 }
 293
 294 TEST(SafeBrowsingStoreTest, Y2K38) {
 295   const base::Time now = base::Time::Now();
 296   const base::Time future = now + base::TimeDelta::FromDays(3*365);
 297
 298   // TODO: Fix file format before 2035.
 299   EXPECT_GT(static_cast<int32>(future.ToTimeT()), 0)
 300     << " (int32)time_t is running out.";
 301 }
 302
 303 }  // namespace