• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/utils.h"
29 
30 using std::string;
31 using std::vector;
32 
33 namespace chromeos_update_engine {
34 
35 // Generated by running this on a linux shell:
36 // $ echo -n hi | openssl dgst -sha256 -binary | openssl base64
37 static const char kExpectedHash[] =
38     "j0NDRmSPa5bfid2pAcUXaxCm2Dlh3TwayItZstwyeqQ=";
39 static const uint8_t kExpectedRawHash[] = {
40   0x8f, 0x43, 0x43, 0x46, 0x64, 0x8f, 0x6b, 0x96,
41   0xdf, 0x89, 0xdd, 0xa9, 0x01, 0xc5, 0x17, 0x6b,
42   0x10, 0xa6, 0xd8, 0x39, 0x61, 0xdd, 0x3c, 0x1a,
43   0xc8, 0x8b, 0x59, 0xb2, 0xdc, 0x32, 0x7a, 0xa4
44 };
45 
46 class HashCalculatorTest : public ::testing::Test {
47  public:
HashCalculatorTest()48   HashCalculatorTest() {}
49 };
50 
TEST_F(HashCalculatorTest,SimpleTest)51 TEST_F(HashCalculatorTest, SimpleTest) {
52   HashCalculator calc;
53   calc.Update("hi", 2);
54   calc.Finalize();
55   EXPECT_EQ(kExpectedHash, calc.hash());
56   brillo::Blob raw_hash(std::begin(kExpectedRawHash),
57                         std::end(kExpectedRawHash));
58   EXPECT_TRUE(raw_hash == calc.raw_hash());
59 }
60 
TEST_F(HashCalculatorTest,MultiUpdateTest)61 TEST_F(HashCalculatorTest, MultiUpdateTest) {
62   HashCalculator calc;
63   calc.Update("h", 1);
64   calc.Update("i", 1);
65   calc.Finalize();
66   EXPECT_EQ(kExpectedHash, calc.hash());
67   brillo::Blob raw_hash(std::begin(kExpectedRawHash),
68                         std::end(kExpectedRawHash));
69   EXPECT_TRUE(raw_hash == calc.raw_hash());
70 }
71 
TEST_F(HashCalculatorTest,ContextTest)72 TEST_F(HashCalculatorTest, ContextTest) {
73   HashCalculator calc;
74   calc.Update("h", 1);
75   string calc_context = calc.GetContext();
76   calc.Finalize();
77   HashCalculator calc_next;
78   calc_next.SetContext(calc_context);
79   calc_next.Update("i", 1);
80   calc_next.Finalize();
81   EXPECT_EQ(kExpectedHash, calc_next.hash());
82   brillo::Blob raw_hash(std::begin(kExpectedRawHash),
83                         std::end(kExpectedRawHash));
84   EXPECT_TRUE(raw_hash == calc_next.raw_hash());
85 }
86 
TEST_F(HashCalculatorTest,BigTest)87 TEST_F(HashCalculatorTest, BigTest) {
88   HashCalculator calc;
89 
90   int digit_count = 1;
91   int next_overflow = 10;
92   for (int i = 0; i < 1000000; i++) {
93     char buf[8];
94     if (i == next_overflow) {
95       next_overflow *= 10;
96       digit_count++;
97     }
98     ASSERT_EQ(digit_count, snprintf(buf, sizeof(buf), "%d", i)) << " i = " << i;
99     calc.Update(buf, strlen(buf));
100   }
101   calc.Finalize();
102 
103   // Hash constant generated by running this on a linux shell:
104   // $ C=0
105   // $ while [ $C -lt 1000000 ]; do
106   //     echo -n $C
107   //     let C=C+1
108   //   done | openssl dgst -sha256 -binary | openssl base64
109   EXPECT_EQ("NZf8k6SPBkYMvhaX8YgzuMgbkLP1XZ+neM8K5wcSsf8=", calc.hash());
110 }
111 
TEST_F(HashCalculatorTest,UpdateFileSimpleTest)112 TEST_F(HashCalculatorTest, UpdateFileSimpleTest) {
113   string data_path;
114   ASSERT_TRUE(
115       utils::MakeTempFile("data.XXXXXX", &data_path, nullptr));
116   ScopedPathUnlinker data_path_unlinker(data_path);
117   ASSERT_TRUE(utils::WriteFile(data_path.c_str(), "hi", 2));
118 
119   static const int kLengths[] = { -1, 2, 10 };
120   for (size_t i = 0; i < arraysize(kLengths); i++) {
121     HashCalculator calc;
122     EXPECT_EQ(2, calc.UpdateFile(data_path, kLengths[i]));
123     EXPECT_TRUE(calc.Finalize());
124     EXPECT_EQ(kExpectedHash, calc.hash());
125     brillo::Blob raw_hash(std::begin(kExpectedRawHash),
126                           std::end(kExpectedRawHash));
127     EXPECT_TRUE(raw_hash == calc.raw_hash());
128   }
129 
130   HashCalculator calc;
131   EXPECT_EQ(0, calc.UpdateFile(data_path, 0));
132   EXPECT_EQ(1, calc.UpdateFile(data_path, 1));
133   EXPECT_TRUE(calc.Finalize());
134   // echo -n h | openssl dgst -sha256 -binary | openssl base64
135   EXPECT_EQ("qqlAJmTxpB9A67xSyZk+tmrrNmYClY/fqig7ceZNsSM=", calc.hash());
136 }
137 
TEST_F(HashCalculatorTest,RawHashOfFileSimpleTest)138 TEST_F(HashCalculatorTest, RawHashOfFileSimpleTest) {
139   string data_path;
140   ASSERT_TRUE(
141       utils::MakeTempFile("data.XXXXXX", &data_path, nullptr));
142   ScopedPathUnlinker data_path_unlinker(data_path);
143   ASSERT_TRUE(utils::WriteFile(data_path.c_str(), "hi", 2));
144 
145   static const int kLengths[] = { -1, 2, 10 };
146   for (size_t i = 0; i < arraysize(kLengths); i++) {
147     brillo::Blob exp_raw_hash(std::begin(kExpectedRawHash),
148                               std::end(kExpectedRawHash));
149     brillo::Blob raw_hash;
150     EXPECT_EQ(2, HashCalculator::RawHashOfFile(data_path,
151                                                kLengths[i],
152                                                &raw_hash));
153     EXPECT_TRUE(exp_raw_hash == raw_hash);
154   }
155 }
156 
TEST_F(HashCalculatorTest,UpdateFileNonexistentTest)157 TEST_F(HashCalculatorTest, UpdateFileNonexistentTest) {
158   HashCalculator calc;
159   EXPECT_EQ(-1, calc.UpdateFile("/some/non-existent/file", -1));
160 }
161 
TEST_F(HashCalculatorTest,AbortTest)162 TEST_F(HashCalculatorTest, AbortTest) {
163   // Just make sure we don't crash and valgrind doesn't detect memory leaks
164   {
165     HashCalculator calc;
166   }
167   {
168     HashCalculator calc;
169     calc.Update("h", 1);
170   }
171 }
172 
173 }  // namespace chromeos_update_engine
174