Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(87)

Side by Side Diff: chrome/browser/safe_browsing/protocol_parser_unittest.cc

Issue 1420123003: Move more declarations from c/b/sb/sb_util.h to components. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@01_components
Patch Set: Minor: Replace safe_browsing_util:: with safe_browsing:: and use safe_browsing:: namespace prefix Created 5 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include <string> 5 #include <string>
6 6
7 #include "base/strings/stringprintf.h" 7 #include "base/strings/stringprintf.h"
8 #include "base/time/time.h" 8 #include "base/time/time.h"
9 #include "chrome/browser/safe_browsing/protocol_parser.h" 9 #include "chrome/browser/safe_browsing/protocol_parser.h"
10 #include "chrome/browser/safe_browsing/safe_browsing_util.h" 10 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after
81 EXPECT_TRUE(safe_browsing::ParseChunk(kRawAddChunk, sizeof(kRawAddChunk), 81 EXPECT_TRUE(safe_browsing::ParseChunk(kRawAddChunk, sizeof(kRawAddChunk),
82 &chunks)); 82 &chunks));
83 ASSERT_EQ(1U, chunks.size()); 83 ASSERT_EQ(1U, chunks.size());
84 EXPECT_EQ(1, chunks[0]->ChunkNumber()); 84 EXPECT_EQ(1, chunks[0]->ChunkNumber());
85 EXPECT_TRUE(chunks[0]->IsAdd()); 85 EXPECT_TRUE(chunks[0]->IsAdd());
86 EXPECT_FALSE(chunks[0]->IsSub()); 86 EXPECT_FALSE(chunks[0]->IsSub());
87 EXPECT_FALSE(chunks[0]->IsPrefix()); 87 EXPECT_FALSE(chunks[0]->IsPrefix());
88 EXPECT_TRUE(chunks[0]->IsFullHash()); 88 EXPECT_TRUE(chunks[0]->IsFullHash());
89 89
90 ASSERT_EQ(2U, chunks[0]->FullHashCount()); 90 ASSERT_EQ(2U, chunks[0]->FullHashCount());
91 EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1)); 91 EXPECT_TRUE(
92 EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2)); 92 safe_browsing::SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1));
93 EXPECT_TRUE(
94 safe_browsing::SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2));
93 } 95 }
94 96
95 // Test parsing multiple add chunks. We'll use the same chunk as above, and add 97 // Test parsing multiple add chunks. We'll use the same chunk as above, and add
96 // one more after it. 98 // one more after it.
97 TEST(SafeBrowsingProtocolParsingTest, TestAddChunks) { 99 TEST(SafeBrowsingProtocolParsingTest, TestAddChunks) {
98 const char kRawAddChunk[] = { 100 const char kRawAddChunk[] = {
99 '\0', '\0', '\0', '\x1C', // 32-bit payload length in network byte order. 101 '\0', '\0', '\0', '\x1C', // 32-bit payload length in network byte order.
100 '\x08', // field 1, wire format varint 102 '\x08', // field 1, wire format varint
101 '\x01', // chunk_number varint 1 103 '\x01', // chunk_number varint 1
102 '\x22', // field 4, wire format length-delimited 104 '\x22', // field 4, wire format length-delimited
(...skipping 172 matching lines...) Expand 10 before | Expand all | Expand 10 after
275 EXPECT_TRUE(safe_browsing::ParseChunk(kRawSubChunk, sizeof(kRawSubChunk), 277 EXPECT_TRUE(safe_browsing::ParseChunk(kRawSubChunk, sizeof(kRawSubChunk),
276 &chunks)); 278 &chunks));
277 ASSERT_EQ(1U, chunks.size()); 279 ASSERT_EQ(1U, chunks.size());
278 EXPECT_EQ(2, chunks[0]->ChunkNumber()); 280 EXPECT_EQ(2, chunks[0]->ChunkNumber());
279 EXPECT_FALSE(chunks[0]->IsAdd()); 281 EXPECT_FALSE(chunks[0]->IsAdd());
280 EXPECT_TRUE(chunks[0]->IsSub()); 282 EXPECT_TRUE(chunks[0]->IsSub());
281 EXPECT_FALSE(chunks[0]->IsPrefix()); 283 EXPECT_FALSE(chunks[0]->IsPrefix());
282 EXPECT_TRUE(chunks[0]->IsFullHash()); 284 EXPECT_TRUE(chunks[0]->IsFullHash());
283 285
284 ASSERT_EQ(2U, chunks[0]->FullHashCount()); 286 ASSERT_EQ(2U, chunks[0]->FullHashCount());
285 EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1)); 287 EXPECT_TRUE(
288 safe_browsing::SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1));
286 EXPECT_EQ(7, chunks[0]->AddChunkNumberAt(0)); 289 EXPECT_EQ(7, chunks[0]->AddChunkNumberAt(0));
287 EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2)); 290 EXPECT_TRUE(
291 safe_browsing::SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2));
288 EXPECT_EQ(9, chunks[0]->AddChunkNumberAt(1)); 292 EXPECT_EQ(9, chunks[0]->AddChunkNumberAt(1));
289 } 293 }
290 294
291 // Test parsing the SafeBrowsing update response. 295 // Test parsing the SafeBrowsing update response.
292 TEST(SafeBrowsingProtocolParsingTest, TestChunkDelete) { 296 TEST(SafeBrowsingProtocolParsingTest, TestChunkDelete) {
293 std::string add_del("n:1700\ni:phishy\nad:1-7,43-597,44444,99999\n" 297 std::string add_del("n:1700\ni:phishy\nad:1-7,43-597,44444,99999\n"
294 "i:malware\nsd:21-27,42,171717\n"); 298 "i:malware\nsd:21-27,42,171717\n");
295 299
296 size_t next_query_sec = 0; 300 size_t next_query_sec = 0;
297 bool reset = false; 301 bool reset = false;
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after
389 kDefaultPhishList)); 393 kDefaultPhishList));
390 std::vector<SBFullHashResult> full_hashes; 394 std::vector<SBFullHashResult> full_hashes;
391 base::TimeDelta cache_lifetime; 395 base::TimeDelta cache_lifetime;
392 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash.data(), get_hash.length(), 396 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash.data(), get_hash.length(),
393 &cache_lifetime, &full_hashes)); 397 &cache_lifetime, &full_hashes));
394 398
395 ASSERT_EQ(3U, full_hashes.size()); 399 ASSERT_EQ(3U, full_hashes.size());
396 EXPECT_EQ(memcmp(&full_hashes[0].hash, 400 EXPECT_EQ(memcmp(&full_hashes[0].hash,
397 "00112233445566778899aabbccddeeff", 401 "00112233445566778899aabbccddeeff",
398 sizeof(SBFullHash)), 0); 402 sizeof(SBFullHash)), 0);
399 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id); 403 EXPECT_EQ(safe_browsing::PHISH, full_hashes[0].list_id);
400 EXPECT_EQ(memcmp(&full_hashes[1].hash, 404 EXPECT_EQ(memcmp(&full_hashes[1].hash,
401 "00001111222233334444555566667777", 405 "00001111222233334444555566667777",
402 sizeof(SBFullHash)), 0); 406 sizeof(SBFullHash)), 0);
403 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[1].list_id); 407 EXPECT_EQ(safe_browsing::PHISH, full_hashes[1].list_id);
404 EXPECT_EQ(memcmp(&full_hashes[2].hash, 408 EXPECT_EQ(memcmp(&full_hashes[2].hash,
405 "ffffeeeeddddccccbbbbaaaa99998888", 409 "ffffeeeeddddccccbbbbaaaa99998888",
406 sizeof(SBFullHash)), 0); 410 sizeof(SBFullHash)), 0);
407 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[2].list_id); 411 EXPECT_EQ(safe_browsing::PHISH, full_hashes[2].list_id);
408 412
409 // Test multiple lists in the GetHash results. 413 // Test multiple lists in the GetHash results.
410 const std::string get_hash2(base::StringPrintf( 414 const std::string get_hash2(base::StringPrintf(
411 "45\n" 415 "45\n"
412 "%s:32:1\n" 416 "%s:32:1\n"
413 "00112233445566778899aabbccddeeff" 417 "00112233445566778899aabbccddeeff"
414 "%s:32:2\n" 418 "%s:32:2\n"
415 "cafebeefcafebeefdeaddeaddeaddead" 419 "cafebeefcafebeefdeaddeaddeaddead"
416 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss", 420 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss",
417 kDefaultPhishList, 421 kDefaultPhishList,
418 kDefaultMalwareList)); 422 kDefaultMalwareList));
419 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash2.data(), get_hash2.length(), 423 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash2.data(), get_hash2.length(),
420 &cache_lifetime, &full_hashes)); 424 &cache_lifetime, &full_hashes));
421 425
422 ASSERT_EQ(3U, full_hashes.size()); 426 ASSERT_EQ(3U, full_hashes.size());
423 EXPECT_EQ(memcmp(&full_hashes[0].hash, 427 EXPECT_EQ(memcmp(&full_hashes[0].hash,
424 "00112233445566778899aabbccddeeff", 428 "00112233445566778899aabbccddeeff",
425 sizeof(SBFullHash)), 0); 429 sizeof(SBFullHash)), 0);
426 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id); 430 EXPECT_EQ(safe_browsing::PHISH, full_hashes[0].list_id);
427 EXPECT_EQ(memcmp(&full_hashes[1].hash, 431 EXPECT_EQ(memcmp(&full_hashes[1].hash,
428 "cafebeefcafebeefdeaddeaddeaddead", 432 "cafebeefcafebeefdeaddeaddeaddead",
429 sizeof(SBFullHash)), 0); 433 sizeof(SBFullHash)), 0);
430 EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id); 434 EXPECT_EQ(safe_browsing::MALWARE, full_hashes[1].list_id);
431 EXPECT_EQ(memcmp(&full_hashes[2].hash, 435 EXPECT_EQ(memcmp(&full_hashes[2].hash,
432 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss", 436 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss",
433 sizeof(SBFullHash)), 0); 437 sizeof(SBFullHash)), 0);
434 EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[2].list_id); 438 EXPECT_EQ(safe_browsing::MALWARE, full_hashes[2].list_id);
435 439
436 // Test metadata parsing. 440 // Test metadata parsing.
437 const std::string get_hash3(base::StringPrintf( 441 const std::string get_hash3(base::StringPrintf(
438 "45\n" 442 "45\n"
439 "%s:32:2:m\n" 443 "%s:32:2:m\n"
440 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss" 444 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss"
441 "00112233445566778899aabbccddeeff" 445 "00112233445566778899aabbccddeeff"
442 "2\nab2\nxy" 446 "2\nab2\nxy"
443 "%s:32:1\n" 447 "%s:32:1\n"
444 "cafebeefcafebeefdeaddeaddeaddead", 448 "cafebeefcafebeefdeaddeaddeaddead",
445 kDefaultMalwareList, 449 kDefaultMalwareList,
446 kDefaultPhishList)); 450 kDefaultPhishList));
447 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash3.data(), get_hash3.length(), 451 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash3.data(), get_hash3.length(),
448 &cache_lifetime, &full_hashes)); 452 &cache_lifetime, &full_hashes));
449 453
450 ASSERT_EQ(3U, full_hashes.size()); 454 ASSERT_EQ(3U, full_hashes.size());
451 EXPECT_EQ(memcmp(&full_hashes[0].hash, 455 EXPECT_EQ(memcmp(&full_hashes[0].hash,
452 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss", 456 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss",
453 sizeof(SBFullHash)), 0); 457 sizeof(SBFullHash)), 0);
454 EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[0].list_id); 458 EXPECT_EQ(safe_browsing::MALWARE, full_hashes[0].list_id);
455 EXPECT_EQ(std::string("ab"), full_hashes[0].metadata); 459 EXPECT_EQ(std::string("ab"), full_hashes[0].metadata);
456 EXPECT_EQ(memcmp(&full_hashes[1].hash, 460 EXPECT_EQ(memcmp(&full_hashes[1].hash,
457 "00112233445566778899aabbccddeeff", 461 "00112233445566778899aabbccddeeff",
458 sizeof(SBFullHash)), 0); 462 sizeof(SBFullHash)), 0);
459 EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id); 463 EXPECT_EQ(safe_browsing::MALWARE, full_hashes[1].list_id);
460 EXPECT_EQ(std::string("xy"), full_hashes[1].metadata); 464 EXPECT_EQ(std::string("xy"), full_hashes[1].metadata);
461 EXPECT_EQ(memcmp(&full_hashes[2].hash, 465 EXPECT_EQ(memcmp(&full_hashes[2].hash,
462 "cafebeefcafebeefdeaddeaddeaddead", 466 "cafebeefcafebeefdeaddeaddeaddead",
463 sizeof(SBFullHash)), 0); 467 sizeof(SBFullHash)), 0);
464 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[2].list_id); 468 EXPECT_EQ(safe_browsing::PHISH, full_hashes[2].list_id);
465 EXPECT_EQ(std::string(), full_hashes[2].metadata); 469 EXPECT_EQ(std::string(), full_hashes[2].metadata);
466 } 470 }
467 471
468 TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownList) { 472 TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownList) {
469 std::string hash_response(base::StringPrintf( 473 std::string hash_response(base::StringPrintf(
470 "45\n" 474 "45\n"
471 "%s:32:1\n" 475 "%s:32:1\n"
472 "12345678901234567890123456789012" 476 "12345678901234567890123456789012"
473 "googpub-phish-shavar:32:1\n" 477 "googpub-phish-shavar:32:1\n"
474 "09876543210987654321098765432109", 478 "09876543210987654321098765432109",
475 kDefaultPhishList)); 479 kDefaultPhishList));
476 std::vector<SBFullHashResult> full_hashes; 480 std::vector<SBFullHashResult> full_hashes;
477 base::TimeDelta cache_lifetime; 481 base::TimeDelta cache_lifetime;
478 EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(), 482 EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(),
479 hash_response.size(), 483 hash_response.size(),
480 &cache_lifetime, 484 &cache_lifetime,
481 &full_hashes)); 485 &full_hashes));
482 486
483 ASSERT_EQ(1U, full_hashes.size()); 487 ASSERT_EQ(1U, full_hashes.size());
484 EXPECT_EQ(memcmp("12345678901234567890123456789012", 488 EXPECT_EQ(memcmp("12345678901234567890123456789012",
485 &full_hashes[0].hash, sizeof(SBFullHash)), 0); 489 &full_hashes[0].hash, sizeof(SBFullHash)), 0);
486 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id); 490 EXPECT_EQ(safe_browsing::PHISH, full_hashes[0].list_id);
487 491
488 hash_response += base::StringPrintf( 492 hash_response += base::StringPrintf(
489 "%s:32:1\n" 493 "%s:32:1\n"
490 "abcdefghijklmnopqrstuvwxyz123457", 494 "abcdefghijklmnopqrstuvwxyz123457",
491 kDefaultMalwareList); 495 kDefaultMalwareList);
492 full_hashes.clear(); 496 full_hashes.clear();
493 EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(), 497 EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(),
494 hash_response.size(), 498 hash_response.size(),
495 &cache_lifetime, 499 &cache_lifetime,
496 &full_hashes)); 500 &full_hashes));
497 501
498 EXPECT_EQ(2U, full_hashes.size()); 502 EXPECT_EQ(2U, full_hashes.size());
499 EXPECT_EQ(memcmp("12345678901234567890123456789012", 503 EXPECT_EQ(memcmp("12345678901234567890123456789012",
500 &full_hashes[0].hash, sizeof(SBFullHash)), 0); 504 &full_hashes[0].hash, sizeof(SBFullHash)), 0);
501 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id); 505 EXPECT_EQ(safe_browsing::PHISH, full_hashes[0].list_id);
502 EXPECT_EQ(memcmp("abcdefghijklmnopqrstuvwxyz123457", 506 EXPECT_EQ(memcmp("abcdefghijklmnopqrstuvwxyz123457",
503 &full_hashes[1].hash, sizeof(SBFullHash)), 0); 507 &full_hashes[1].hash, sizeof(SBFullHash)), 0);
504 EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id); 508 EXPECT_EQ(safe_browsing::MALWARE, full_hashes[1].list_id);
505 } 509 }
506 510
507 TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownListAndMetadata) { 511 TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownListAndMetadata) {
508 std::vector<SBFullHashResult> full_hashes; 512 std::vector<SBFullHashResult> full_hashes;
509 base::TimeDelta cache_lifetime; 513 base::TimeDelta cache_lifetime;
510 // Test skipping over a hashentry with an unrecognized listname that also has 514 // Test skipping over a hashentry with an unrecognized listname that also has
511 // metadata. 515 // metadata.
512 const std::string get_hash3(base::StringPrintf( 516 const std::string get_hash3(base::StringPrintf(
513 "600\n" 517 "600\n"
514 "BADLISTNAME:32:1:m\n" 518 "BADLISTNAME:32:1:m\n"
515 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" 519 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
516 "8\nMETADATA" 520 "8\nMETADATA"
517 "%s:32:1\n" 521 "%s:32:1\n"
518 "0123456789hashhashhashhashhashha", 522 "0123456789hashhashhashhashhashha",
519 kDefaultMalwareList)); 523 kDefaultMalwareList));
520 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash3.data(), get_hash3.length(), 524 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash3.data(), get_hash3.length(),
521 &cache_lifetime, &full_hashes)); 525 &cache_lifetime, &full_hashes));
522 ASSERT_EQ(1U, full_hashes.size()); 526 ASSERT_EQ(1U, full_hashes.size());
523 EXPECT_EQ(memcmp(&full_hashes[0].hash, 527 EXPECT_EQ(memcmp(&full_hashes[0].hash,
524 "0123456789hashhashhashhashhashha", 528 "0123456789hashhashhashhashhashha",
525 sizeof(SBFullHash)), 0); 529 sizeof(SBFullHash)), 0);
526 EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[0].list_id); 530 EXPECT_EQ(safe_browsing::MALWARE, full_hashes[0].list_id);
527 EXPECT_EQ(std::string(), full_hashes[0].metadata); 531 EXPECT_EQ(std::string(), full_hashes[0].metadata);
528 } 532 }
529 533
530 TEST(SafeBrowsingProtocolParsingTest, TestFormatHash) { 534 TEST(SafeBrowsingProtocolParsingTest, TestFormatHash) {
531 std::vector<SBPrefix> prefixes; 535 std::vector<SBPrefix> prefixes;
532 prefixes.push_back(0x34333231); 536 prefixes.push_back(0x34333231);
533 prefixes.push_back(0x64636261); 537 prefixes.push_back(0x64636261);
534 prefixes.push_back(0x73727170); 538 prefixes.push_back(0x73727170);
535 539
536 EXPECT_EQ("4:12\n1234abcdpqrs", safe_browsing::FormatGetHash(prefixes)); 540 EXPECT_EQ("4:12\n1234abcdpqrs", safe_browsing::FormatGetHash(prefixes));
(...skipping 167 matching lines...) Expand 10 before | Expand all | Expand 10 after
704 EXPECT_FALSE(chunks[0]->IsAdd()); 708 EXPECT_FALSE(chunks[0]->IsAdd());
705 EXPECT_TRUE(chunks[0]->IsSub()); 709 EXPECT_TRUE(chunks[0]->IsSub());
706 EXPECT_TRUE(chunks[2]->IsPrefix()); 710 EXPECT_TRUE(chunks[2]->IsPrefix());
707 EXPECT_FALSE(chunks[2]->IsFullHash()); 711 EXPECT_FALSE(chunks[2]->IsFullHash());
708 ASSERT_EQ(1U, chunks[2]->PrefixCount()); 712 ASSERT_EQ(1U, chunks[2]->PrefixCount());
709 EXPECT_EQ(0x70707070U, chunks[2]->PrefixAt(0)); // pppp 713 EXPECT_EQ(0x70707070U, chunks[2]->PrefixAt(0)); // pppp
710 EXPECT_EQ(11, chunks[2]->AddChunkNumberAt(0)); 714 EXPECT_EQ(11, chunks[2]->AddChunkNumberAt(0));
711 } 715 }
712 716
713 } // namespace 717 } // namespace
OLDNEW
« no previous file with comments | « chrome/browser/safe_browsing/protocol_parser.cc ('k') | chrome/browser/safe_browsing/safe_browsing_blocking_page_test.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698