OLD | NEW |
1 // Copyright (c) 2009 The Chromium OS Authors. All rights reserved. | 1 // Copyright (c) 2009 The Chromium OS 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 "update_engine/omaha_hash_calculator.h" | 5 #include "update_engine/omaha_hash_calculator.h" |
6 | 6 |
7 #include <openssl/bio.h> | 7 #include <openssl/bio.h> |
8 #include <openssl/buffer.h> | 8 #include <openssl/buffer.h> |
9 #include <openssl/evp.h> | 9 #include <openssl/evp.h> |
10 #include "base/logging.h" | 10 #include "base/logging.h" |
11 #include "update_engine/utils.h" | 11 #include "update_engine/utils.h" |
12 | 12 |
13 using std::string; | 13 using std::string; |
14 using std::vector; | 14 using std::vector; |
15 | 15 |
16 namespace chromeos_update_engine { | 16 namespace chromeos_update_engine { |
17 | 17 |
18 OmahaHashCalculator::OmahaHashCalculator() : valid_(false) { | 18 OmahaHashCalculator::OmahaHashCalculator() : valid_(false) { |
19 valid_ = (SHA1_Init(&ctx_) == 1); | 19 valid_ = (SHA256_Init(&ctx_) == 1); |
20 LOG_IF(ERROR, !valid_) << "SHA1_Init failed"; | 20 LOG_IF(ERROR, !valid_) << "SHA256_Init failed"; |
21 } | 21 } |
22 | 22 |
23 // Update is called with all of the data that should be hashed in order. | 23 // Update is called with all of the data that should be hashed in order. |
24 // Mostly just passes the data through to OpenSSL's SHA1_Update() | 24 // Mostly just passes the data through to OpenSSL's SHA256_Update() |
25 bool OmahaHashCalculator::Update(const char* data, size_t length) { | 25 bool OmahaHashCalculator::Update(const char* data, size_t length) { |
26 TEST_AND_RETURN_FALSE(valid_); | 26 TEST_AND_RETURN_FALSE(valid_); |
27 TEST_AND_RETURN_FALSE(hash_.empty()); | 27 TEST_AND_RETURN_FALSE(hash_.empty()); |
28 COMPILE_ASSERT(sizeof(size_t) <= sizeof(unsigned long), | 28 COMPILE_ASSERT(sizeof(size_t) <= sizeof(unsigned long), |
29 length_param_may_be_truncated_in_SHA1_Update); | 29 length_param_may_be_truncated_in_SHA256_Update); |
30 TEST_AND_RETURN_FALSE(SHA1_Update(&ctx_, data, length) == 1); | 30 TEST_AND_RETURN_FALSE(SHA256_Update(&ctx_, data, length) == 1); |
31 return true; | 31 return true; |
32 } | 32 } |
33 | 33 |
34 // Call Finalize() when all data has been passed in. This mostly just | 34 // Call Finalize() when all data has been passed in. This mostly just |
35 // calls OpenSSL's SHA1_Final() and then base64 encodes the hash. | 35 // calls OpenSSL's SHA256_Final() and then base64 encodes the hash. |
36 bool OmahaHashCalculator::Finalize() { | 36 bool OmahaHashCalculator::Finalize() { |
37 bool success = true; | 37 bool success = true; |
38 TEST_AND_RETURN_FALSE(hash_.empty()); | 38 TEST_AND_RETURN_FALSE(hash_.empty()); |
39 unsigned char md[SHA_DIGEST_LENGTH]; | 39 unsigned char md[SHA256_DIGEST_LENGTH]; |
40 TEST_AND_RETURN_FALSE(SHA1_Final(md, &ctx_) == 1); | 40 TEST_AND_RETURN_FALSE(SHA256_Final(md, &ctx_) == 1); |
41 | 41 |
42 // Convert md to base64 encoding and store it in hash_ | 42 // Convert md to base64 encoding and store it in hash_ |
43 BIO *b64 = BIO_new(BIO_f_base64()); | 43 BIO *b64 = BIO_new(BIO_f_base64()); |
44 if (!b64) | 44 if (!b64) |
45 LOG(INFO) << "BIO_new(BIO_f_base64()) failed"; | 45 LOG(INFO) << "BIO_new(BIO_f_base64()) failed"; |
46 BIO *bmem = BIO_new(BIO_s_mem()); | 46 BIO *bmem = BIO_new(BIO_s_mem()); |
47 if (!bmem) | 47 if (!bmem) |
48 LOG(INFO) << "BIO_new(BIO_s_mem()) failed"; | 48 LOG(INFO) << "BIO_new(BIO_s_mem()) failed"; |
49 if (b64 && bmem) { | 49 if (b64 && bmem) { |
50 b64 = BIO_push(b64, bmem); | 50 b64 = BIO_push(b64, bmem); |
51 success = (BIO_write(b64, md, sizeof(md)) == sizeof(md)); | 51 success = (BIO_write(b64, md, sizeof(md)) == sizeof(md)); |
52 if (success) | 52 if (success) |
53 success = (BIO_flush(b64) == 1); | 53 success = (BIO_flush(b64) == 1); |
54 | 54 |
55 BUF_MEM *bptr = NULL; | 55 BUF_MEM *bptr = NULL; |
56 BIO_get_mem_ptr(b64, &bptr); | 56 BIO_get_mem_ptr(b64, &bptr); |
57 hash_.assign(bptr->data, bptr->length - 1); | 57 hash_.assign(bptr->data, bptr->length - 1); |
58 } | 58 } |
59 if (b64) { | 59 if (b64) { |
60 BIO_free_all(b64); | 60 BIO_free_all(b64); |
61 b64 = NULL; | 61 b64 = NULL; |
62 } | 62 } |
63 return success; | 63 return success; |
64 } | 64 } |
65 | 65 |
66 bool OmahaHashCalculator::RawHashOfData(const vector<char>& data, | 66 bool OmahaHashCalculator::RawHashOfData(const vector<char>& data, |
67 vector<char>* out_hash) { | 67 vector<char>* out_hash) { |
68 OmahaHashCalculator calc; | 68 OmahaHashCalculator calc; |
69 calc.Update(&data[0], data.size()); | 69 calc.Update(&data[0], data.size()); |
70 | 70 |
71 out_hash->resize(out_hash->size() + SHA_DIGEST_LENGTH); | 71 out_hash->resize(out_hash->size() + SHA256_DIGEST_LENGTH); |
72 TEST_AND_RETURN_FALSE( | 72 TEST_AND_RETURN_FALSE( |
73 SHA1_Final(reinterpret_cast<unsigned char*>(&(*(out_hash->end() - | 73 SHA256_Final(reinterpret_cast<unsigned char*>(&(*(out_hash->end() - |
74 SHA_DIGEST_LENGTH))), | 74 SHA256_DIGEST_LENGTH))), |
75 &calc.ctx_) == 1); | 75 &calc.ctx_) == 1); |
76 return true; | 76 return true; |
77 } | 77 } |
78 | 78 |
79 string OmahaHashCalculator::OmahaHashOfBytes( | 79 string OmahaHashCalculator::OmahaHashOfBytes( |
80 const void* data, size_t length) { | 80 const void* data, size_t length) { |
81 OmahaHashCalculator calc; | 81 OmahaHashCalculator calc; |
82 calc.Update(reinterpret_cast<const char*>(data), length); | 82 calc.Update(reinterpret_cast<const char*>(data), length); |
83 calc.Finalize(); | 83 calc.Finalize(); |
84 return calc.hash(); | 84 return calc.hash(); |
85 } | 85 } |
86 | 86 |
87 string OmahaHashCalculator::OmahaHashOfString(const string& str) { | 87 string OmahaHashCalculator::OmahaHashOfString(const string& str) { |
88 return OmahaHashOfBytes(str.data(), str.size()); | 88 return OmahaHashOfBytes(str.data(), str.size()); |
89 } | 89 } |
90 | 90 |
91 string OmahaHashCalculator::OmahaHashOfData(const vector<char>& data) { | 91 string OmahaHashCalculator::OmahaHashOfData(const vector<char>& data) { |
92 return OmahaHashOfBytes(&data[0], data.size()); | 92 return OmahaHashOfBytes(&data[0], data.size()); |
93 } | 93 } |
94 | 94 |
95 } // namespace chromeos_update_engine | 95 } // namespace chromeos_update_engine |
OLD | NEW |