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
3 // found in the LICENSE file.
9 #include "base/basictypes.h"
13 // Implementation of SHA-1. Only handles data in byte-sized blocks,
14 // which simplifies the code a fair bit.
16 // Identifier names follow notation in FIPS PUB 180-3, where you'll
17 // also find a description of the algorithm:
18 // http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf
22 // SecureHashAlgorithm sha;
23 // while(there is data to hash)
24 // sha.Update(moredata, size of data);
26 // memcpy(somewhere, sha.Digest(), 20);
28 // to reuse the instance of sha, call sha.Init();
30 // TODO(jhawkins): Replace this implementation with a per-platform
31 // implementation using each platform's crypto library. See
32 // http://crbug.com/47218
34 class SecureHashAlgorithm {
36 SecureHashAlgorithm() { Init(); }
38 static const int kDigestSizeBytes;
41 void Update(const void* data, size_t nbytes);
44 // 20 bytes of message digest.
45 const unsigned char* Digest() const {
46 return reinterpret_cast<const unsigned char*>(H);
66 static inline uint32 f(uint32 t, uint32 B, uint32 C, uint32 D) {
68 return (B & C) | ((~B) & D);
72 return (B & C) | (B & D) | (C & D);
78 static inline uint32 S(uint32 n, uint32 X) {
79 return (X << n) | (X >> (32-n));
82 static inline uint32 K(uint32 t) {
94 static inline void swapends(uint32* t) {
95 *t = ((*t & 0xff000000) >> 24) |
96 ((*t & 0xff0000) >> 8) |
97 ((*t & 0xff00) << 8) |
101 const int SecureHashAlgorithm::kDigestSizeBytes = 20;
103 void SecureHashAlgorithm::Init() {
118 void SecureHashAlgorithm::Final() {
122 for (int t = 0; t < 5; ++t)
126 void SecureHashAlgorithm::Update(const void* data, size_t nbytes) {
127 const uint8* d = reinterpret_cast<const uint8*>(data);
136 void SecureHashAlgorithm::Pad() {
140 // pad out to next block
147 while (cursor < 64-4)
150 M[64-4] = (l & 0xff000000) >> 24;
151 M[64-3] = (l & 0xff0000) >> 16;
152 M[64-2] = (l & 0xff00) >> 8;
153 M[64-1] = (l & 0xff);
156 void SecureHashAlgorithm::Process() {
159 // Each a...e corresponds to a section in the FIPS 180-3 algorithm.
163 // W and M are in a union, so no need to memcpy.
164 // memcpy(W, M, sizeof(M));
165 for (t = 0; t < 16; ++t)
169 for (t = 16; t < 80; ++t)
170 W[t] = S(1, W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16]);
180 for (t = 0; t < 80; ++t) {
181 uint32 TEMP = S(5, A) + f(t, B, C, D) + E + W[t] + K(t);
199 std::string SHA1HashString(const std::string& str) {
200 char hash[SecureHashAlgorithm::kDigestSizeBytes];
201 SHA1HashBytes(reinterpret_cast<const unsigned char*>(str.c_str()),
202 str.length(), reinterpret_cast<unsigned char*>(hash));
203 return std::string(hash, SecureHashAlgorithm::kDigestSizeBytes);
206 void SHA1HashBytes(const unsigned char* data, size_t len,
207 unsigned char* hash) {
208 SecureHashAlgorithm sha;
209 sha.Update(data, len);
212 memcpy(hash, sha.Digest(), SecureHashAlgorithm::kDigestSizeBytes);