1 // Copyright (c) 2016 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 "core/fdrm/fx_crypt.h"
6
7 #include <memory>
8 #include <string>
9
10 #include "core/fxcrt/fx_memory.h"
11 #include "testing/gtest/include/gtest/gtest.h"
12 #include "testing/utils/hash.h"
13
14 namespace {
15
CRYPT_MD5String(const char * str)16 std::string CRYPT_MD5String(const char* str) {
17 return GenerateMD5Base16(reinterpret_cast<const uint8_t*>(str), strlen(str));
18 }
19
CheckArcFourContext(const CRYPT_rc4_context & context,int32_t expected_x,int32_t expected_y,const uint8_t * expected_permutation)20 void CheckArcFourContext(const CRYPT_rc4_context& context,
21 int32_t expected_x,
22 int32_t expected_y,
23 const uint8_t* expected_permutation) {
24 EXPECT_EQ(expected_x, context.x);
25 EXPECT_EQ(expected_y, context.y);
26 for (int32_t i = 0; i < kRC4ContextPermutationLength; ++i)
27 EXPECT_EQ(expected_permutation[i], context.m[i]) << i;
28 }
29
30 } // namespace
31
32 // Originally from chromium's /src/base/md5_unittest.cc.
TEST(FXCRYPT,CryptToBase16)33 TEST(FXCRYPT, CryptToBase16) {
34 static constexpr uint8_t kData[] = {0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00,
35 0xb2, 0x04, 0xe9, 0x80, 0x09, 0x98,
36 0xec, 0xf8, 0x42, 0x7e};
37
38 std::string actual = CryptToBase16(kData);
39 std::string expected = "d41d8cd98f00b204e9800998ecf8427e";
40
41 EXPECT_EQ(expected, actual);
42 }
43
TEST(FXCRYPT,MD5GenerateEmtpyData)44 TEST(FXCRYPT, MD5GenerateEmtpyData) {
45 uint8_t digest[16];
46 CRYPT_MD5Generate({}, digest);
47
48 static constexpr uint8_t kExpected[] = {0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00,
49 0xb2, 0x04, 0xe9, 0x80, 0x09, 0x98,
50 0xec, 0xf8, 0x42, 0x7e};
51
52 for (int i = 0; i < 16; ++i)
53 EXPECT_EQ(kExpected[i], digest[i]);
54 }
55
TEST(FXCRYPT,MD5GenerateOneByteData)56 TEST(FXCRYPT, MD5GenerateOneByteData) {
57 uint8_t digest[16];
58 CRYPT_MD5Generate(pdfium::as_bytes(pdfium::make_span("a", 1)), digest);
59
60 static constexpr uint8_t kExpected[] = {0x0c, 0xc1, 0x75, 0xb9, 0xc0, 0xf1,
61 0xb6, 0xa8, 0x31, 0xc3, 0x99, 0xe2,
62 0x69, 0x77, 0x26, 0x61};
63
64 for (int i = 0; i < 16; ++i)
65 EXPECT_EQ(kExpected[i], digest[i]);
66 }
67
TEST(FXCRYPT,MD5GenerateLongData)68 TEST(FXCRYPT, MD5GenerateLongData) {
69 const uint32_t length = 10 * 1024 * 1024 + 1;
70 std::vector<uint8_t> data(length);
71
72 for (uint32_t i = 0; i < length; ++i)
73 data[i] = i & 0xFF;
74
75 uint8_t digest[16];
76 CRYPT_MD5Generate(data, digest);
77
78 static constexpr uint8_t kExpected[] = {0x90, 0xbd, 0x6a, 0xd9, 0x0a, 0xce,
79 0xf5, 0xad, 0xaa, 0x92, 0x20, 0x3e,
80 0x21, 0xc7, 0xa1, 0x3e};
81
82 for (int i = 0; i < 16; ++i)
83 EXPECT_EQ(kExpected[i], digest[i]);
84 }
85
TEST(FXCRYPT,ContextWithEmptyData)86 TEST(FXCRYPT, ContextWithEmptyData) {
87 CRYPT_md5_context ctx = CRYPT_MD5Start();
88
89 uint8_t digest[16];
90 CRYPT_MD5Finish(&ctx, digest);
91
92 static constexpr uint8_t kExpected[] = {0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00,
93 0xb2, 0x04, 0xe9, 0x80, 0x09, 0x98,
94 0xec, 0xf8, 0x42, 0x7e};
95
96 for (int i = 0; i < 16; ++i)
97 EXPECT_EQ(kExpected[i], digest[i]);
98 }
99
TEST(FXCRYPT,ContextWithLongData)100 TEST(FXCRYPT, ContextWithLongData) {
101 CRYPT_md5_context ctx = CRYPT_MD5Start();
102
103 const uint32_t length = 10 * 1024 * 1024 + 1;
104 std::vector<uint8_t> data(length);
105
106 for (uint32_t i = 0; i < length; ++i)
107 data[i] = i & 0xFF;
108
109 pdfium::span<const uint8_t> data_span = pdfium::make_span(data);
110 uint32_t total = 0;
111 while (total < length) {
112 constexpr uint32_t kChunkLen = 4097; // intentionally not 2^k.
113 uint32_t len = std::min(kChunkLen, length - total);
114 CRYPT_MD5Update(&ctx, data_span.subspan(total, len));
115 total += len;
116 }
117
118 EXPECT_EQ(length, total);
119
120 uint8_t digest[16];
121 CRYPT_MD5Finish(&ctx, digest);
122
123 static constexpr uint8_t kExpected[] = {0x90, 0xbd, 0x6a, 0xd9, 0x0a, 0xce,
124 0xf5, 0xad, 0xaa, 0x92, 0x20, 0x3e,
125 0x21, 0xc7, 0xa1, 0x3e};
126
127 for (int i = 0; i < 16; ++i)
128 EXPECT_EQ(kExpected[i], digest[i]);
129 }
130
131 // Example data from http://www.ietf.org/rfc/rfc1321.txt A.5 Test Suite
TEST(FXCRYPT,MD5StringTestSuite1)132 TEST(FXCRYPT, MD5StringTestSuite1) {
133 std::string actual = CRYPT_MD5String("");
134 std::string expected = "d41d8cd98f00b204e9800998ecf8427e";
135 EXPECT_EQ(expected, actual);
136 }
137
TEST(FXCRYPT,MD5StringTestSuite2)138 TEST(FXCRYPT, MD5StringTestSuite2) {
139 std::string actual = CRYPT_MD5String("a");
140 std::string expected = "0cc175b9c0f1b6a831c399e269772661";
141 EXPECT_EQ(expected, actual);
142 }
143
TEST(FXCRYPT,MD5StringTestSuite3)144 TEST(FXCRYPT, MD5StringTestSuite3) {
145 std::string actual = CRYPT_MD5String("abc");
146 std::string expected = "900150983cd24fb0d6963f7d28e17f72";
147 EXPECT_EQ(expected, actual);
148 }
149
TEST(FXCRYPT,MD5StringTestSuite4)150 TEST(FXCRYPT, MD5StringTestSuite4) {
151 std::string actual = CRYPT_MD5String("message digest");
152 std::string expected = "f96b697d7cb7938d525a2f31aaf161d0";
153 EXPECT_EQ(expected, actual);
154 }
155
TEST(FXCRYPT,MD5StringTestSuite5)156 TEST(FXCRYPT, MD5StringTestSuite5) {
157 std::string actual = CRYPT_MD5String("abcdefghijklmnopqrstuvwxyz");
158 std::string expected = "c3fcd3d76192e4007dfb496cca67e13b";
159 EXPECT_EQ(expected, actual);
160 }
161
TEST(FXCRYPT,MD5StringTestSuite6)162 TEST(FXCRYPT, MD5StringTestSuite6) {
163 std::string actual = CRYPT_MD5String(
164 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
165 "abcdefghijklmnopqrstuvwxyz"
166 "0123456789");
167 std::string expected = "d174ab98d277d9f5a5611c2c9f419d9f";
168 EXPECT_EQ(expected, actual);
169 }
170
TEST(FXCRYPT,MD5StringTestSuite7)171 TEST(FXCRYPT, MD5StringTestSuite7) {
172 std::string actual = CRYPT_MD5String(
173 "12345678901234567890"
174 "12345678901234567890"
175 "12345678901234567890"
176 "12345678901234567890");
177 std::string expected = "57edf4a22be3c955ac49da2e2107b67a";
178 EXPECT_EQ(expected, actual);
179 }
180
TEST(FXCRYPT,ContextWithStringData)181 TEST(FXCRYPT, ContextWithStringData) {
182 CRYPT_md5_context ctx = CRYPT_MD5Start();
183 CRYPT_MD5Update(&ctx, pdfium::as_bytes(pdfium::make_span("abc", 3)));
184
185 uint8_t digest[16];
186 CRYPT_MD5Finish(&ctx, digest);
187
188 std::string actual = CryptToBase16(digest);
189 std::string expected = "900150983cd24fb0d6963f7d28e17f72";
190 EXPECT_EQ(expected, actual);
191 }
192
TEST(FXCRYPT,Sha1Empty)193 TEST(FXCRYPT, Sha1Empty) {
194 static const char kInput[] = "";
195 static const uint8_t kExpected[] = {0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b,
196 0x0d, 0x32, 0x55, 0xbf, 0xef, 0x95, 0x60,
197 0x18, 0x90, 0xaf, 0xd8, 0x07, 0x09};
198 uint8_t actual[20];
199 CRYPT_SHA1Generate(reinterpret_cast<const uint8_t*>(kInput), strlen(kInput),
200 actual);
201
202 for (size_t i = 0; i < FX_ArraySize(kExpected); i++)
203 EXPECT_EQ(kExpected[i], actual[i]) << " at byte " << i;
204 }
205
206 // Originally from chromium's /src/base/sha1_unittest.cc
TEST(FXCRYPT,Sha1TestA1)207 TEST(FXCRYPT, Sha1TestA1) {
208 // Example A.1 from FIPS 180-2: one-block message.
209 static const char kInput[] = "abc";
210 static const uint8_t kExpected[] = {0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81,
211 0x6a, 0xba, 0x3e, 0x25, 0x71, 0x78, 0x50,
212 0xc2, 0x6c, 0x9c, 0xd0, 0xd8, 0x9d};
213 uint8_t actual[20];
214 CRYPT_SHA1Generate(reinterpret_cast<const uint8_t*>(kInput), strlen(kInput),
215 actual);
216
217 for (size_t i = 0; i < FX_ArraySize(kExpected); i++)
218 EXPECT_EQ(kExpected[i], actual[i]) << " at byte " << i;
219 }
220
TEST(FXCRYPT,Sha1TestA2)221 TEST(FXCRYPT, Sha1TestA2) {
222 // Example A.2 from FIPS 180-2: multi-block message.
223 static const char kInput[] =
224 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
225 static const uint8_t kExpected[] = {0x84, 0x98, 0x3e, 0x44, 0x1c, 0x3b, 0xd2,
226 0x6e, 0xba, 0xae, 0x4a, 0xa1, 0xf9, 0x51,
227 0x29, 0xe5, 0xe5, 0x46, 0x70, 0xf1};
228
229 uint8_t actual[20];
230 CRYPT_SHA1Generate(reinterpret_cast<const uint8_t*>(kInput), strlen(kInput),
231 actual);
232
233 for (size_t i = 0; i < FX_ArraySize(kExpected); i++)
234 EXPECT_EQ(kExpected[i], actual[i]) << " at byte " << i;
235 }
236
TEST(FXCRYPT,Sha256Empty)237 TEST(FXCRYPT, Sha256Empty) {
238 static const char kInput[] = "";
239 static const uint8_t kExpected[32] = {
240 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4,
241 0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b,
242 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55};
243 uint8_t actual[32];
244 CRYPT_SHA256Generate(reinterpret_cast<const uint8_t*>(kInput), strlen(kInput),
245 actual);
246 for (size_t i = 0; i < FX_ArraySize(kExpected); ++i)
247 EXPECT_EQ(kExpected[i], actual[i]) << " at byte " << i;
248 }
249
TEST(FXCRYPT,Sha256TestB1)250 TEST(FXCRYPT, Sha256TestB1) {
251 // Example B.1 from FIPS 180-2: one-block message.
252 static const char kInput[] = "abc";
253 static const uint8_t kExpected[32] = {
254 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40,
255 0xde, 0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17,
256 0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad};
257 uint8_t actual[32];
258 CRYPT_SHA256Generate(reinterpret_cast<const uint8_t*>(kInput), strlen(kInput),
259 actual);
260 for (size_t i = 0; i < FX_ArraySize(kExpected); ++i)
261 EXPECT_EQ(kExpected[i], actual[i]) << " at byte " << i;
262 }
263
TEST(FXCRYPT,Sha256TestB2)264 TEST(FXCRYPT, Sha256TestB2) {
265 // Example B.2 from FIPS 180-2: multi-block message.
266 static const char kInput[] =
267 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
268 static const uint8_t kExpected[32] = {
269 0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8, 0xe5, 0xc0, 0x26,
270 0x93, 0x0c, 0x3e, 0x60, 0x39, 0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff,
271 0x21, 0x67, 0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1};
272 uint8_t actual[32];
273 CRYPT_SHA256Generate(reinterpret_cast<const uint8_t*>(kInput), strlen(kInput),
274 actual);
275 for (size_t i = 0; i < FX_ArraySize(kExpected); ++i)
276 EXPECT_EQ(kExpected[i], actual[i]) << " at byte " << i;
277 }
278
TEST(FXCRYPT,CRYPT_ArcFourSetup)279 TEST(FXCRYPT, CRYPT_ArcFourSetup) {
280 {
281 static const uint8_t kNullPermutation[kRC4ContextPermutationLength] = {
282 0, 35, 3, 43, 9, 11, 65, 229, 32, 36, 134, 98, 59, 34,
283 173, 153, 214, 200, 64, 161, 191, 62, 6, 25, 56, 234, 49, 246,
284 69, 133, 203, 194, 10, 42, 228, 198, 195, 245, 236, 91, 206, 23,
285 235, 27, 138, 18, 143, 250, 244, 76, 123, 217, 132, 249, 72, 127,
286 94, 151, 33, 60, 248, 85, 177, 210, 142, 83, 110, 140, 41, 135,
287 196, 238, 156, 242, 141, 67, 5, 185, 131, 63, 137, 37, 172, 121,
288 70, 144, 237, 130, 17, 44, 253, 166, 78, 201, 12, 119, 215, 7,
289 126, 114, 97, 192, 53, 4, 254, 45, 102, 122, 230, 88, 193, 129,
290 160, 124, 84, 108, 239, 189, 152, 120, 115, 207, 50, 176, 86, 157,
291 164, 187, 71, 1, 15, 58, 29, 21, 46, 145, 247, 162, 95, 183,
292 13, 226, 159, 175, 221, 100, 96, 202, 101, 178, 154, 47, 205, 106,
293 148, 104, 93, 112, 26, 165, 128, 186, 146, 218, 66, 211, 171, 90,
294 252, 19, 40, 99, 223, 174, 255, 51, 77, 227, 48, 220, 168, 118,
295 224, 103, 75, 105, 125, 199, 73, 82, 57, 181, 81, 149, 68, 52,
296 232, 22, 2, 216, 113, 30, 109, 163, 92, 61, 14, 8, 38, 225,
297 79, 231, 170, 240, 20, 219, 204, 150, 180, 188, 116, 190, 241, 197,
298 179, 87, 74, 147, 80, 54, 212, 16, 167, 222, 136, 213, 55, 182,
299 139, 24, 209, 251, 208, 28, 111, 89, 158, 155, 243, 107, 233, 169,
300 117, 184, 31, 39};
301 CRYPT_rc4_context context;
302 CRYPT_ArcFourSetup(&context, {});
303 CheckArcFourContext(context, 0, 0, kNullPermutation);
304 }
305 {
306 static const uint8_t kFoobarPermutation[kRC4ContextPermutationLength] = {
307 102, 214, 39, 49, 17, 132, 244, 106, 114, 76, 183, 212, 116, 73,
308 42, 103, 128, 246, 139, 199, 31, 234, 25, 109, 48, 19, 121, 4,
309 20, 54, 134, 77, 163, 38, 61, 101, 145, 78, 215, 96, 92, 80,
310 224, 168, 243, 210, 82, 252, 113, 56, 217, 62, 218, 129, 125, 33,
311 99, 9, 153, 59, 43, 13, 206, 124, 131, 18, 213, 118, 173, 122,
312 193, 172, 177, 105, 148, 207, 186, 5, 85, 32, 68, 220, 79, 84,
313 169, 209, 150, 7, 133, 63, 147, 93, 26, 130, 60, 117, 250, 57,
314 24, 247, 200, 127, 136, 66, 112, 107, 140, 154, 70, 170, 185, 138,
315 248, 236, 88, 86, 44, 216, 241, 35, 100, 151, 156, 74, 119, 55,
316 245, 46, 227, 208, 229, 16, 249, 149, 53, 157, 201, 75, 58, 28,
317 142, 238, 182, 180, 179, 144, 12, 6, 176, 10, 90, 239, 104, 40,
318 181, 194, 137, 69, 221, 205, 165, 188, 191, 87, 1, 91, 2, 171,
319 232, 34, 162, 166, 160, 126, 225, 167, 123, 197, 223, 195, 22, 203,
320 189, 237, 37, 27, 222, 175, 23, 143, 152, 192, 21, 231, 228, 141,
321 30, 204, 158, 240, 120, 98, 89, 83, 135, 251, 81, 196, 161, 3,
322 8, 230, 52, 219, 41, 242, 36, 97, 15, 155, 65, 187, 254, 64,
323 159, 67, 211, 108, 178, 146, 202, 11, 164, 226, 184, 50, 190, 174,
324 71, 233, 235, 198, 95, 51, 110, 255, 253, 72, 115, 0, 47, 94,
325 29, 45, 14, 111};
326 CRYPT_rc4_context context;
327 static const uint8_t kFooBar[] = "foobar";
328 CRYPT_ArcFourSetup(&context, {kFooBar, FX_ArraySize(kFooBar) - 1});
329 CheckArcFourContext(context, 0, 0, kFoobarPermutation);
330 }
331 }
332
TEST(FXCRYPT,CRYPT_ArcFourCrypt)333 TEST(FXCRYPT, CRYPT_ArcFourCrypt) {
334 static const uint8_t kDataShort[] =
335 "The Quick Fox Jumped Over The Lazy Brown Dog.";
336 static const uint8_t kDataLong[] =
337 "The Quick Fox Jumped Over The Lazy Brown Dog.\n"
338 "1234567890123456789012345678901234567890123456789012345678901234567890\n"
339 "1234567890123456789012345678901234567890123456789012345678901234567890\n"
340 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n"
341 "!@#$%^&*()[]{};':\",.<>/?\\|\r\t\n";
342 {
343 CRYPT_rc4_context context;
344 CRYPT_ArcFourSetup(&context, {});
345
346 uint8_t data_short[FX_ArraySize(kDataShort)];
347 memcpy(data_short, kDataShort, FX_ArraySize(kDataShort));
348 static const uint8_t kExpectedEncryptedDataShort[] = {
349 138, 112, 236, 97, 242, 66, 52, 89, 225, 38, 88, 8,
350 47, 78, 216, 24, 170, 106, 26, 199, 208, 131, 157, 242,
351 55, 11, 25, 90, 66, 182, 19, 255, 210, 181, 85, 69,
352 31, 240, 206, 171, 97, 62, 202, 172, 30, 252};
353 static_assert(
354 FX_ArraySize(kExpectedEncryptedDataShort) == FX_ArraySize(data_short),
355 "data_short mismatch");
356 CRYPT_ArcFourCrypt(&context, data_short);
357 for (size_t i = 0; i < FX_ArraySize(data_short); ++i)
358 EXPECT_EQ(kExpectedEncryptedDataShort[i], data_short[i]) << i;
359
360 static const uint8_t kPermutation[kRC4ContextPermutationLength] = {
361 0, 198, 10, 37, 253, 192, 171, 183, 99, 8, 144, 103, 208, 191,
362 149, 9, 228, 243, 94, 150, 169, 151, 210, 206, 221, 235, 32, 186,
363 212, 122, 72, 200, 236, 138, 244, 217, 158, 213, 139, 242, 17, 143,
364 50, 132, 12, 160, 145, 250, 214, 76, 123, 35, 27, 249, 203, 127,
365 64, 62, 33, 60, 248, 85, 177, 6, 142, 83, 110, 140, 41, 135,
366 196, 238, 156, 91, 141, 67, 5, 185, 131, 63, 137, 43, 172, 121,
367 70, 134, 237, 130, 25, 44, 153, 166, 78, 201, 42, 119, 215, 7,
368 126, 114, 97, 11, 53, 4, 254, 45, 102, 133, 230, 88, 193, 129,
369 18, 124, 84, 108, 239, 189, 152, 120, 115, 207, 234, 176, 86, 157,
370 164, 187, 71, 1, 15, 58, 29, 21, 46, 23, 247, 162, 95, 229,
371 13, 226, 159, 175, 56, 100, 96, 202, 101, 178, 154, 47, 205, 106,
372 148, 104, 93, 112, 26, 165, 128, 246, 146, 218, 66, 211, 65, 90,
373 252, 19, 40, 49, 223, 174, 255, 51, 77, 227, 48, 220, 168, 118,
374 224, 98, 75, 105, 125, 199, 73, 82, 57, 181, 81, 173, 68, 52,
375 232, 22, 2, 216, 113, 30, 109, 163, 92, 61, 14, 36, 38, 225,
376 79, 231, 170, 240, 20, 219, 204, 161, 180, 188, 116, 190, 241, 197,
377 179, 87, 74, 147, 80, 54, 69, 16, 167, 222, 136, 245, 55, 182,
378 3, 24, 209, 251, 59, 28, 111, 89, 195, 155, 194, 107, 233, 34,
379 117, 184, 31, 39};
380 CheckArcFourContext(context, 46, 135, kPermutation);
381 }
382 {
383 CRYPT_rc4_context context;
384 CRYPT_ArcFourSetup(&context, {});
385
386 uint8_t data_long[FX_ArraySize(kDataLong)];
387 memcpy(data_long, kDataLong, FX_ArraySize(kDataLong));
388 static const uint8_t kExpectedEncryptedDataLong[] = {
389 138, 112, 236, 97, 242, 66, 52, 89, 225, 38, 88, 8, 47, 78,
390 216, 24, 170, 106, 26, 199, 208, 131, 157, 242, 55, 11, 25, 90,
391 66, 182, 19, 255, 210, 181, 85, 69, 31, 240, 206, 171, 97, 62,
392 202, 172, 30, 246, 19, 43, 184, 0, 173, 27, 140, 90, 167, 240,
393 122, 125, 184, 49, 149, 71, 63, 104, 171, 144, 242, 106, 121, 124,
394 209, 149, 61, 1, 66, 186, 252, 47, 51, 170, 253, 75, 95, 41,
395 203, 28, 197, 174, 144, 209, 166, 98, 142, 125, 44, 5, 147, 42,
396 73, 178, 119, 90, 253, 69, 103, 178, 15, 136, 51, 112, 39, 81,
397 37, 111, 129, 232, 106, 159, 126, 142, 120, 124, 48, 140, 253, 12,
398 223, 208, 106, 76, 60, 238, 5, 162, 100, 226, 251, 156, 169, 35,
399 193, 10, 242, 210, 20, 96, 37, 84, 99, 183, 179, 203, 62, 122,
400 54, 6, 51, 239, 142, 250, 238, 41, 223, 58, 48, 101, 29, 187,
401 43, 235, 3, 5, 176, 33, 14, 171, 36, 26, 234, 207, 105, 79,
402 69, 126, 82, 183, 105, 228, 31, 173, 8, 240, 99, 5, 147, 206,
403 215, 140, 48, 190, 165, 50, 41, 232, 29, 105, 156, 64, 229, 165,
404 12, 64, 163, 255, 146, 108, 212, 125, 142, 101, 13, 99, 174, 10,
405 160, 68, 196, 120, 110, 201, 254, 158, 97, 215, 0, 207, 90, 23,
406 208, 161, 105, 226, 164, 114, 80, 137, 58, 107, 109, 42, 110, 100,
407 202, 170, 224, 89, 28, 5, 138, 19, 253, 105, 220, 105, 24, 187,
408 109, 89, 205, 89, 202};
409 static_assert(
410 FX_ArraySize(kExpectedEncryptedDataLong) == FX_ArraySize(data_long),
411 "data_long mismatch");
412 static_assert(FX_ArraySize(data_long) > 256, "too short");
413 CRYPT_ArcFourCrypt(&context, data_long);
414 for (size_t i = 0; i < FX_ArraySize(data_long); ++i)
415 EXPECT_EQ(kExpectedEncryptedDataLong[i], data_long[i]) << i;
416
417 static const uint8_t kPermutation[kRC4ContextPermutationLength] = {
418 172, 59, 196, 72, 101, 21, 215, 210, 212, 52, 243, 73, 47, 213,
419 211, 50, 228, 144, 66, 93, 169, 31, 237, 206, 221, 235, 222, 250,
420 97, 87, 174, 164, 190, 111, 27, 217, 173, 189, 65, 11, 115, 171,
421 104, 132, 12, 170, 205, 114, 7, 105, 37, 83, 78, 134, 236, 70,
422 197, 122, 177, 202, 39, 195, 30, 3, 86, 127, 74, 106, 68, 91,
423 110, 121, 208, 25, 56, 6, 28, 225, 163, 193, 166, 244, 119, 34,
424 23, 88, 108, 123, 162, 159, 242, 61, 230, 227, 254, 14, 4, 156,
425 161, 44, 58, 153, 33, 143, 129, 232, 182, 152, 76, 168, 238, 239,
426 185, 219, 233, 16, 188, 45, 40, 35, 103, 99, 89, 157, 241, 245,
427 192, 180, 248, 8, 85, 231, 146, 154, 252, 181, 107, 126, 98, 80,
428 102, 165, 199, 94, 49, 255, 18, 204, 216, 77, 20, 187, 145, 125,
429 1, 247, 79, 26, 207, 81, 117, 179, 186, 38, 175, 19, 139, 138,
430 149, 54, 64, 109, 249, 135, 142, 118, 17, 13, 201, 184, 55, 224,
431 209, 155, 113, 218, 82, 131, 178, 253, 140, 226, 43, 42, 24, 29,
432 229, 200, 137, 240, 203, 167, 95, 148, 15, 176, 60, 75, 53, 41,
433 150, 112, 160, 96, 22, 10, 234, 116, 130, 158, 214, 36, 9, 67,
434 198, 194, 191, 100, 124, 147, 32, 183, 120, 246, 51, 141, 46, 251,
435 92, 223, 133, 63, 0, 71, 48, 128, 220, 90, 62, 136, 2, 5,
436 69, 57, 151, 84};
437 CheckArcFourContext(context, 15, 222, kPermutation);
438 }
439 {
440 CRYPT_rc4_context context;
441 static const uint8_t kFooBar[] = "foobar";
442 CRYPT_ArcFourSetup(&context, {kFooBar, FX_ArraySize(kFooBar) - 1});
443
444 uint8_t data_short[FX_ArraySize(kDataShort)];
445 memcpy(data_short, kDataShort, FX_ArraySize(kDataShort));
446 static const uint8_t kExpectedEncryptedDataShort[] = {
447 59, 193, 117, 206, 167, 54, 218, 7, 229, 214, 188, 55,
448 90, 205, 196, 25, 36, 114, 199, 218, 161, 107, 122, 119,
449 106, 167, 44, 175, 240, 123, 192, 102, 174, 167, 105, 187,
450 202, 70, 121, 81, 17, 30, 5, 138, 116, 166};
451 static_assert(
452 FX_ArraySize(kExpectedEncryptedDataShort) == FX_ArraySize(data_short),
453 "data_short mismatch");
454 CRYPT_ArcFourCrypt(&context, data_short);
455 for (size_t i = 0; i < FX_ArraySize(data_short); ++i)
456 EXPECT_EQ(kExpectedEncryptedDataShort[i], data_short[i]) << i;
457
458 static const uint8_t kPermutation[kRC4ContextPermutationLength] = {
459 102, 41, 45, 82, 124, 141, 237, 38, 6, 64, 90, 140, 254, 96,
460 220, 109, 99, 49, 27, 227, 205, 75, 191, 37, 17, 54, 83, 196,
461 108, 79, 31, 190, 180, 0, 125, 194, 243, 156, 224, 246, 253, 193,
462 42, 81, 117, 56, 181, 252, 113, 210, 217, 62, 218, 129, 61, 33,
463 128, 9, 153, 59, 43, 13, 206, 48, 131, 18, 213, 118, 173, 122,
464 80, 172, 177, 105, 148, 207, 186, 5, 85, 32, 68, 215, 19, 84,
465 169, 209, 150, 7, 133, 63, 147, 93, 26, 130, 60, 145, 250, 57,
466 24, 247, 200, 127, 136, 66, 112, 107, 212, 154, 70, 170, 185, 138,
467 248, 236, 88, 86, 44, 216, 241, 35, 100, 151, 78, 74, 119, 55,
468 245, 46, 199, 208, 229, 16, 249, 149, 53, 157, 201, 234, 58, 28,
469 142, 238, 182, 163, 179, 144, 12, 114, 176, 10, 183, 239, 104, 40,
470 73, 101, 137, 69, 221, 134, 165, 188, 25, 87, 1, 91, 2, 171,
471 232, 34, 162, 166, 160, 126, 225, 167, 123, 197, 223, 195, 22, 203,
472 189, 244, 103, 139, 222, 175, 23, 143, 152, 192, 21, 231, 228, 132,
473 30, 204, 158, 240, 120, 98, 89, 121, 135, 251, 168, 4, 161, 3,
474 8, 230, 52, 219, 214, 242, 36, 97, 15, 155, 65, 187, 116, 76,
475 159, 67, 211, 20, 178, 146, 202, 11, 164, 226, 184, 50, 77, 174,
476 71, 233, 235, 198, 95, 51, 110, 255, 92, 72, 115, 106, 47, 94,
477 29, 39, 14, 111};
478 CheckArcFourContext(context, 46, 39, kPermutation);
479 }
480 {
481 CRYPT_rc4_context context;
482 static const uint8_t kFooBar[] = "foobar";
483 CRYPT_ArcFourSetup(&context, {kFooBar, FX_ArraySize(kFooBar) - 1});
484
485 uint8_t data_long[FX_ArraySize(kDataLong)];
486 memcpy(data_long, kDataLong, FX_ArraySize(kDataLong));
487 static const uint8_t kExpectedEncryptedDataLong[] = {
488 59, 193, 117, 206, 167, 54, 218, 7, 229, 214, 188, 55, 90, 205,
489 196, 25, 36, 114, 199, 218, 161, 107, 122, 119, 106, 167, 44, 175,
490 240, 123, 192, 102, 174, 167, 105, 187, 202, 70, 121, 81, 17, 30,
491 5, 138, 116, 172, 169, 50, 160, 116, 237, 117, 108, 241, 127, 61,
492 83, 45, 77, 176, 0, 106, 191, 221, 132, 143, 219, 94, 2, 235,
493 204, 166, 201, 139, 140, 163, 104, 115, 48, 37, 18, 114, 168, 49,
494 235, 163, 179, 131, 182, 218, 120, 200, 9, 90, 60, 47, 55, 235,
495 135, 37, 21, 170, 48, 112, 185, 169, 43, 233, 88, 134, 117, 126,
496 248, 40, 176, 248, 30, 131, 108, 43, 139, 68, 232, 219, 7, 39,
497 223, 45, 199, 243, 54, 171, 31, 37, 161, 24, 38, 251, 13, 144,
498 106, 215, 179, 203, 5, 253, 25, 32, 25, 146, 109, 193, 143, 141,
499 177, 226, 134, 222, 95, 79, 156, 202, 240, 34, 153, 145, 169, 150,
500 231, 63, 113, 242, 156, 39, 136, 249, 108, 50, 181, 22, 22, 180,
501 57, 76, 69, 62, 254, 47, 141, 249, 235, 90, 25, 34, 40, 194,
502 66, 86, 110, 192, 235, 191, 205, 133, 91, 32, 104, 65, 43, 36,
503 140, 36, 228, 156, 105, 251, 169, 168, 203, 189, 238, 221, 64, 200,
504 68, 137, 153, 9, 183, 84, 153, 140, 239, 0, 15, 50, 126, 145,
505 22, 110, 43, 56, 94, 127, 48, 96, 47, 172, 3, 31, 130, 249,
506 243, 73, 206, 89, 9, 93, 156, 167, 205, 166, 75, 227, 36, 34,
507 81, 124, 195, 246, 152};
508 static_assert(
509 FX_ArraySize(kExpectedEncryptedDataLong) == FX_ArraySize(data_long),
510 "data_long mismatch");
511 static_assert(FX_ArraySize(data_long) > 256, "too short");
512 CRYPT_ArcFourCrypt(&context, data_long);
513 for (size_t i = 0; i < FX_ArraySize(data_long); ++i)
514 EXPECT_EQ(kExpectedEncryptedDataLong[i], data_long[i]) << i;
515
516 static const uint8_t kPermutation[kRC4ContextPermutationLength] = {
517 188, 12, 81, 130, 228, 58, 124, 218, 72, 210, 50, 70, 166, 38,
518 110, 111, 73, 49, 27, 227, 249, 21, 1, 226, 17, 54, 53, 16,
519 108, 51, 31, 123, 221, 23, 125, 148, 5, 200, 208, 246, 253, 193,
520 42, 45, 236, 56, 230, 194, 178, 213, 120, 116, 7, 164, 33, 107,
521 189, 20, 133, 114, 173, 161, 59, 128, 3, 238, 65, 69, 144, 179,
522 44, 35, 8, 163, 252, 195, 160, 197, 204, 28, 34, 129, 67, 89,
523 22, 149, 199, 131, 182, 46, 250, 222, 155, 104, 10, 32, 139, 245,
524 90, 41, 132, 224, 83, 242, 135, 75, 74, 61, 62, 141, 43, 127,
525 255, 91, 170, 78, 157, 101, 243, 216, 254, 156, 229, 118, 174, 147,
526 103, 76, 196, 145, 134, 94, 205, 146, 202, 98, 100, 106, 232, 177,
527 187, 13, 80, 137, 151, 11, 82, 40, 167, 175, 25, 219, 168, 240,
528 99, 55, 4, 19, 180, 2, 203, 18, 171, 154, 113, 117, 6, 185,
529 172, 186, 237, 223, 233, 244, 217, 191, 190, 198, 97, 165, 220, 9,
530 214, 150, 184, 143, 206, 24, 209, 207, 36, 142, 87, 15, 159, 71,
531 84, 162, 169, 86, 48, 47, 140, 215, 241, 235, 158, 14, 26, 248,
532 138, 119, 212, 39, 88, 121, 96, 109, 29, 66, 136, 102, 225, 92,
533 201, 126, 122, 192, 60, 0, 64, 239, 183, 37, 57, 63, 234, 181,
534 153, 52, 176, 112, 93, 79, 77, 115, 231, 30, 95, 251, 211, 68,
535 105, 85, 247, 152};
536 CheckArcFourContext(context, 15, 68, kPermutation);
537 }
538 }
539
TEST(FXCRYPT,Sha384Empty)540 TEST(FXCRYPT, Sha384Empty) {
541 static const char kInput[] = "";
542 static const uint8_t kExpected[48] = {
543 0x38, 0xb0, 0x60, 0xa7, 0x51, 0xac, 0x96, 0x38, 0x4c, 0xd9, 0x32, 0x7e,
544 0xb1, 0xb1, 0xe3, 0x6a, 0x21, 0xfd, 0xb7, 0x11, 0x14, 0xbe, 0x07, 0x43,
545 0x4c, 0x0c, 0xc7, 0xbf, 0x63, 0xf6, 0xe1, 0xda, 0x27, 0x4e, 0xde, 0xbf,
546 0xe7, 0x6f, 0x65, 0xfb, 0xd5, 0x1a, 0xd2, 0xf1, 0x48, 0x98, 0xb9, 0x5b};
547 uint8_t actual[48];
548 CRYPT_SHA384Generate(reinterpret_cast<const uint8_t*>(kInput), strlen(kInput),
549 actual);
550 for (size_t i = 0; i < FX_ArraySize(kExpected); ++i)
551 EXPECT_EQ(kExpected[i], actual[i]) << " at byte " << i;
552 }
553
554 // Verified against echo -n "..." | openssl sha384
TEST(FXCRYPT,Sha384Test)555 TEST(FXCRYPT, Sha384Test) {
556 static const char kInput[] =
557 "This is a simple test. To see whether it is getting correct value.";
558 static const uint8_t kExpected[48] = {
559 0x95, 0x54, 0xff, 0xd3, 0x89, 0xf0, 0xd6, 0x42, 0xe9, 0x33, 0xfe, 0x4c,
560 0x07, 0x81, 0x19, 0xca, 0xcb, 0xb3, 0x14, 0x46, 0xd8, 0xbd, 0xa4, 0xf4,
561 0x12, 0xd5, 0x54, 0x03, 0x79, 0x28, 0xe5, 0xdc, 0x12, 0xa5, 0x1b, 0xe9,
562 0xfe, 0x59, 0x25, 0x3c, 0x92, 0x30, 0x5e, 0xe5, 0x0e, 0x03, 0x58, 0x07};
563 uint8_t actual[48];
564 CRYPT_SHA384Generate(reinterpret_cast<const uint8_t*>(kInput), strlen(kInput),
565 actual);
566 for (size_t i = 0; i < FX_ArraySize(kExpected); ++i)
567 EXPECT_EQ(kExpected[i], actual[i]) << " at byte " << i;
568 }
569
570 // Verified against echo -n "..." | openssl sha384
TEST(FXCRYPT,Sha384Pad112)571 TEST(FXCRYPT, Sha384Pad112) {
572 static const char kInput[] =
573 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
574 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
575 static const uint8_t kExpected[48] = {
576 0x18, 0x7d, 0x4e, 0x07, 0xcb, 0x30, 0x61, 0x03, 0xc6, 0x99, 0x67, 0xbf,
577 0x54, 0x4d, 0x0d, 0xfb, 0xe9, 0x04, 0x25, 0x77, 0x59, 0x9c, 0x73, 0xc3,
578 0x30, 0xab, 0xc0, 0xcb, 0x64, 0xc6, 0x12, 0x36, 0xd5, 0xed, 0x56, 0x5e,
579 0xe1, 0x91, 0x19, 0xd8, 0xc3, 0x17, 0x79, 0xa3, 0x8f, 0x79, 0x1f, 0xcd};
580 uint8_t actual[48];
581 EXPECT_EQ(112u, strlen(kInput));
582 CRYPT_SHA384Generate(reinterpret_cast<const uint8_t*>(kInput), strlen(kInput),
583 actual);
584 for (size_t i = 0; i < FX_ArraySize(kExpected); ++i)
585 EXPECT_EQ(kExpected[i], actual[i]) << " at byte " << i;
586 }
587
TEST(FXCRYPT,Sha512Empty)588 TEST(FXCRYPT, Sha512Empty) {
589 static const char kInput[] = "";
590 static const uint8_t kExpected[64] = {
591 0xcf, 0x83, 0xe1, 0x35, 0x7e, 0xef, 0xb8, 0xbd, 0xf1, 0x54, 0x28,
592 0x50, 0xd6, 0x6d, 0x80, 0x07, 0xd6, 0x20, 0xe4, 0x05, 0x0b, 0x57,
593 0x15, 0xdc, 0x83, 0xf4, 0xa9, 0x21, 0xd3, 0x6c, 0xe9, 0xce, 0x47,
594 0xd0, 0xd1, 0x3c, 0x5d, 0x85, 0xf2, 0xb0, 0xff, 0x83, 0x18, 0xd2,
595 0x87, 0x7e, 0xec, 0x2f, 0x63, 0xb9, 0x31, 0xbd, 0x47, 0x41, 0x7a,
596 0x81, 0xa5, 0x38, 0x32, 0x7a, 0xf9, 0x27, 0xda, 0x3e};
597 uint8_t actual[64];
598 CRYPT_SHA512Generate(reinterpret_cast<const uint8_t*>(kInput), strlen(kInput),
599 actual);
600 for (size_t i = 0; i < FX_ArraySize(kExpected); ++i)
601 EXPECT_EQ(kExpected[i], actual[i]) << " at byte " << i;
602 }
603
604 // Verified against echo -n "..." | openssl sha512
TEST(FXCRYPT,Sha512Test)605 TEST(FXCRYPT, Sha512Test) {
606 static const char kInput[] =
607 "This is a simple test. To see whether it is getting correct value.";
608 static const uint8_t kExpected[64] = {
609 0x86, 0xB5, 0x05, 0x63, 0xA2, 0x6F, 0xD6, 0xFA, 0xEB, 0x9B, 0xC3,
610 0xBB, 0x9E, 0xB7, 0x03, 0x82, 0xB6, 0x50, 0x55, 0x6B, 0x90, 0x69,
611 0xD0, 0xA7, 0x53, 0x0A, 0x34, 0xDD, 0xEA, 0x11, 0xCC, 0x91, 0x5C,
612 0xC7, 0x93, 0xCA, 0xAE, 0x30, 0xD1, 0x96, 0xBE, 0xD0, 0x35, 0x21,
613 0x4A, 0xC6, 0x42, 0x56, 0x0C, 0xA3, 0x00, 0x69, 0x44, 0x77, 0xCC,
614 0x3E, 0xD4, 0xD6, 0x10, 0x31, 0xC6, 0xC0, 0x58, 0xCF};
615 uint8_t actual[64];
616 CRYPT_SHA512Generate(reinterpret_cast<const uint8_t*>(kInput), strlen(kInput),
617 actual);
618 for (size_t i = 0; i < FX_ArraySize(kExpected); ++i)
619 EXPECT_EQ(kExpected[i], actual[i]) << " at byte " << i;
620 }
621
622 // Verified against echo -n "..." | openssl sha512
TEST(FXCRYPT,Sha512Pad112)623 TEST(FXCRYPT, Sha512Pad112) {
624 static const char kInput[] =
625 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
626 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
627 static const uint8_t kExpected[64] = {
628 0xc0, 0x1d, 0x08, 0x0e, 0xfd, 0x49, 0x27, 0x76, 0xa1, 0xc4, 0x3b,
629 0xd2, 0x3d, 0xd9, 0x9d, 0x0a, 0x2e, 0x62, 0x6d, 0x48, 0x1e, 0x16,
630 0x78, 0x2e, 0x75, 0xd5, 0x4c, 0x25, 0x03, 0xb5, 0xdc, 0x32, 0xbd,
631 0x05, 0xf0, 0xf1, 0xba, 0x33, 0xe5, 0x68, 0xb8, 0x8f, 0xd2, 0xd9,
632 0x70, 0x92, 0x9b, 0x71, 0x9e, 0xcb, 0xb1, 0x52, 0xf5, 0x8f, 0x13,
633 0x0a, 0x40, 0x7c, 0x88, 0x30, 0x60, 0x4b, 0x70, 0xca};
634 uint8_t actual[64];
635 EXPECT_EQ(112u, strlen(kInput));
636 CRYPT_SHA512Generate(reinterpret_cast<const uint8_t*>(kInput), strlen(kInput),
637 actual);
638 for (size_t i = 0; i < FX_ArraySize(kExpected); ++i)
639 EXPECT_EQ(kExpected[i], actual[i]) << " at byte " << i;
640 }
641