1 //
2 // Copyright (C) 2009 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 #include "update_engine/common/hash_calculator.h"
18
19 #include <math.h>
20 #include <unistd.h>
21
22 #include <string>
23 #include <vector>
24
25 #include <brillo/secure_blob.h>
26 #include <gtest/gtest.h>
27
28 #include "update_engine/common/libcurl_http_fetcher.h"
29 #include "update_engine/common/utils.h"
30
31 using std::string;
32 using std::vector;
33
34 namespace chromeos_update_engine {
35
36 // Generated by running this on a linux shell:
37 // $ echo -n hi | openssl dgst -sha256 -binary | openssl base64
38 static const char kExpectedHash[] =
39 "j0NDRmSPa5bfid2pAcUXaxCm2Dlh3TwayItZstwyeqQ=";
40 static const uint8_t kExpectedRawHash[] = {
41 0x8f, 0x43, 0x43, 0x46, 0x64, 0x8f, 0x6b, 0x96,
42 0xdf, 0x89, 0xdd, 0xa9, 0x01, 0xc5, 0x17, 0x6b,
43 0x10, 0xa6, 0xd8, 0x39, 0x61, 0xdd, 0x3c, 0x1a,
44 0xc8, 0x8b, 0x59, 0xb2, 0xdc, 0x32, 0x7a, 0xa4
45 };
46
47 class HashCalculatorTest : public ::testing::Test {
48 public:
HashCalculatorTest()49 HashCalculatorTest() {}
50 };
51
TEST_F(HashCalculatorTest,SimpleTest)52 TEST_F(HashCalculatorTest, SimpleTest) {
53 HashCalculator calc;
54 calc.Update("hi", 2);
55 calc.Finalize();
56 EXPECT_EQ(kExpectedHash, calc.hash());
57 brillo::Blob raw_hash(std::begin(kExpectedRawHash),
58 std::end(kExpectedRawHash));
59 EXPECT_TRUE(raw_hash == calc.raw_hash());
60 }
61
TEST_F(HashCalculatorTest,MultiUpdateTest)62 TEST_F(HashCalculatorTest, MultiUpdateTest) {
63 HashCalculator calc;
64 calc.Update("h", 1);
65 calc.Update("i", 1);
66 calc.Finalize();
67 EXPECT_EQ(kExpectedHash, calc.hash());
68 brillo::Blob raw_hash(std::begin(kExpectedRawHash),
69 std::end(kExpectedRawHash));
70 EXPECT_TRUE(raw_hash == calc.raw_hash());
71 }
72
TEST_F(HashCalculatorTest,ContextTest)73 TEST_F(HashCalculatorTest, ContextTest) {
74 HashCalculator calc;
75 calc.Update("h", 1);
76 string calc_context = calc.GetContext();
77 calc.Finalize();
78 HashCalculator calc_next;
79 calc_next.SetContext(calc_context);
80 calc_next.Update("i", 1);
81 calc_next.Finalize();
82 EXPECT_EQ(kExpectedHash, calc_next.hash());
83 brillo::Blob raw_hash(std::begin(kExpectedRawHash),
84 std::end(kExpectedRawHash));
85 EXPECT_TRUE(raw_hash == calc_next.raw_hash());
86 }
87
TEST_F(HashCalculatorTest,BigTest)88 TEST_F(HashCalculatorTest, BigTest) {
89 HashCalculator calc;
90
91 int digit_count = 1;
92 int next_overflow = 10;
93 for (int i = 0; i < 1000000; i++) {
94 char buf[8];
95 if (i == next_overflow) {
96 next_overflow *= 10;
97 digit_count++;
98 }
99 ASSERT_EQ(digit_count, snprintf(buf, sizeof(buf), "%d", i)) << " i = " << i;
100 calc.Update(buf, strlen(buf));
101 }
102 calc.Finalize();
103
104 // Hash constant generated by running this on a linux shell:
105 // $ C=0
106 // $ while [ $C -lt 1000000 ]; do
107 // echo -n $C
108 // let C=C+1
109 // done | openssl dgst -sha256 -binary | openssl base64
110 EXPECT_EQ("NZf8k6SPBkYMvhaX8YgzuMgbkLP1XZ+neM8K5wcSsf8=", calc.hash());
111 }
112
TEST_F(HashCalculatorTest,UpdateFileSimpleTest)113 TEST_F(HashCalculatorTest, UpdateFileSimpleTest) {
114 string data_path;
115 ASSERT_TRUE(
116 utils::MakeTempFile("data.XXXXXX", &data_path, nullptr));
117 ScopedPathUnlinker data_path_unlinker(data_path);
118 ASSERT_TRUE(utils::WriteFile(data_path.c_str(), "hi", 2));
119
120 static const int kLengths[] = { -1, 2, 10 };
121 for (size_t i = 0; i < arraysize(kLengths); i++) {
122 HashCalculator calc;
123 EXPECT_EQ(2, calc.UpdateFile(data_path, kLengths[i]));
124 EXPECT_TRUE(calc.Finalize());
125 EXPECT_EQ(kExpectedHash, calc.hash());
126 brillo::Blob raw_hash(std::begin(kExpectedRawHash),
127 std::end(kExpectedRawHash));
128 EXPECT_TRUE(raw_hash == calc.raw_hash());
129 }
130
131 HashCalculator calc;
132 EXPECT_EQ(0, calc.UpdateFile(data_path, 0));
133 EXPECT_EQ(1, calc.UpdateFile(data_path, 1));
134 EXPECT_TRUE(calc.Finalize());
135 // echo -n h | openssl dgst -sha256 -binary | openssl base64
136 EXPECT_EQ("qqlAJmTxpB9A67xSyZk+tmrrNmYClY/fqig7ceZNsSM=", calc.hash());
137 }
138
TEST_F(HashCalculatorTest,RawHashOfFileSimpleTest)139 TEST_F(HashCalculatorTest, RawHashOfFileSimpleTest) {
140 string data_path;
141 ASSERT_TRUE(
142 utils::MakeTempFile("data.XXXXXX", &data_path, nullptr));
143 ScopedPathUnlinker data_path_unlinker(data_path);
144 ASSERT_TRUE(utils::WriteFile(data_path.c_str(), "hi", 2));
145
146 static const int kLengths[] = { -1, 2, 10 };
147 for (size_t i = 0; i < arraysize(kLengths); i++) {
148 brillo::Blob exp_raw_hash(std::begin(kExpectedRawHash),
149 std::end(kExpectedRawHash));
150 brillo::Blob raw_hash;
151 EXPECT_EQ(2, HashCalculator::RawHashOfFile(data_path,
152 kLengths[i],
153 &raw_hash));
154 EXPECT_TRUE(exp_raw_hash == raw_hash);
155 }
156 }
157
TEST_F(HashCalculatorTest,UpdateFileNonexistentTest)158 TEST_F(HashCalculatorTest, UpdateFileNonexistentTest) {
159 HashCalculator calc;
160 EXPECT_EQ(-1, calc.UpdateFile("/some/non-existent/file", -1));
161 }
162
TEST_F(HashCalculatorTest,AbortTest)163 TEST_F(HashCalculatorTest, AbortTest) {
164 // Just make sure we don't crash and valgrind doesn't detect memory leaks
165 {
166 HashCalculator calc;
167 }
168 {
169 HashCalculator calc;
170 calc.Update("h", 1);
171 }
172 }
173
174 } // namespace chromeos_update_engine
175