OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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 "chrome/browser/safe_browsing/sandboxed_zip_analyzer.h" | 5 #include "chrome/browser/safe_browsing/sandboxed_zip_analyzer.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/bind_helpers.h" | 10 #include "base/bind_helpers.h" |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
59 ArchiveAnalyzerResults* results_; | 59 ArchiveAnalyzerResults* results_; |
60 DISALLOW_COPY_AND_ASSIGN(ResultsGetter); | 60 DISALLOW_COPY_AND_ASSIGN(ResultsGetter); |
61 }; | 61 }; |
62 | 62 |
63 SandboxedZipAnalyzerTest() | 63 SandboxedZipAnalyzerTest() |
64 : browser_thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {} | 64 : browser_thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {} |
65 | 65 |
66 void SetUp() override { | 66 void SetUp() override { |
67 ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &dir_test_data_)); | 67 ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &dir_test_data_)); |
68 dir_test_data_ = dir_test_data_.AppendASCII("safe_browsing"); | 68 dir_test_data_ = dir_test_data_.AppendASCII("safe_browsing"); |
69 dir_test_data_ = dir_test_data_.AppendASCII("download_protection"); | |
70 } | 69 } |
71 | 70 |
72 // Runs a sandboxed zip analyzer on |file_path|, writing its results into | 71 // Runs a sandboxed zip analyzer on |file_path|, writing its results into |
73 // |results|. | 72 // |results|. |
74 void RunAnalyzer(const base::FilePath& file_path, | 73 void RunAnalyzer(const base::FilePath& file_path, |
75 ArchiveAnalyzerResults* results) { | 74 ArchiveAnalyzerResults* results) { |
76 DCHECK(results); | 75 DCHECK(results); |
77 base::RunLoop run_loop; | 76 base::RunLoop run_loop; |
78 ResultsGetter results_getter(run_loop.QuitClosure(), results); | 77 ResultsGetter results_getter(run_loop.QuitClosure(), results); |
79 scoped_refptr<SandboxedZipAnalyzer> analyzer( | 78 scoped_refptr<SandboxedZipAnalyzer> analyzer( |
(...skipping 12 matching lines...) Expand all Loading... |
92 } | 91 } |
93 ASSERT_TRUE(binary.has_image_headers()); | 92 ASSERT_TRUE(binary.has_image_headers()); |
94 ASSERT_TRUE(binary.image_headers().has_pe_headers()); | 93 ASSERT_TRUE(binary.image_headers().has_pe_headers()); |
95 EXPECT_TRUE(binary.image_headers().pe_headers().has_dos_header()); | 94 EXPECT_TRUE(binary.image_headers().pe_headers().has_dos_header()); |
96 EXPECT_TRUE(binary.image_headers().pe_headers().has_file_header()); | 95 EXPECT_TRUE(binary.image_headers().pe_headers().has_file_header()); |
97 EXPECT_TRUE(binary.image_headers().pe_headers().has_optional_headers32()); | 96 EXPECT_TRUE(binary.image_headers().pe_headers().has_optional_headers32()); |
98 EXPECT_FALSE(binary.image_headers().pe_headers().has_optional_headers64()); | 97 EXPECT_FALSE(binary.image_headers().pe_headers().has_optional_headers64()); |
99 } | 98 } |
100 #endif | 99 #endif |
101 | 100 |
| 101 #if defined(OS_MACOSX) |
| 102 void ExpectMachOHeaders(const BinaryData& data, |
| 103 const ClientDownloadRequest_ArchivedBinary& binary) { |
| 104 EXPECT_EQ(data.is_signed, binary.has_signature()); |
| 105 if (data.is_signed) { |
| 106 ASSERT_LT(0, binary.signature().signed_data_size()); |
| 107 EXPECT_NE(0U, binary.signature().signed_data(0).size()); |
| 108 } |
| 109 EXPECT_TRUE(binary.has_image_headers()); |
| 110 ASSERT_LT(0, binary.image_headers().mach_o_headers_size()); |
| 111 EXPECT_LT(0, binary.image_headers().mach_o_headers(0).load_commands_size()); |
| 112 } |
| 113 #endif |
| 114 |
102 // Verifies expectations about a binary found by the analyzer. | 115 // Verifies expectations about a binary found by the analyzer. |
103 void ExpectBinary(const BinaryData& data, | 116 void ExpectBinary(const BinaryData& data, |
104 const ClientDownloadRequest_ArchivedBinary& binary) { | 117 const ClientDownloadRequest_ArchivedBinary& binary) { |
105 ASSERT_TRUE(binary.has_file_basename()); | 118 ASSERT_TRUE(binary.has_file_basename()); |
106 EXPECT_EQ(data.file_basename, binary.file_basename()); | 119 EXPECT_EQ(data.file_basename, binary.file_basename()); |
107 ASSERT_TRUE(binary.has_download_type()); | 120 ASSERT_TRUE(binary.has_download_type()); |
108 EXPECT_EQ(data.download_type, binary.download_type()); | 121 EXPECT_EQ(data.download_type, binary.download_type()); |
109 ASSERT_TRUE(binary.has_digests()); | 122 ASSERT_TRUE(binary.has_digests()); |
110 ASSERT_TRUE(binary.digests().has_sha256()); | 123 ASSERT_TRUE(binary.digests().has_sha256()); |
111 EXPECT_EQ(std::string(data.sha256_digest, | 124 EXPECT_EQ(std::string(data.sha256_digest, |
112 data.sha256_digest + crypto::kSHA256Length), | 125 data.sha256_digest + crypto::kSHA256Length), |
113 binary.digests().sha256()); | 126 binary.digests().sha256()); |
114 EXPECT_FALSE(binary.digests().has_sha1()); | 127 EXPECT_FALSE(binary.digests().has_sha1()); |
115 EXPECT_FALSE(binary.digests().has_md5()); | 128 EXPECT_FALSE(binary.digests().has_md5()); |
116 ASSERT_TRUE(binary.has_length()); | 129 ASSERT_TRUE(binary.has_length()); |
117 EXPECT_EQ(data.length, binary.length()); | 130 EXPECT_EQ(data.length, binary.length()); |
118 #if defined(OS_WIN) | 131 #if defined(OS_WIN) |
119 // ExtractImageFeatures only implemented for Windows, and only works on PE | 132 // ExtractImageFeatures for Windows, which only works on PE |
120 // files. | 133 // files. |
121 if (binary.file_basename().find(".exe") != std::string::npos) { | 134 if (binary.file_basename().find(".exe") != std::string::npos) { |
122 ExpectPEHeaders(data, binary); | 135 ExpectPEHeaders(data, binary); |
123 return; | 136 return; |
124 } | 137 } |
125 #endif // OS_WIN | 138 #endif // OS_WIN |
| 139 #if defined(OS_MACOSX) |
| 140 // ExtractImageFeatures for Mac, which only works on MachO |
| 141 // files. |
| 142 if (binary.file_basename().find("executablefat") != std::string::npos) { |
| 143 ExpectMachOHeaders(data, binary); |
| 144 return; |
| 145 } |
| 146 #endif // OS_MACOSX |
| 147 // No signature/image headers should be extracted on the wrong platform |
| 148 // (e.g. analyzing .exe on Mac). |
126 ASSERT_FALSE(binary.has_signature()); | 149 ASSERT_FALSE(binary.has_signature()); |
127 ASSERT_FALSE(binary.has_image_headers()); | 150 ASSERT_FALSE(binary.has_image_headers()); |
128 } | 151 } |
129 | 152 |
130 static const uint8_t kUnsignedDigest[]; | 153 static const uint8_t kUnsignedDigest[]; |
131 static const uint8_t kSignedDigest[]; | 154 static const uint8_t kSignedDigest[]; |
132 static const uint8_t kJSEFileDigest[]; | 155 static const uint8_t kJSEFileDigest[]; |
133 static const BinaryData kUnsignedExe; | 156 static const BinaryData kUnsignedExe; |
134 static const BinaryData kSignedExe; | 157 static const BinaryData kSignedExe; |
135 static const BinaryData kJSEFile; | 158 static const BinaryData kJSEFile; |
136 | 159 |
| 160 #if defined(OS_MACOSX) |
| 161 static const uint8_t kUnsignedMachODigest[]; |
| 162 static const uint8_t kSignedMachODigest[]; |
| 163 static const BinaryData kUnsignedMachO; |
| 164 static const BinaryData kSignedMachO; |
| 165 #endif // OS_MACOSX |
| 166 |
137 base::FilePath dir_test_data_; | 167 base::FilePath dir_test_data_; |
138 content::TestBrowserThreadBundle browser_thread_bundle_; | 168 content::TestBrowserThreadBundle browser_thread_bundle_; |
139 content::InProcessUtilityThreadHelper utility_thread_helper_; | 169 content::InProcessUtilityThreadHelper utility_thread_helper_; |
140 }; | 170 }; |
141 | 171 |
142 // static | 172 // static |
143 const uint8_t SandboxedZipAnalyzerTest::kUnsignedDigest[] = { | 173 const uint8_t SandboxedZipAnalyzerTest::kUnsignedDigest[] = { |
144 0x1e, 0x95, 0x4d, 0x9c, 0xe0, 0x38, 0x9e, 0x2b, 0xa7, 0x44, 0x72, | 174 0x1e, 0x95, 0x4d, 0x9c, 0xe0, 0x38, 0x9e, 0x2b, 0xa7, 0x44, 0x72, |
145 0x16, 0xf2, 0x17, 0x61, 0xf9, 0x8d, 0x1e, 0x65, 0x40, 0xc2, 0xab, | 175 0x16, 0xf2, 0x17, 0x61, 0xf9, 0x8d, 0x1e, 0x65, 0x40, 0xc2, 0xab, |
146 0xec, 0xdb, 0xec, 0xff, 0x57, 0x0e, 0x36, 0xc4, 0x93, 0xdb}; | 176 0xec, 0xdb, 0xec, 0xff, 0x57, 0x0e, 0x36, 0xc4, 0x93, 0xdb}; |
(...skipping 23 matching lines...) Expand all Loading... |
170 }; | 200 }; |
171 const SandboxedZipAnalyzerTest::BinaryData SandboxedZipAnalyzerTest::kJSEFile = | 201 const SandboxedZipAnalyzerTest::BinaryData SandboxedZipAnalyzerTest::kJSEFile = |
172 { | 202 { |
173 "hello.jse", | 203 "hello.jse", |
174 ClientDownloadRequest_DownloadType_WIN_EXECUTABLE, | 204 ClientDownloadRequest_DownloadType_WIN_EXECUTABLE, |
175 &kJSEFileDigest[0], | 205 &kJSEFileDigest[0], |
176 6, | 206 6, |
177 false, // is_signed | 207 false, // is_signed |
178 }; | 208 }; |
179 | 209 |
| 210 #if defined(OS_MACOSX) |
| 211 const uint8_t SandboxedZipAnalyzerTest::kUnsignedMachODigest[] = { |
| 212 0xe4, 0x62, 0xff, 0x75, 0x2f, 0xf9, 0xd8, 0x4e, 0x34, 0xd8, 0x43, |
| 213 0xe5, 0xd4, 0x6e, 0x20, 0x12, 0xad, 0xcb, 0xd4, 0x85, 0x40, 0xa8, |
| 214 0x47, 0x3f, 0xb7, 0x94, 0xb2, 0x86, 0xa3, 0x89, 0xb9, 0x45}; |
| 215 const SandboxedZipAnalyzerTest::BinaryData |
| 216 SandboxedZipAnalyzerTest::kUnsignedMachO = { |
| 217 "executablefat", |
| 218 ClientDownloadRequest_DownloadType_WIN_EXECUTABLE, |
| 219 &kUnsignedMachODigest[0], |
| 220 16640, |
| 221 false, // !is_signed |
| 222 }; |
| 223 const uint8_t SandboxedZipAnalyzerTest::kSignedMachODigest[] = { |
| 224 0x59, 0x0b, 0xc9, 0xc8, 0xee, 0x6c, 0xec, 0x94, 0x46, 0xc1, 0x44, |
| 225 0xd8, 0xea, 0x2b, 0x10, 0x85, 0xb1, 0x5b, 0x5c, 0x68, 0x80, 0x9b, |
| 226 0x2c, 0x27, 0x48, 0xad, 0x04, 0x0c, 0x2a, 0x1e, 0xf8, 0x29}; |
| 227 const SandboxedZipAnalyzerTest::BinaryData |
| 228 SandboxedZipAnalyzerTest::kSignedMachO = { |
| 229 "signedexecutablefat", |
| 230 ClientDownloadRequest_DownloadType_WIN_EXECUTABLE, |
| 231 &kSignedMachODigest[0], |
| 232 34176, |
| 233 true, // !is_signed |
| 234 }; |
| 235 #endif // OS_MACOSX |
| 236 |
180 TEST_F(SandboxedZipAnalyzerTest, NoBinaries) { | 237 TEST_F(SandboxedZipAnalyzerTest, NoBinaries) { |
181 ArchiveAnalyzerResults results; | 238 ArchiveAnalyzerResults results; |
182 RunAnalyzer(dir_test_data_.AppendASCII("zipfile_no_binaries.zip"), &results); | 239 RunAnalyzer( |
| 240 dir_test_data_.AppendASCII("download_protection/zipfile_no_binaries.zip"), |
| 241 &results); |
183 ASSERT_TRUE(results.success); | 242 ASSERT_TRUE(results.success); |
184 EXPECT_FALSE(results.has_executable); | 243 EXPECT_FALSE(results.has_executable); |
185 EXPECT_FALSE(results.has_archive); | 244 EXPECT_FALSE(results.has_archive); |
186 EXPECT_EQ(0, results.archived_binary.size()); | 245 EXPECT_EQ(0, results.archived_binary.size()); |
187 } | 246 } |
188 | 247 |
189 TEST_F(SandboxedZipAnalyzerTest, OneUnsignedBinary) { | 248 TEST_F(SandboxedZipAnalyzerTest, OneUnsignedBinary) { |
190 ArchiveAnalyzerResults results; | 249 ArchiveAnalyzerResults results; |
191 RunAnalyzer(dir_test_data_.AppendASCII("zipfile_one_unsigned_binary.zip"), | 250 RunAnalyzer(dir_test_data_.AppendASCII( |
| 251 "download_protection/zipfile_one_unsigned_binary.zip"), |
192 &results); | 252 &results); |
193 ASSERT_TRUE(results.success); | 253 ASSERT_TRUE(results.success); |
194 EXPECT_TRUE(results.has_executable); | 254 EXPECT_TRUE(results.has_executable); |
195 EXPECT_FALSE(results.has_archive); | 255 EXPECT_FALSE(results.has_archive); |
196 ASSERT_EQ(1, results.archived_binary.size()); | 256 ASSERT_EQ(1, results.archived_binary.size()); |
197 ExpectBinary(kUnsignedExe, results.archived_binary.Get(0)); | 257 ExpectBinary(kUnsignedExe, results.archived_binary.Get(0)); |
198 } | 258 } |
199 | 259 |
200 TEST_F(SandboxedZipAnalyzerTest, TwoBinariesOneSigned) { | 260 TEST_F(SandboxedZipAnalyzerTest, TwoBinariesOneSigned) { |
201 ArchiveAnalyzerResults results; | 261 ArchiveAnalyzerResults results; |
202 RunAnalyzer(dir_test_data_.AppendASCII("zipfile_two_binaries_one_signed.zip"), | 262 RunAnalyzer(dir_test_data_.AppendASCII( |
| 263 "download_protection/zipfile_two_binaries_one_signed.zip"), |
203 &results); | 264 &results); |
204 ASSERT_TRUE(results.success); | 265 ASSERT_TRUE(results.success); |
205 EXPECT_TRUE(results.has_executable); | 266 EXPECT_TRUE(results.has_executable); |
206 EXPECT_FALSE(results.has_archive); | 267 EXPECT_FALSE(results.has_archive); |
207 ASSERT_EQ(2, results.archived_binary.size()); | 268 ASSERT_EQ(2, results.archived_binary.size()); |
208 ExpectBinary(kUnsignedExe, results.archived_binary.Get(0)); | 269 ExpectBinary(kUnsignedExe, results.archived_binary.Get(0)); |
209 ExpectBinary(kSignedExe, results.archived_binary.Get(1)); | 270 ExpectBinary(kSignedExe, results.archived_binary.Get(1)); |
210 } | 271 } |
211 | 272 |
212 TEST_F(SandboxedZipAnalyzerTest, ZippedArchiveNoBinaries) { | 273 TEST_F(SandboxedZipAnalyzerTest, ZippedArchiveNoBinaries) { |
213 ArchiveAnalyzerResults results; | 274 ArchiveAnalyzerResults results; |
214 RunAnalyzer(dir_test_data_.AppendASCII("zipfile_archive_no_binaries.zip"), | 275 RunAnalyzer(dir_test_data_.AppendASCII( |
| 276 "download_protection/zipfile_archive_no_binaries.zip"), |
215 &results); | 277 &results); |
216 ASSERT_TRUE(results.success); | 278 ASSERT_TRUE(results.success); |
217 EXPECT_FALSE(results.has_executable); | 279 EXPECT_FALSE(results.has_executable); |
218 EXPECT_TRUE(results.has_archive); | 280 EXPECT_TRUE(results.has_archive); |
219 EXPECT_EQ(1, results.archived_binary.size()); | 281 EXPECT_EQ(1, results.archived_binary.size()); |
220 ASSERT_EQ(1u, results.archived_archive_filenames.size()); | 282 ASSERT_EQ(1u, results.archived_archive_filenames.size()); |
221 EXPECT_EQ(FILE_PATH_LITERAL("hello.zip"), | 283 EXPECT_EQ(FILE_PATH_LITERAL("hello.zip"), |
222 results.archived_archive_filenames[0].value()); | 284 results.archived_archive_filenames[0].value()); |
223 } | 285 } |
224 | 286 |
225 TEST_F(SandboxedZipAnalyzerTest, ZippedRarArchiveNoBinaries) { | 287 TEST_F(SandboxedZipAnalyzerTest, ZippedRarArchiveNoBinaries) { |
226 ArchiveAnalyzerResults results; | 288 ArchiveAnalyzerResults results; |
227 RunAnalyzer(dir_test_data_.AppendASCII("zipfile_rar_archive_no_binaries.zip"), | 289 RunAnalyzer(dir_test_data_.AppendASCII( |
| 290 "download_protection/zipfile_rar_archive_no_binaries.zip"), |
228 &results); | 291 &results); |
229 ASSERT_TRUE(results.success); | 292 ASSERT_TRUE(results.success); |
230 EXPECT_FALSE(results.has_executable); | 293 EXPECT_FALSE(results.has_executable); |
231 EXPECT_TRUE(results.has_archive); | 294 EXPECT_TRUE(results.has_archive); |
232 EXPECT_EQ(1, results.archived_binary.size()); | 295 EXPECT_EQ(1, results.archived_binary.size()); |
233 ASSERT_EQ(1u, results.archived_archive_filenames.size()); | 296 ASSERT_EQ(1u, results.archived_archive_filenames.size()); |
234 EXPECT_EQ(FILE_PATH_LITERAL("hello.rar"), | 297 EXPECT_EQ(FILE_PATH_LITERAL("hello.rar"), |
235 results.archived_archive_filenames[0].value()); | 298 results.archived_archive_filenames[0].value()); |
236 } | 299 } |
237 | 300 |
238 TEST_F(SandboxedZipAnalyzerTest, ZippedArchiveAndBinaries) { | 301 TEST_F(SandboxedZipAnalyzerTest, ZippedArchiveAndBinaries) { |
239 ArchiveAnalyzerResults results; | 302 ArchiveAnalyzerResults results; |
240 RunAnalyzer(dir_test_data_.AppendASCII("zipfile_archive_and_binaries.zip"), | 303 RunAnalyzer(dir_test_data_.AppendASCII( |
| 304 "download_protection/zipfile_archive_and_binaries.zip"), |
241 &results); | 305 &results); |
242 ASSERT_TRUE(results.success); | 306 ASSERT_TRUE(results.success); |
243 EXPECT_TRUE(results.has_executable); | 307 EXPECT_TRUE(results.has_executable); |
244 EXPECT_TRUE(results.has_archive); | 308 EXPECT_TRUE(results.has_archive); |
245 ASSERT_EQ(2, results.archived_binary.size()); | 309 ASSERT_EQ(2, results.archived_binary.size()); |
246 ExpectBinary(kSignedExe, results.archived_binary.Get(0)); | 310 ExpectBinary(kSignedExe, results.archived_binary.Get(0)); |
247 ASSERT_EQ(1u, results.archived_archive_filenames.size()); | 311 ASSERT_EQ(1u, results.archived_archive_filenames.size()); |
248 EXPECT_EQ(FILE_PATH_LITERAL("hello.7z"), | 312 EXPECT_EQ(FILE_PATH_LITERAL("hello.7z"), |
249 results.archived_archive_filenames[0].value()); | 313 results.archived_archive_filenames[0].value()); |
250 } | 314 } |
251 | 315 |
252 TEST_F(SandboxedZipAnalyzerTest, | 316 TEST_F(SandboxedZipAnalyzerTest, |
253 ZippedArchiveAndBinariesWithTrailingSpaceAndPeriodChars) { | 317 ZippedArchiveAndBinariesWithTrailingSpaceAndPeriodChars) { |
254 ArchiveAnalyzerResults results; | 318 ArchiveAnalyzerResults results; |
255 RunAnalyzer(dir_test_data_.AppendASCII("zipfile_two_binaries_one_archive_" | 319 RunAnalyzer(dir_test_data_.AppendASCII( |
256 "trailing_space_and_period_chars.zip"), | 320 "download_protection/zipfile_two_binaries_one_archive_" |
| 321 "trailing_space_and_period_chars.zip"), |
257 &results); | 322 &results); |
258 ASSERT_TRUE(results.success); | 323 ASSERT_TRUE(results.success); |
259 EXPECT_TRUE(results.has_executable); | 324 EXPECT_TRUE(results.has_executable); |
260 EXPECT_TRUE(results.has_archive); | 325 EXPECT_TRUE(results.has_archive); |
261 ASSERT_EQ(3, results.archived_binary.size()); | 326 ASSERT_EQ(3, results.archived_binary.size()); |
262 | 327 |
263 BinaryData SignedExe = kSignedExe; | 328 BinaryData SignedExe = kSignedExe; |
264 SignedExe.file_basename = "signed.exe "; | 329 SignedExe.file_basename = "signed.exe "; |
265 BinaryData UnsignedExe = kUnsignedExe; | 330 BinaryData UnsignedExe = kUnsignedExe; |
266 UnsignedExe.file_basename = "unsigned.exe."; | 331 UnsignedExe.file_basename = "unsigned.exe."; |
267 ExpectBinary(SignedExe, results.archived_binary.Get(0)); | 332 ExpectBinary(SignedExe, results.archived_binary.Get(0)); |
268 ExpectBinary(UnsignedExe, results.archived_binary.Get(1)); | 333 ExpectBinary(UnsignedExe, results.archived_binary.Get(1)); |
269 ASSERT_EQ(1u, results.archived_archive_filenames.size()); | 334 ASSERT_EQ(1u, results.archived_archive_filenames.size()); |
270 EXPECT_EQ(FILE_PATH_LITERAL("zipfile_no_binaries.zip . . "), | 335 EXPECT_EQ(FILE_PATH_LITERAL("zipfile_no_binaries.zip . . "), |
271 results.archived_archive_filenames[0].value()); | 336 results.archived_archive_filenames[0].value()); |
272 } | 337 } |
273 | 338 |
274 TEST_F(SandboxedZipAnalyzerTest, ZippedJSEFile) { | 339 TEST_F(SandboxedZipAnalyzerTest, ZippedJSEFile) { |
275 ArchiveAnalyzerResults results; | 340 ArchiveAnalyzerResults results; |
276 RunAnalyzer(dir_test_data_.AppendASCII("zipfile_one_jse_file.zip"), &results); | 341 RunAnalyzer(dir_test_data_.AppendASCII( |
| 342 "download_protection/zipfile_one_jse_file.zip"), |
| 343 &results); |
277 ASSERT_TRUE(results.success); | 344 ASSERT_TRUE(results.success); |
278 EXPECT_TRUE(results.has_executable); | 345 EXPECT_TRUE(results.has_executable); |
279 EXPECT_FALSE(results.has_archive); | 346 EXPECT_FALSE(results.has_archive); |
280 ASSERT_EQ(1, results.archived_binary.size()); | 347 ASSERT_EQ(1, results.archived_binary.size()); |
281 ExpectBinary(kJSEFile, results.archived_binary.Get(0)); | 348 ExpectBinary(kJSEFile, results.archived_binary.Get(0)); |
282 EXPECT_TRUE(results.archived_archive_filenames.empty()); | 349 EXPECT_TRUE(results.archived_archive_filenames.empty()); |
283 } | 350 } |
284 | 351 |
| 352 #if defined(OS_MACOSX) |
| 353 TEST_F(SandboxedZipAnalyzerTest, ZippedAppWithUnsignedAndSignedExecutable) { |
| 354 ArchiveAnalyzerResults results; |
| 355 RunAnalyzer(dir_test_data_.AppendASCII( |
| 356 "mach_o/zipped-app-two-executables-one-signed.zip"), |
| 357 &results); |
| 358 ASSERT_TRUE(results.success); |
| 359 EXPECT_TRUE(results.has_executable); |
| 360 EXPECT_FALSE(results.has_archive); |
| 361 ASSERT_EQ(2, results.archived_binary.size()); |
| 362 ExpectBinary(kUnsignedMachO, results.archived_binary.Get(0)); |
| 363 ExpectBinary(kSignedMachO, results.archived_binary.Get(1)); |
| 364 } |
| 365 #endif // OS_MACOSX |
| 366 |
285 } // namespace safe_browsing | 367 } // namespace safe_browsing |
OLD | NEW |