OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 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 "crypto/sha2.h" | 5 #include "crypto/sha2.h" |
6 | 6 |
7 #include "base/basictypes.h" | 7 #include <stddef.h> |
| 8 #include <stdint.h> |
| 9 |
8 #include "testing/gtest/include/gtest/gtest.h" | 10 #include "testing/gtest/include/gtest/gtest.h" |
9 | 11 |
10 TEST(Sha256Test, Test1) { | 12 TEST(Sha256Test, Test1) { |
11 // Example B.1 from FIPS 180-2: one-block message. | 13 // Example B.1 from FIPS 180-2: one-block message. |
12 std::string input1 = "abc"; | 14 std::string input1 = "abc"; |
13 int expected1[] = { 0xba, 0x78, 0x16, 0xbf, | 15 int expected1[] = { 0xba, 0x78, 0x16, 0xbf, |
14 0x8f, 0x01, 0xcf, 0xea, | 16 0x8f, 0x01, 0xcf, 0xea, |
15 0x41, 0x41, 0x40, 0xde, | 17 0x41, 0x41, 0x40, 0xde, |
16 0x5d, 0xae, 0x22, 0x23, | 18 0x5d, 0xae, 0x22, 0x23, |
17 0xb0, 0x03, 0x61, 0xa3, | 19 0xb0, 0x03, 0x61, 0xa3, |
18 0x96, 0x17, 0x7a, 0x9c, | 20 0x96, 0x17, 0x7a, 0x9c, |
19 0xb4, 0x10, 0xff, 0x61, | 21 0xb4, 0x10, 0xff, 0x61, |
20 0xf2, 0x00, 0x15, 0xad }; | 22 0xf2, 0x00, 0x15, 0xad }; |
21 | 23 |
22 uint8 output1[crypto::kSHA256Length]; | 24 uint8_t output1[crypto::kSHA256Length]; |
23 crypto::SHA256HashString(input1, output1, sizeof(output1)); | 25 crypto::SHA256HashString(input1, output1, sizeof(output1)); |
24 for (size_t i = 0; i < crypto::kSHA256Length; i++) | 26 for (size_t i = 0; i < crypto::kSHA256Length; i++) |
25 EXPECT_EQ(expected1[i], static_cast<int>(output1[i])); | 27 EXPECT_EQ(expected1[i], static_cast<int>(output1[i])); |
26 | 28 |
27 uint8 output_truncated1[4]; // 4 bytes == 32 bits | 29 uint8_t output_truncated1[4]; // 4 bytes == 32 bits |
28 crypto::SHA256HashString(input1, | 30 crypto::SHA256HashString(input1, |
29 output_truncated1, sizeof(output_truncated1)); | 31 output_truncated1, sizeof(output_truncated1)); |
30 for (size_t i = 0; i < sizeof(output_truncated1); i++) | 32 for (size_t i = 0; i < sizeof(output_truncated1); i++) |
31 EXPECT_EQ(expected1[i], static_cast<int>(output_truncated1[i])); | 33 EXPECT_EQ(expected1[i], static_cast<int>(output_truncated1[i])); |
32 } | 34 } |
33 | 35 |
34 TEST(Sha256Test, Test1_String) { | 36 TEST(Sha256Test, Test1_String) { |
35 // Same as the above, but using the wrapper that returns a std::string. | 37 // Same as the above, but using the wrapper that returns a std::string. |
36 // Example B.1 from FIPS 180-2: one-block message. | 38 // Example B.1 from FIPS 180-2: one-block message. |
37 std::string input1 = "abc"; | 39 std::string input1 = "abc"; |
38 int expected1[] = { 0xba, 0x78, 0x16, 0xbf, | 40 int expected1[] = { 0xba, 0x78, 0x16, 0xbf, |
39 0x8f, 0x01, 0xcf, 0xea, | 41 0x8f, 0x01, 0xcf, 0xea, |
40 0x41, 0x41, 0x40, 0xde, | 42 0x41, 0x41, 0x40, 0xde, |
41 0x5d, 0xae, 0x22, 0x23, | 43 0x5d, 0xae, 0x22, 0x23, |
42 0xb0, 0x03, 0x61, 0xa3, | 44 0xb0, 0x03, 0x61, 0xa3, |
43 0x96, 0x17, 0x7a, 0x9c, | 45 0x96, 0x17, 0x7a, 0x9c, |
44 0xb4, 0x10, 0xff, 0x61, | 46 0xb4, 0x10, 0xff, 0x61, |
45 0xf2, 0x00, 0x15, 0xad }; | 47 0xf2, 0x00, 0x15, 0xad }; |
46 | 48 |
47 std::string output1 = crypto::SHA256HashString(input1); | 49 std::string output1 = crypto::SHA256HashString(input1); |
48 ASSERT_EQ(crypto::kSHA256Length, output1.size()); | 50 ASSERT_EQ(crypto::kSHA256Length, output1.size()); |
49 for (size_t i = 0; i < crypto::kSHA256Length; i++) | 51 for (size_t i = 0; i < crypto::kSHA256Length; i++) |
50 EXPECT_EQ(expected1[i], static_cast<uint8>(output1[i])); | 52 EXPECT_EQ(expected1[i], static_cast<uint8_t>(output1[i])); |
51 } | 53 } |
52 | 54 |
53 TEST(Sha256Test, Test2) { | 55 TEST(Sha256Test, Test2) { |
54 // Example B.2 from FIPS 180-2: multi-block message. | 56 // Example B.2 from FIPS 180-2: multi-block message. |
55 std::string input2 = | 57 std::string input2 = |
56 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"; | 58 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"; |
57 int expected2[] = { 0x24, 0x8d, 0x6a, 0x61, | 59 int expected2[] = { 0x24, 0x8d, 0x6a, 0x61, |
58 0xd2, 0x06, 0x38, 0xb8, | 60 0xd2, 0x06, 0x38, 0xb8, |
59 0xe5, 0xc0, 0x26, 0x93, | 61 0xe5, 0xc0, 0x26, 0x93, |
60 0x0c, 0x3e, 0x60, 0x39, | 62 0x0c, 0x3e, 0x60, 0x39, |
61 0xa3, 0x3c, 0xe4, 0x59, | 63 0xa3, 0x3c, 0xe4, 0x59, |
62 0x64, 0xff, 0x21, 0x67, | 64 0x64, 0xff, 0x21, 0x67, |
63 0xf6, 0xec, 0xed, 0xd4, | 65 0xf6, 0xec, 0xed, 0xd4, |
64 0x19, 0xdb, 0x06, 0xc1 }; | 66 0x19, 0xdb, 0x06, 0xc1 }; |
65 | 67 |
66 uint8 output2[crypto::kSHA256Length]; | 68 uint8_t output2[crypto::kSHA256Length]; |
67 crypto::SHA256HashString(input2, output2, sizeof(output2)); | 69 crypto::SHA256HashString(input2, output2, sizeof(output2)); |
68 for (size_t i = 0; i < crypto::kSHA256Length; i++) | 70 for (size_t i = 0; i < crypto::kSHA256Length; i++) |
69 EXPECT_EQ(expected2[i], static_cast<int>(output2[i])); | 71 EXPECT_EQ(expected2[i], static_cast<int>(output2[i])); |
70 | 72 |
71 uint8 output_truncated2[6]; | 73 uint8_t output_truncated2[6]; |
72 crypto::SHA256HashString(input2, | 74 crypto::SHA256HashString(input2, |
73 output_truncated2, sizeof(output_truncated2)); | 75 output_truncated2, sizeof(output_truncated2)); |
74 for (size_t i = 0; i < sizeof(output_truncated2); i++) | 76 for (size_t i = 0; i < sizeof(output_truncated2); i++) |
75 EXPECT_EQ(expected2[i], static_cast<int>(output_truncated2[i])); | 77 EXPECT_EQ(expected2[i], static_cast<int>(output_truncated2[i])); |
76 } | 78 } |
77 | 79 |
78 TEST(Sha256Test, Test3) { | 80 TEST(Sha256Test, Test3) { |
79 // Example B.3 from FIPS 180-2: long message. | 81 // Example B.3 from FIPS 180-2: long message. |
80 std::string input3(1000000, 'a'); // 'a' repeated a million times | 82 std::string input3(1000000, 'a'); // 'a' repeated a million times |
81 int expected3[] = { 0xcd, 0xc7, 0x6e, 0x5c, | 83 int expected3[] = { 0xcd, 0xc7, 0x6e, 0x5c, |
82 0x99, 0x14, 0xfb, 0x92, | 84 0x99, 0x14, 0xfb, 0x92, |
83 0x81, 0xa1, 0xc7, 0xe2, | 85 0x81, 0xa1, 0xc7, 0xe2, |
84 0x84, 0xd7, 0x3e, 0x67, | 86 0x84, 0xd7, 0x3e, 0x67, |
85 0xf1, 0x80, 0x9a, 0x48, | 87 0xf1, 0x80, 0x9a, 0x48, |
86 0xa4, 0x97, 0x20, 0x0e, | 88 0xa4, 0x97, 0x20, 0x0e, |
87 0x04, 0x6d, 0x39, 0xcc, | 89 0x04, 0x6d, 0x39, 0xcc, |
88 0xc7, 0x11, 0x2c, 0xd0 }; | 90 0xc7, 0x11, 0x2c, 0xd0 }; |
89 | 91 |
90 uint8 output3[crypto::kSHA256Length]; | 92 uint8_t output3[crypto::kSHA256Length]; |
91 crypto::SHA256HashString(input3, output3, sizeof(output3)); | 93 crypto::SHA256HashString(input3, output3, sizeof(output3)); |
92 for (size_t i = 0; i < crypto::kSHA256Length; i++) | 94 for (size_t i = 0; i < crypto::kSHA256Length; i++) |
93 EXPECT_EQ(expected3[i], static_cast<int>(output3[i])); | 95 EXPECT_EQ(expected3[i], static_cast<int>(output3[i])); |
94 | 96 |
95 uint8 output_truncated3[12]; | 97 uint8_t output_truncated3[12]; |
96 crypto::SHA256HashString(input3, | 98 crypto::SHA256HashString(input3, |
97 output_truncated3, sizeof(output_truncated3)); | 99 output_truncated3, sizeof(output_truncated3)); |
98 for (size_t i = 0; i < sizeof(output_truncated3); i++) | 100 for (size_t i = 0; i < sizeof(output_truncated3); i++) |
99 EXPECT_EQ(expected3[i], static_cast<int>(output_truncated3[i])); | 101 EXPECT_EQ(expected3[i], static_cast<int>(output_truncated3[i])); |
100 } | 102 } |
OLD | NEW |