chrome/browser/safe_browsing/protocol_parser_unittest.cc

   1 // Copyright (c) 2012 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 <string>
   6
   7 #include "base/strings/stringprintf.h"
   8 #include "base/time/time.h"
   9 #include "chrome/browser/safe_browsing/protocol_parser.h"
  10 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace {
  14
  15 #if defined(OS_ANDROID)
  16 const char kDefaultPhishList[] = "goog-mobilephish-shavar";
  17 const char kDefaultMalwareList[] = "goog-mobilemalware-shavar";
  18 #else
  19 const char kDefaultPhishList[] = "goog-phish-shavar";
  20 const char kDefaultMalwareList[] = "goog-malware-shavar";
  21 #endif
  22
  23 // Test parsing one add chunk.
  24 TEST(SafeBrowsingProtocolParsingTest, TestAddChunk) {
  25   const char kRawAddChunk[] = {
  26     '\0', '\0', '\0', '\x1C',  // 32-bit payload length in network byte order.
  27     '\x08',                    // field 1, wire format varint
  28     '\x01',                    // chunk_number varint 1
  29     '\x22',                    // field 4, wire format length-delimited
  30     '\x18',                    // varint length 24
  31     '1', '1', '1', '1',        // 4-byte prefixes
  32     '2', '2', '2', '2',
  33     '3', '3', '3', '3',
  34     '4', '4', '4', '4',
  35     '8', '8', '8', '8',
  36     '9', '9', '9', '9',
  37   };
  38
  39   ScopedVector<SBChunkData> chunks;
  40   EXPECT_TRUE(safe_browsing::ParseChunk(kRawAddChunk, sizeof(kRawAddChunk),
  41                                         &chunks));
  42   ASSERT_EQ(1U, chunks.size());
  43   EXPECT_EQ(1, chunks[0]->ChunkNumber());
  44   EXPECT_TRUE(chunks[0]->IsAdd());
  45   EXPECT_FALSE(chunks[0]->IsSub());
  46   EXPECT_TRUE(chunks[0]->IsPrefix());
  47   EXPECT_FALSE(chunks[0]->IsFullHash());
  48   ASSERT_EQ(6U, chunks[0]->PrefixCount());
  49   EXPECT_EQ(0x31313131U, chunks[0]->PrefixAt(0));  // 1111
  50   EXPECT_EQ(0x32323232U, chunks[0]->PrefixAt(1));  // 2222
  51   EXPECT_EQ(0x33333333U, chunks[0]->PrefixAt(2));  // 3333
  52   EXPECT_EQ(0x34343434U, chunks[0]->PrefixAt(3));  // 4444
  53   EXPECT_EQ(0x38383838U, chunks[0]->PrefixAt(4));  // 8888
  54   EXPECT_EQ(0x39393939U, chunks[0]->PrefixAt(5));  // 9999
  55 }
  56
  57 // Test parsing one add chunk with full hashes.
  58 TEST(SafeBrowsingProtocolParsingTest, TestAddFullChunk) {
  59   const char kRawAddChunk[] = {
  60     '\0', '\0', '\0', '\x46',  // 32-bit payload length in network byte order.
  61     '\x08',                    // field 1, wire format varint
  62     '\x01',                    // chunk_number varint 1
  63     '\x18',                    // field 3, wire format varint
  64     '\x01',                    // enum PrefixType == FULL_32B
  65     '\x22',                    // field 4, wire format length-delimited
  66     '\x40',                    // varint length 64 (2 full hashes)
  67
  68     '0', '1', '0', '1', '0', '1', '0', '1',
  69     '0', '1', '0', '1', '0', '1', '0', '1',
  70     '0', '1', '0', '1', '0', '1', '0', '1',
  71     '0', '1', '0', '1', '0', '1', '0', '1',
  72
  73     '2', '3', '2', '3', '2', '3', '2', '3',
  74     '2', '3', '2', '3', '2', '3', '2', '3',
  75     '2', '3', '2', '3', '2', '3', '2', '3',
  76     '2', '3', '2', '3', '2', '3', '2', '3',
  77   };
  78
  79   SBFullHash full_hash1, full_hash2;
  80   for (int i = 0; i < 32; ++i) {
  81     full_hash1.full_hash[i] = (i % 2) ? '1' : '0';
  82     full_hash2.full_hash[i] = (i % 2) ? '3' : '2';
  83   }
  84
  85   ScopedVector<SBChunkData> chunks;
  86   EXPECT_TRUE(safe_browsing::ParseChunk(kRawAddChunk, sizeof(kRawAddChunk),
  87                                         &chunks));
  88   ASSERT_EQ(1U, chunks.size());
  89   EXPECT_EQ(1, chunks[0]->ChunkNumber());
  90   EXPECT_TRUE(chunks[0]->IsAdd());
  91   EXPECT_FALSE(chunks[0]->IsSub());
  92   EXPECT_FALSE(chunks[0]->IsPrefix());
  93   EXPECT_TRUE(chunks[0]->IsFullHash());
  94
  95   ASSERT_EQ(2U, chunks[0]->FullHashCount());
  96   EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1));
  97   EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2));
  98 }
  99
 100 // Test parsing multiple add chunks. We'll use the same chunk as above, and add
 101 // one more after it.
 102 TEST(SafeBrowsingProtocolParsingTest, TestAddChunks) {
 103   const char kRawAddChunk[] = {
 104     '\0', '\0', '\0', '\x1C',  // 32-bit payload length in network byte order.
 105     '\x08',                    // field 1, wire format varint
 106     '\x01',                    // chunk_number varint 1
 107     '\x22',                    // field 4, wire format length-delimited
 108     '\x18',                    // varint length 24
 109
 110     '1', '1', '1', '1',        // 4-byte prefixes
 111     '2', '2', '2', '2',
 112     '3', '3', '3', '3',
 113     '4', '4', '4', '4',
 114     '8', '8', '8', '8',
 115     '9', '9', '9', '9',
 116
 117     '\0', '\0', '\0', '\x0C',  // 32-bit payload length in network byte order.
 118     '\x08',                    // field 1, wire format varint
 119     '\x02',                    // chunk_number varint 1
 120     '\x22',                    // field 4, wire format length-delimited
 121     '\x08',                    // varint length 8
 122     'p', 'p', 'p', 'p',        // 4-byte prefixes
 123     'g', 'g', 'g', 'g',
 124   };
 125
 126   ScopedVector<SBChunkData> chunks;
 127   EXPECT_TRUE(safe_browsing::ParseChunk(kRawAddChunk, sizeof(kRawAddChunk),
 128                                         &chunks));
 129   ASSERT_EQ(2U, chunks.size());
 130
 131   EXPECT_EQ(1, chunks[0]->ChunkNumber());
 132   EXPECT_TRUE(chunks[0]->IsAdd());
 133   EXPECT_FALSE(chunks[0]->IsSub());
 134   EXPECT_TRUE(chunks[0]->IsPrefix());
 135   EXPECT_FALSE(chunks[0]->IsFullHash());
 136   ASSERT_EQ(6U, chunks[0]->PrefixCount());
 137   EXPECT_EQ(0x31313131U, chunks[0]->PrefixAt(0));  // 1111
 138   EXPECT_EQ(0x32323232U, chunks[0]->PrefixAt(1));  // 2222
 139   EXPECT_EQ(0x33333333U, chunks[0]->PrefixAt(2));  // 3333
 140   EXPECT_EQ(0x34343434U, chunks[0]->PrefixAt(3));  // 4444
 141   EXPECT_EQ(0x38383838U, chunks[0]->PrefixAt(4));  // 8888
 142   EXPECT_EQ(0x39393939U, chunks[0]->PrefixAt(5));  // 9999
 143
 144   EXPECT_EQ(2, chunks[1]->ChunkNumber());
 145   EXPECT_TRUE(chunks[1]->IsAdd());
 146   EXPECT_FALSE(chunks[1]->IsSub());
 147   EXPECT_TRUE(chunks[1]->IsPrefix());
 148   EXPECT_FALSE(chunks[1]->IsFullHash());
 149   ASSERT_EQ(2U, chunks[1]->PrefixCount());
 150   EXPECT_EQ(0x70707070U, chunks[1]->PrefixAt(0));  // pppp
 151   EXPECT_EQ(0x67676767U, chunks[1]->PrefixAt(1));  // gggg
 152 }
 153
 154 TEST(SafeBrowsingProtocolParsingTest, TestTruncatedPrefixChunk) {
 155   // This chunk delares there are 6 prefixes but actually only contains 3.
 156   const char kRawAddChunk[] = {
 157     '\0', '\0', '\0', '\x1C',  // 32-bit payload length in network byte order.
 158     '\x08',                    // field 1, wire format varint
 159     '\x01',                    // chunk_number varint 1
 160     '\x22',                    // field 4, wire format length-delimited
 161     '\x18',                    // varint length 24
 162     '1', '1', '1', '1',        // 4-byte prefixes
 163     '2', '2', '2', '2',
 164     '3', '3', '3', '3',
 165   };
 166
 167   ScopedVector<SBChunkData> chunks;
 168   EXPECT_FALSE(safe_browsing::ParseChunk(kRawAddChunk, sizeof(kRawAddChunk),
 169                                          &chunks));
 170 }
 171
 172 TEST(SafeBrowsingProtocolParsingTest, TestTruncatedFullHashChunk) {
 173   // This chunk delares there are two full hashes but there is only one.
 174   const char kRawAddChunk[] = {
 175     '\0', '\0', '\0', '\x46',  // 32-bit payload length in network byte order.
 176     '\x08',                    // field 1, wire format varint
 177     '\x01',                    // chunk_number varint 1
 178     '\x18',                    // field 3, wire format varint
 179     '\x01',                    // enum PrefixType == FULL_32B
 180     '\x22',                    // field 4, wire format length-delimited
 181     '\x40',                    // varint length 64 (2 full hashes)
 182
 183     '0', '1', '0', '1', '0', '1', '0', '1',
 184     '0', '1', '0', '1', '0', '1', '0', '1',
 185     '0', '1', '0', '1', '0', '1', '0', '1',
 186     '0', '1', '0', '1', '0', '1', '0', '1',
 187   };
 188
 189   ScopedVector<SBChunkData> chunks;
 190   EXPECT_FALSE(safe_browsing::ParseChunk(kRawAddChunk, sizeof(kRawAddChunk),
 191                                          &chunks));
 192 }
 193
 194 TEST(SafeBrowsingProtocolParsingTest, TestHugeChunk) {
 195   // This chunk delares there are 6 prefixes but actually only contains 3.
 196   const char kRawAddChunk[] = {
 197     '\x1', '\0', '\0', '\0',   // 32-bit payload length in network byte order.
 198     '\x08',                    // field 1, wire format varint
 199     '\x01',                    // chunk_number varint 1
 200     '\x22',                    // field 4, wire format length-delimited
 201     '\x18',                    // varint length 24
 202     '1', '1', '1', '1',        // 4-byte prefixes
 203     '2', '2', '2', '2',
 204     '3', '3', '3', '3',
 205   };
 206
 207   ScopedVector<SBChunkData> chunks;
 208   EXPECT_FALSE(safe_browsing::ParseChunk(kRawAddChunk, sizeof(kRawAddChunk),
 209                                          &chunks));
 210 }
 211
 212 // Test parsing one sub chunk.
 213 TEST(SafeBrowsingProtocolParsingTest, TestSubChunk) {
 214   const char kRawSubChunk[] = {
 215     '\0', '\0', '\0', '\x12',  // 32-bit payload length in network byte order
 216     '\x08',                    // field 1, wire format varint
 217     '\x03',                    // chunk_number varint 3
 218     '\x10',                    // field 2, wire format varint
 219     '\x01',                    // enum ChunkType == SUB
 220     '\x22',                    // field 4, wire format length-delimited
 221     '\x08',                    // varint length 8 (2 prefixes)
 222     '1', '1', '1', '1',        // 4-byte prefixes
 223     '2', '2', '2', '2',
 224     '\x2a',                    // field 5, wire format length-delimited
 225     '\x02',                    // varint length 2 (2 add-chunk numbers)
 226     '\x07', '\x09',            // varint 7, varint 9
 227   };
 228
 229   ScopedVector<SBChunkData> chunks;
 230   EXPECT_TRUE(safe_browsing::ParseChunk(kRawSubChunk, sizeof(kRawSubChunk),
 231                                         &chunks));
 232   ASSERT_EQ(1U, chunks.size());
 233   EXPECT_EQ(3, chunks[0]->ChunkNumber());
 234   EXPECT_FALSE(chunks[0]->IsAdd());
 235   EXPECT_TRUE(chunks[0]->IsSub());
 236   EXPECT_TRUE(chunks[0]->IsPrefix());
 237   EXPECT_FALSE(chunks[0]->IsFullHash());
 238   ASSERT_EQ(2U, chunks[0]->PrefixCount());
 239   EXPECT_EQ(0x31313131U, chunks[0]->PrefixAt(0));  // 1111
 240   EXPECT_EQ(7, chunks[0]->AddChunkNumberAt(0));
 241   EXPECT_EQ(0x32323232U, chunks[0]->PrefixAt(1));  // 2222
 242   EXPECT_EQ(9, chunks[0]->AddChunkNumberAt(1));
 243 }
 244
 245 // Test parsing one sub chunk with full hashes.
 246 TEST(SafeBrowsingProtocolParsingTest, TestSubFullChunk) {
 247   const char kRawSubChunk[] = {
 248     '\0', '\0', '\0', '\x4C',  // 32-bit payload length in network byte order.
 249     '\x08',                    // field 1, wire format varint
 250     '\x02',                    // chunk_number varint 2
 251     '\x10',                    // field 2, wire format varint
 252     '\x01',                    // enum ChunkType == SUB
 253     '\x18',                    // field 3, wire format varint
 254     '\x01',                    // enum PrefixType == FULL_32B
 255     '\x22',                    // field 4, wire format length-delimited
 256     '\x40',                    // varint length 64 (2 full hashes)
 257
 258     '0', '1', '0', '1', '0', '1', '0', '1',
 259     '0', '1', '0', '1', '0', '1', '0', '1',
 260     '0', '1', '0', '1', '0', '1', '0', '1',
 261     '0', '1', '0', '1', '0', '1', '0', '1',
 262
 263     '2', '3', '2', '3', '2', '3', '2', '3',
 264     '2', '3', '2', '3', '2', '3', '2', '3',
 265     '2', '3', '2', '3', '2', '3', '2', '3',
 266     '2', '3', '2', '3', '2', '3', '2', '3',
 267
 268     '\x2a',                    // field 5, wire format length-delimited
 269     '\x02',                    // varint length 2 (2 add-chunk numbers)
 270     '\x07', '\x09',            // varint 7, varint 9
 271   };
 272
 273   SBFullHash full_hash1, full_hash2;
 274   for (int i = 0; i < 32; ++i) {
 275     full_hash1.full_hash[i] = i % 2 ? '1' : '0';
 276     full_hash2.full_hash[i] = i % 2 ? '3' : '2';
 277   }
 278
 279   ScopedVector<SBChunkData> chunks;
 280   EXPECT_TRUE(safe_browsing::ParseChunk(kRawSubChunk, sizeof(kRawSubChunk),
 281                                         &chunks));
 282   ASSERT_EQ(1U, chunks.size());
 283   EXPECT_EQ(2, chunks[0]->ChunkNumber());
 284   EXPECT_FALSE(chunks[0]->IsAdd());
 285   EXPECT_TRUE(chunks[0]->IsSub());
 286   EXPECT_FALSE(chunks[0]->IsPrefix());
 287   EXPECT_TRUE(chunks[0]->IsFullHash());
 288
 289   ASSERT_EQ(2U, chunks[0]->FullHashCount());
 290   EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1));
 291   EXPECT_EQ(7, chunks[0]->AddChunkNumberAt(0));
 292   EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2));
 293   EXPECT_EQ(9, chunks[0]->AddChunkNumberAt(1));
 294 }
 295
 296 // Test parsing the SafeBrowsing update response.
 297 TEST(SafeBrowsingProtocolParsingTest, TestChunkDelete) {
 298   std::string add_del("n:1700\ni:phishy\nad:1-7,43-597,44444,99999\n"
 299                       "i:malware\nsd:21-27,42,171717\n");
 300
 301   size_t next_query_sec = 0;
 302   bool reset = false;
 303   std::vector<SBChunkDelete> deletes;
 304   std::vector<ChunkUrl> urls;
 305   EXPECT_TRUE(safe_browsing::ParseUpdate(add_del.data(), add_del.length(),
 306                                          &next_query_sec, &reset,
 307                                          &deletes, &urls));
 308
 309   EXPECT_TRUE(urls.empty());
 310   EXPECT_FALSE(reset);
 311   EXPECT_EQ(1700U, next_query_sec);
 312   ASSERT_EQ(2U, deletes.size());
 313
 314   ASSERT_EQ(4U, deletes[0].chunk_del.size());
 315   EXPECT_TRUE(deletes[0].chunk_del[0] == ChunkRange(1, 7));
 316   EXPECT_TRUE(deletes[0].chunk_del[1] == ChunkRange(43, 597));
 317   EXPECT_TRUE(deletes[0].chunk_del[2] == ChunkRange(44444));
 318   EXPECT_TRUE(deletes[0].chunk_del[3] == ChunkRange(99999));
 319
 320   ASSERT_EQ(3U, deletes[1].chunk_del.size());
 321   EXPECT_TRUE(deletes[1].chunk_del[0] == ChunkRange(21, 27));
 322   EXPECT_TRUE(deletes[1].chunk_del[1] == ChunkRange(42));
 323   EXPECT_TRUE(deletes[1].chunk_del[2] == ChunkRange(171717));
 324
 325   // An update response with missing list name.
 326   next_query_sec = 0;
 327   deletes.clear();
 328   urls.clear();
 329   add_del = "n:1700\nad:1-7,43-597,44444,99999\ni:malware\nsd:4,21-27171717\n";
 330   EXPECT_FALSE(safe_browsing::ParseUpdate(add_del.data(), add_del.length(),
 331                                           &next_query_sec, &reset,
 332                                           &deletes, &urls));
 333 }
 334
 335 // Test parsing the SafeBrowsing update response.
 336 TEST(SafeBrowsingProtocolParsingTest, TestRedirects) {
 337   const std::string redirects(base::StringPrintf(
 338       "i:%s\n"
 339       "u:cache.googlevideo.com/safebrowsing/rd/goog-malware-shavar_s_1\n"
 340       "u:cache.googlevideo.com/safebrowsing/rd/goog-malware-shavar_s_2\n"
 341       "u:cache.googlevideo.com/safebrowsing/rd/goog-malware-shavar_s_3\n"
 342       "u:s.ytimg.com/safebrowsing/rd/goog-phish-shavar_a_8641-8800:8641-8689,"
 343       "8691-8731,8733-8786\n",
 344       kDefaultMalwareList));
 345
 346   size_t next_query_sec = 0;
 347   bool reset = false;
 348   std::vector<SBChunkDelete> deletes;
 349   std::vector<ChunkUrl> urls;
 350   EXPECT_TRUE(safe_browsing::ParseUpdate(redirects.data(), redirects.length(),
 351                                          &next_query_sec, &reset,
 352                                          &deletes, &urls));
 353   EXPECT_FALSE(reset);
 354   EXPECT_EQ(0U, next_query_sec);
 355   EXPECT_TRUE(deletes.empty());
 356
 357   ASSERT_EQ(4U, urls.size());
 358   EXPECT_EQ("cache.googlevideo.com/safebrowsing/rd/goog-malware-shavar_s_1",
 359             urls[0].url);
 360   EXPECT_EQ("cache.googlevideo.com/safebrowsing/rd/goog-malware-shavar_s_2",
 361             urls[1].url);
 362   EXPECT_EQ("cache.googlevideo.com/safebrowsing/rd/goog-malware-shavar_s_3",
 363             urls[2].url);
 364   EXPECT_EQ("s.ytimg.com/safebrowsing/rd/goog-phish-shavar_a_8641-8800:"
 365             "8641-8689,8691-8731,8733-8786",
 366             urls[3].url);
 367 }
 368
 369 // Test parsing various SafeBrowsing protocol headers.
 370 TEST(SafeBrowsingProtocolParsingTest, TestNextQueryTime) {
 371   std::string headers("n:1800\ni:goog-white-shavar\n");
 372   size_t next_query_sec = 0;
 373   bool reset = false;
 374   std::vector<SBChunkDelete> deletes;
 375   std::vector<ChunkUrl> urls;
 376   EXPECT_TRUE(safe_browsing::ParseUpdate(headers.data(), headers.length(),
 377                                          &next_query_sec, &reset,
 378                                          &deletes, &urls));
 379
 380   EXPECT_EQ(1800U, next_query_sec);
 381   EXPECT_FALSE(reset);
 382   EXPECT_TRUE(deletes.empty());
 383   EXPECT_TRUE(urls.empty());
 384 }
 385
 386 // Test parsing data from a GetHashRequest
 387 TEST(SafeBrowsingProtocolParsingTest, TestGetHash) {
 388   const std::string get_hash(base::StringPrintf(
 389       "45\n"
 390       "%s:32:3\n"
 391       "00112233445566778899aabbccddeeff"
 392       "00001111222233334444555566667777"
 393       "ffffeeeeddddccccbbbbaaaa99998888",
 394       kDefaultPhishList));
 395   std::vector<SBFullHashResult> full_hashes;
 396   base::TimeDelta cache_lifetime;
 397   EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash.data(), get_hash.length(),
 398                                           &cache_lifetime, &full_hashes));
 399
 400   ASSERT_EQ(3U, full_hashes.size());
 401   EXPECT_EQ(memcmp(&full_hashes[0].hash,
 402                    "00112233445566778899aabbccddeeff",
 403                    sizeof(SBFullHash)), 0);
 404   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id);
 405   EXPECT_EQ(memcmp(&full_hashes[1].hash,
 406                    "00001111222233334444555566667777",
 407                    sizeof(SBFullHash)), 0);
 408   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[1].list_id);
 409   EXPECT_EQ(memcmp(&full_hashes[2].hash,
 410                    "ffffeeeeddddccccbbbbaaaa99998888",
 411                    sizeof(SBFullHash)), 0);
 412   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[2].list_id);
 413
 414   // Test multiple lists in the GetHash results.
 415   const std::string get_hash2(base::StringPrintf(
 416       "45\n"
 417       "%s:32:1\n"
 418       "00112233445566778899aabbccddeeff"
 419       "%s:32:2\n"
 420       "cafebeefcafebeefdeaddeaddeaddead"
 421       "zzzzyyyyxxxxwwwwvvvvuuuuttttssss",
 422       kDefaultPhishList,
 423       kDefaultMalwareList));
 424   EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash2.data(), get_hash2.length(),
 425                                           &cache_lifetime, &full_hashes));
 426
 427   ASSERT_EQ(3U, full_hashes.size());
 428   EXPECT_EQ(memcmp(&full_hashes[0].hash,
 429                    "00112233445566778899aabbccddeeff",
 430                    sizeof(SBFullHash)), 0);
 431   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id);
 432   EXPECT_EQ(memcmp(&full_hashes[1].hash,
 433                    "cafebeefcafebeefdeaddeaddeaddead",
 434                    sizeof(SBFullHash)), 0);
 435   EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id);
 436   EXPECT_EQ(memcmp(&full_hashes[2].hash,
 437                    "zzzzyyyyxxxxwwwwvvvvuuuuttttssss",
 438                    sizeof(SBFullHash)), 0);
 439   EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[2].list_id);
 440
 441   // Test metadata parsing.
 442   const std::string get_hash3(base::StringPrintf(
 443       "45\n"
 444       "%s:32:2:m\n"
 445       "zzzzyyyyxxxxwwwwvvvvuuuuttttssss"
 446       "00112233445566778899aabbccddeeff"
 447       "2\nab2\nxy"
 448       "%s:32:1\n"
 449       "cafebeefcafebeefdeaddeaddeaddead",
 450       kDefaultMalwareList,
 451       kDefaultPhishList));
 452   EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash3.data(), get_hash3.length(),
 453                                           &cache_lifetime, &full_hashes));
 454
 455   ASSERT_EQ(3U, full_hashes.size());
 456   EXPECT_EQ(memcmp(&full_hashes[0].hash,
 457                    "zzzzyyyyxxxxwwwwvvvvuuuuttttssss",
 458                    sizeof(SBFullHash)), 0);
 459   EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[0].list_id);
 460   EXPECT_EQ(std::string("ab"), full_hashes[0].metadata);
 461   EXPECT_EQ(memcmp(&full_hashes[1].hash,
 462                    "00112233445566778899aabbccddeeff",
 463                    sizeof(SBFullHash)), 0);
 464   EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id);
 465   EXPECT_EQ(std::string("xy"), full_hashes[1].metadata);
 466   EXPECT_EQ(memcmp(&full_hashes[2].hash,
 467                    "cafebeefcafebeefdeaddeaddeaddead",
 468                    sizeof(SBFullHash)), 0);
 469   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[2].list_id);
 470   EXPECT_EQ(std::string(), full_hashes[2].metadata);
 471 }
 472
 473 TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownList) {
 474   std::string hash_response(base::StringPrintf(
 475       "45\n"
 476       "%s:32:1\n"
 477       "12345678901234567890123456789012"
 478       "googpub-phish-shavar:32:1\n"
 479       "09876543210987654321098765432109",
 480       kDefaultPhishList));
 481   std::vector<SBFullHashResult> full_hashes;
 482   base::TimeDelta cache_lifetime;
 483   EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(),
 484                                           hash_response.size(),
 485                                           &cache_lifetime,
 486                                           &full_hashes));
 487
 488   ASSERT_EQ(1U, full_hashes.size());
 489   EXPECT_EQ(memcmp("12345678901234567890123456789012",
 490                    &full_hashes[0].hash, sizeof(SBFullHash)), 0);
 491   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id);
 492
 493   hash_response += base::StringPrintf(
 494       "%s:32:1\n"
 495       "abcdefghijklmnopqrstuvwxyz123457",
 496       kDefaultMalwareList);
 497   full_hashes.clear();
 498   EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(),
 499                                           hash_response.size(),
 500                                           &cache_lifetime,
 501                                           &full_hashes));
 502
 503   EXPECT_EQ(2U, full_hashes.size());
 504   EXPECT_EQ(memcmp("12345678901234567890123456789012",
 505                    &full_hashes[0].hash, sizeof(SBFullHash)), 0);
 506   EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id);
 507   EXPECT_EQ(memcmp("abcdefghijklmnopqrstuvwxyz123457",
 508                    &full_hashes[1].hash, sizeof(SBFullHash)), 0);
 509   EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id);
 510 }
 511
 512 TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownListAndMetadata) {
 513   std::vector<SBFullHashResult> full_hashes;
 514   base::TimeDelta cache_lifetime;
 515   // Test skipping over a hashentry with an unrecognized listname that also has
 516   // metadata.
 517   const std::string get_hash3(base::StringPrintf(
 518       "600\n"
 519       "BADLISTNAME:32:1:m\n"
 520       "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
 521       "8\nMETADATA"
 522       "%s:32:1\n"
 523       "0123456789hashhashhashhashhashha",
 524       kDefaultMalwareList));
 525   EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash3.data(), get_hash3.length(),
 526                                           &cache_lifetime, &full_hashes));
 527   ASSERT_EQ(1U, full_hashes.size());
 528   EXPECT_EQ(memcmp(&full_hashes[0].hash,
 529                    "0123456789hashhashhashhashhashha",
 530                    sizeof(SBFullHash)), 0);
 531   EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[0].list_id);
 532   EXPECT_EQ(std::string(), full_hashes[0].metadata);
 533 }
 534
 535 TEST(SafeBrowsingProtocolParsingTest, TestFormatHash) {
 536   std::vector<SBPrefix> prefixes;
 537   prefixes.push_back(0x34333231);
 538   prefixes.push_back(0x64636261);
 539   prefixes.push_back(0x73727170);
 540
 541   EXPECT_EQ("4:12\n1234abcdpqrs", safe_browsing::FormatGetHash(prefixes));
 542 }
 543
 544 TEST(SafeBrowsingProtocolParsingTest, TestReset) {
 545   std::string update("n:1800\ni:phishy\nr:pleasereset\n");
 546
 547   bool reset = false;
 548   size_t next_update = 0;
 549   std::vector<SBChunkDelete> deletes;
 550   std::vector<ChunkUrl> urls;
 551   EXPECT_TRUE(safe_browsing::ParseUpdate(update.data(), update.size(),
 552                                          &next_update, &reset,
 553                                          &deletes, &urls));
 554   EXPECT_TRUE(reset);
 555 }
 556
 557 // The SafeBrowsing service will occasionally send zero length chunks so that
 558 // client requests will have longer contiguous chunk number ranges, and thus
 559 // reduce the request size.
 560 TEST(SafeBrowsingProtocolParsingTest, TestZeroSizeAddChunk) {
 561   const char kEmptyAddChunk[] = {
 562     '\0', '\0', '\0', '\x02',  // 32-bit payload length in network byte order.
 563     '\x08',                    // field 1, wire format varint
 564     '\x02',                    // chunk_number varint 2
 565   };
 566
 567   ScopedVector<SBChunkData> chunks;
 568   EXPECT_TRUE(safe_browsing::ParseChunk(kEmptyAddChunk, sizeof(kEmptyAddChunk),
 569                                         &chunks));
 570   ASSERT_EQ(1U, chunks.size());
 571   EXPECT_EQ(2, chunks[0]->ChunkNumber());
 572   EXPECT_TRUE(chunks[0]->IsAdd());
 573   EXPECT_FALSE(chunks[0]->IsSub());
 574   EXPECT_TRUE(chunks[0]->IsPrefix());
 575   EXPECT_FALSE(chunks[0]->IsFullHash());
 576   EXPECT_EQ(0U, chunks[0]->PrefixCount());
 577
 578   // Now test a zero size chunk in between normal chunks.
 579   chunks.clear();
 580   const char kAddChunks[] = {
 581     '\0', '\0', '\0', '\x0C',  // 32-bit payload length in network byte order.
 582     '\x08',                    // field 1, wire format varint
 583     '\x01',                    // chunk_number varint 1
 584     '\x22',                    // field 4, wire format length-delimited
 585     '\x08',                    // varint length 8
 586
 587     '1', '1', '1', '1',        // 4-byte prefixes
 588     '2', '2', '2', '2',
 589
 590     '\0', '\0', '\0', '\x02',  // 32-bit payload length in network byte order.
 591     '\x08',                    // field 1, wire format varint
 592     '\x02',                    // chunk_number varint 2
 593
 594     '\0', '\0', '\0', '\x08',  // 32-bit payload length in network byte order.
 595     '\x08',                    // field 1, wire format varint
 596     '\x03',                    // chunk_number varint 3
 597     '\x22',                    // field 4, wire format length-delimited
 598     '\x04',                    // varint length 8
 599     'p', 'p', 'p', 'p',        // 4-byte prefixes
 600   };
 601   EXPECT_TRUE(safe_browsing::ParseChunk(kAddChunks, sizeof(kAddChunks),
 602                                         &chunks));
 603   ASSERT_EQ(3U, chunks.size());
 604
 605   EXPECT_EQ(1, chunks[0]->ChunkNumber());
 606   EXPECT_TRUE(chunks[0]->IsAdd());
 607   EXPECT_FALSE(chunks[0]->IsSub());
 608   EXPECT_TRUE(chunks[0]->IsPrefix());
 609   EXPECT_FALSE(chunks[0]->IsFullHash());
 610   ASSERT_EQ(2U, chunks[0]->PrefixCount());
 611   EXPECT_EQ(0x31313131U, chunks[0]->PrefixAt(0));  // 1111
 612   EXPECT_EQ(0x32323232U, chunks[0]->PrefixAt(1));  // 2222
 613
 614   EXPECT_EQ(2, chunks[1]->ChunkNumber());
 615   EXPECT_TRUE(chunks[1]->IsAdd());
 616   EXPECT_FALSE(chunks[1]->IsSub());
 617   EXPECT_TRUE(chunks[1]->IsPrefix());
 618   EXPECT_FALSE(chunks[1]->IsFullHash());
 619   EXPECT_EQ(0U, chunks[1]->PrefixCount());
 620
 621   EXPECT_EQ(3, chunks[2]->ChunkNumber());
 622   EXPECT_TRUE(chunks[2]->IsAdd());
 623   EXPECT_FALSE(chunks[2]->IsSub());
 624   EXPECT_TRUE(chunks[2]->IsPrefix());
 625   EXPECT_FALSE(chunks[2]->IsFullHash());
 626   ASSERT_EQ(1U, chunks[2]->PrefixCount());
 627   EXPECT_EQ(0x70707070U, chunks[2]->PrefixAt(0));  // pppp
 628 }
 629
 630 // Test parsing a zero sized sub chunk.
 631 TEST(SafeBrowsingProtocolParsingTest, TestZeroSizeSubChunk) {
 632   const char kEmptySubChunk[] = {
 633     '\0', '\0', '\0', '\x04',  // 32-bit payload length in network byte order.
 634     '\x08',                    // field 1, wire format varint
 635     '\x02',                    // chunk_number varint 2
 636     '\x10',                    // field 2, wire format varint
 637     '\x01',                    // enum ChunkType == SUB
 638   };
 639
 640   ScopedVector<SBChunkData> chunks;
 641   EXPECT_TRUE(safe_browsing::ParseChunk(kEmptySubChunk, sizeof(kEmptySubChunk),
 642                                         &chunks));
 643   ASSERT_EQ(1U, chunks.size());
 644   EXPECT_EQ(2, chunks[0]->ChunkNumber());
 645   EXPECT_FALSE(chunks[0]->IsAdd());
 646   EXPECT_TRUE(chunks[0]->IsSub());
 647   EXPECT_TRUE(chunks[0]->IsPrefix());
 648   EXPECT_FALSE(chunks[0]->IsFullHash());
 649   EXPECT_EQ(0U, chunks[0]->PrefixCount());
 650
 651   // Test parsing a zero sized sub chunk mixed in with content carrying chunks.
 652   chunks.clear();
 653   const char kSubChunks[] = {
 654     '\0', '\0', '\0', '\x12',  // 32-bit payload length in network byte order.
 655     '\x08',                    // field 1, wire format varint
 656     '\x01',                    // chunk_number varint 1
 657     '\x10',                    // field 2, wire format varint
 658     '\x01',                    // enum ChunkType == SUB
 659     '\x22',                    // field 4, wire format length-delimited
 660     '\x08',                    // varint length 8
 661     '1', '1', '1', '1',        // 4-byte prefixes
 662     '2', '2', '2', '2',
 663     '\x2a',                    // field 5, wire format length-delimited
 664     '\x02',                    // varint length 2 (2 add-chunk numbers)
 665     '\x07', '\x09',            // varint 7, varint 9
 666
 667     '\0', '\0', '\0', '\x04',  // 32-bit payload length in network byte order.
 668     '\x08',                    // field 1, wire format varint
 669     '\x02',                    // chunk_number varint 2
 670     '\x10',                    // field 2, wire format varint
 671     '\x01',                    // enum ChunkType == SUB
 672
 673     '\0', '\0', '\0', '\x0D',  // 32-bit payload length in network byte order.
 674     '\x08',                    // field 1, wire format varint
 675     '\x03',                    // chunk_number varint 3
 676     '\x10',                    // field 2, wire format varint
 677     '\x01',                    // enum ChunkType == SUB
 678     '\x22',                    // field 4, wire format length-delimited
 679     '\x04',                    // varint length 8
 680     'p', 'p', 'p', 'p',        // 4-byte prefix
 681     '\x2a',                    // field 5, wire format length-delimited
 682     '\x01',                    // varint length 1 (1 add-chunk numbers)
 683     '\x0B',                    // varint 11
 684   };
 685
 686   EXPECT_TRUE(safe_browsing::ParseChunk(kSubChunks, sizeof(kSubChunks),
 687                                         &chunks));
 688   ASSERT_EQ(3U, chunks.size());
 689
 690   EXPECT_EQ(1, chunks[0]->ChunkNumber());
 691   EXPECT_FALSE(chunks[0]->IsAdd());
 692   EXPECT_TRUE(chunks[0]->IsSub());
 693   EXPECT_TRUE(chunks[0]->IsPrefix());
 694   EXPECT_FALSE(chunks[0]->IsFullHash());
 695   ASSERT_EQ(2U, chunks[0]->PrefixCount());
 696   EXPECT_EQ(0x31313131U, chunks[0]->PrefixAt(0));  // 1111
 697   EXPECT_EQ(7, chunks[0]->AddChunkNumberAt(0));
 698   EXPECT_EQ(0x32323232U, chunks[0]->PrefixAt(1));  // 2222
 699   EXPECT_EQ(9, chunks[0]->AddChunkNumberAt(1));
 700
 701   EXPECT_EQ(2, chunks[1]->ChunkNumber());
 702   EXPECT_FALSE(chunks[0]->IsAdd());
 703   EXPECT_TRUE(chunks[0]->IsSub());
 704   EXPECT_TRUE(chunks[1]->IsPrefix());
 705   EXPECT_FALSE(chunks[1]->IsFullHash());
 706   EXPECT_EQ(0U, chunks[1]->PrefixCount());
 707
 708   EXPECT_EQ(3, chunks[2]->ChunkNumber());
 709   EXPECT_FALSE(chunks[0]->IsAdd());
 710   EXPECT_TRUE(chunks[0]->IsSub());
 711   EXPECT_TRUE(chunks[2]->IsPrefix());
 712   EXPECT_FALSE(chunks[2]->IsFullHash());
 713   ASSERT_EQ(1U, chunks[2]->PrefixCount());
 714   EXPECT_EQ(0x70707070U, chunks[2]->PrefixAt(0));  // pppp
 715   EXPECT_EQ(11, chunks[2]->AddChunkNumberAt(0));
 716 }
 717
 718 }  // namespace