1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/safe_browsing/safe_browsing_store.h"
#include "chrome/browser/safe_browsing/safe_browsing_store_unittest_helper.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace {
TEST(SafeBrowsingStoreTest, SBAddPrefixLess) {
// chunk_id then prefix.
EXPECT_TRUE(SBAddPrefixLess(SBAddPrefix(10, 1), SBAddPrefix(11, 1)));
EXPECT_FALSE(SBAddPrefixLess(SBAddPrefix(11, 1), SBAddPrefix(10, 1)));
EXPECT_TRUE(SBAddPrefixLess(SBAddPrefix(10, 1), SBAddPrefix(10, 2)));
EXPECT_FALSE(SBAddPrefixLess(SBAddPrefix(10, 2), SBAddPrefix(10, 1)));
// Equal is not less.
EXPECT_FALSE(SBAddPrefixLess(SBAddPrefix(10, 1), SBAddPrefix(10, 1)));
}
TEST(SafeBrowsingStoreTest, SBAddPrefixHashLess) {
// The first four bytes of SBFullHash can be read as an int32, which
// means that byte-ordering issues can come up. To test this, |one|
// and |two| differ in the prefix, while |one| and |onetwo| have the
// same prefix, but differ in the byte after the prefix.
SBFullHash one, onetwo, two;
memset(&one, 0, sizeof(one));
memset(&onetwo, 0, sizeof(onetwo));
memset(&two, 0, sizeof(two));
one.prefix = 1;
one.full_hash[sizeof(int32)] = 1;
onetwo.prefix = 1;
onetwo.full_hash[sizeof(int32)] = 2;
two.prefix = 2;
const base::Time now = base::Time::Now();
// add_id dominates.
EXPECT_TRUE(SBAddPrefixHashLess(SBAddFullHash(10, two.prefix, now, two),
SBAddFullHash(11, one.prefix, now, one)));
EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(11, two.prefix, now, two),
SBAddFullHash(10, one.prefix, now, one)));
// After add_id, prefix.
EXPECT_TRUE(SBAddPrefixHashLess(SBAddFullHash(10, one.prefix, now, two),
SBAddFullHash(10, two.prefix, now, one)));
EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(10, two.prefix, now, one),
SBAddFullHash(10, one.prefix, now, two)));
// After prefix, full hash.
EXPECT_TRUE(SBAddPrefixHashLess(SBAddFullHash(10, one.prefix, now, one),
SBAddFullHash(10, onetwo.prefix,
now, onetwo)));
EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(10, onetwo.prefix,
now, onetwo),
SBAddFullHash(10, one.prefix, now, one)));
// Equal is not less-than.
EXPECT_FALSE(SBAddPrefixHashLess(SBAddFullHash(10, one.prefix, now, one),
SBAddFullHash(10, one.prefix, now, one)));
}
TEST(SafeBrowsingStoreTest, SBSubPrefixLess) {
// add_id dominates.
EXPECT_TRUE(SBAddPrefixLess(SBSubPrefix(12, 10, 2), SBSubPrefix(9, 11, 1)));
EXPECT_FALSE(SBAddPrefixLess(SBSubPrefix(12, 11, 2), SBSubPrefix(9, 10, 1)));
// After add_id, prefix.
EXPECT_TRUE(SBAddPrefixLess(SBSubPrefix(12, 10, 1), SBSubPrefix(9, 10, 2)));
EXPECT_FALSE(SBAddPrefixLess(SBSubPrefix(12, 10, 2), SBSubPrefix(9, 10, 1)));
// Equal is not less-than.
EXPECT_FALSE(SBAddPrefixLess(SBSubPrefix(12, 10, 1), SBSubPrefix(12, 10, 1)));
// chunk_id doesn't matter.
}
TEST(SafeBrowsingStoreTest, SBSubFullHashLess) {
SBFullHash one, onetwo, two;
memset(&one, 0, sizeof(one));
memset(&onetwo, 0, sizeof(onetwo));
memset(&two, 0, sizeof(two));
one.prefix = 1;
one.full_hash[sizeof(int32)] = 1;
onetwo.prefix = 1;
onetwo.full_hash[sizeof(int32)] = 2;
two.prefix = 2;
// add_id dominates.
EXPECT_TRUE(SBAddPrefixHashLess(SBSubFullHash(12, 10, two.prefix, two),
SBSubFullHash(9, 11, one.prefix, one)));
EXPECT_FALSE(SBAddPrefixHashLess(SBSubFullHash(12, 11, two.prefix, two),
SBSubFullHash(9, 10, one.prefix, one)));
// After add_id, prefix.
EXPECT_TRUE(SBAddPrefixHashLess(SBSubFullHash(12, 10, one.prefix, two),
SBSubFullHash(9, 10, two.prefix, one)));
EXPECT_FALSE(SBAddPrefixHashLess(SBSubFullHash(12, 10, two.prefix, one),
SBSubFullHash(9, 10, one.prefix, two)));
// After prefix, full_hash.
EXPECT_TRUE(SBAddPrefixHashLess(SBSubFullHash(12, 10, one.prefix, one),
SBSubFullHash(9, 10, onetwo.prefix, onetwo)));
EXPECT_FALSE(SBAddPrefixHashLess(SBSubFullHash(12, 10, onetwo.prefix, onetwo),
SBSubFullHash(9, 10, one.prefix, one)));
// Equal is not less-than.
EXPECT_FALSE(SBAddPrefixHashLess(SBSubFullHash(12, 10, one.prefix, one),
SBSubFullHash(9, 10, one.prefix, one)));
}
TEST(SafeBrowsingStoreTest, SBProcessSubs) {
std::vector<SBAddPrefix> add_prefixes;
std::vector<SBAddFullHash> add_hashes;
std::vector<SBSubPrefix> sub_prefixes;
std::vector<SBSubFullHash> sub_hashes;
// SBProcessSubs does a lot of iteration, run through empty just to
// make sure degenerate cases work.
SBProcessSubs(&add_prefixes, &sub_prefixes, &add_hashes, &sub_hashes);
EXPECT_TRUE(add_prefixes.empty());
EXPECT_TRUE(sub_prefixes.empty());
EXPECT_TRUE(add_hashes.empty());
EXPECT_TRUE(sub_hashes.empty());
const base::Time kNow = base::Time::Now();
const SBFullHash kHash1(SBFullHashFromString("one"));
const SBFullHash kHash2(SBFullHashFromString("two"));
const SBFullHash kHash3(SBFullHashFromString("three"));
const int kAddChunk1 = 1; // Use different chunk numbers just in case.
const int kSubChunk1 = 2;
// Construct some full hashes which share prefix with another.
SBFullHash kHash1mod1 = kHash1;
kHash1mod1.full_hash[sizeof(kHash1mod1.full_hash) - 1] ++;
SBFullHash kHash1mod2 = kHash1mod1;
kHash1mod2.full_hash[sizeof(kHash1mod2.full_hash) - 1] ++;
SBFullHash kHash1mod3 = kHash1mod2;
kHash1mod3.full_hash[sizeof(kHash1mod3.full_hash) - 1] ++;
// An add with prefix and a couple hashes, plus a sub for the prefix
// and a couple sub hashes. The sub should knock all of them out.
add_prefixes.push_back(SBAddPrefix(kAddChunk1, kHash1.prefix));
add_hashes.push_back(
SBAddFullHash(kAddChunk1, kHash1.prefix, kNow, kHash1));
add_hashes.push_back(
SBAddFullHash(kAddChunk1, kHash1mod1.prefix, kNow, kHash1mod1));
sub_prefixes.push_back(SBSubPrefix(kSubChunk1, kAddChunk1, kHash1.prefix));
sub_hashes.push_back(
SBSubFullHash(kSubChunk1, kAddChunk1, kHash1mod2.prefix, kHash1mod2));
sub_hashes.push_back(
SBSubFullHash(kSubChunk1, kAddChunk1, kHash1mod3.prefix, kHash1mod3));
// An add with no corresponding sub. Both items should be retained.
add_hashes.push_back(SBAddFullHash(kAddChunk1, kHash2.prefix, kNow, kHash2));
add_prefixes.push_back(SBAddPrefix(kAddChunk1, kHash2.prefix));
// A sub with no corresponding add. Both items should be retained.
sub_hashes.push_back(
SBSubFullHash(kSubChunk1, kAddChunk1, kHash3.prefix, kHash3));
sub_prefixes.push_back(SBSubPrefix(kSubChunk1, kAddChunk1, kHash3.prefix));
SBProcessSubs(&add_prefixes, &sub_prefixes, &add_hashes, &sub_hashes);
EXPECT_EQ(1U, add_prefixes.size());
EXPECT_EQ(kAddChunk1, add_prefixes[0].chunk_id);
EXPECT_EQ(kHash2.prefix, add_prefixes[0].prefix);
EXPECT_EQ(1U, add_hashes.size());
EXPECT_EQ(kAddChunk1, add_hashes[0].add_prefix.chunk_id);
EXPECT_EQ(kHash2.prefix, add_hashes[0].add_prefix.prefix);
EXPECT_TRUE(SBFullHashEq(kHash2, add_hashes[0].full_hash));
EXPECT_EQ(1U, sub_prefixes.size());
EXPECT_EQ(kSubChunk1, sub_prefixes[0].chunk_id);
EXPECT_EQ(kAddChunk1, sub_prefixes[0].add_prefix.chunk_id);
EXPECT_EQ(kHash3.prefix, sub_prefixes[0].add_prefix.prefix);
EXPECT_EQ(1U, sub_hashes.size());
EXPECT_EQ(kSubChunk1, sub_hashes[0].chunk_id);
EXPECT_EQ(kAddChunk1, sub_hashes[0].add_prefix.chunk_id);
EXPECT_EQ(kHash3.prefix, sub_hashes[0].add_prefix.prefix);
EXPECT_TRUE(SBFullHashEq(kHash3, sub_hashes[0].full_hash));
}
} // namespace
|
