Line data Source code
1 : //====- SHA1.cpp - Private copy of the SHA1 implementation ---*- C++ -* ======//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 : //
10 : // This code is taken from public domain
11 : // (http://oauth.googlecode.com/svn/code/c/liboauth/src/sha1.c and
12 : // http://cvsweb.netbsd.org/bsdweb.cgi/src/common/lib/libc/hash/sha1/sha1.c?rev=1.6)
13 : // and modified by wrapping it in a C++ interface for LLVM,
14 : // and removing unnecessary code.
15 : //
16 : //===----------------------------------------------------------------------===//
17 :
18 : #include "llvm/Support/SHA1.h"
19 : #include "llvm/ADT/ArrayRef.h"
20 : #include "llvm/Support/Host.h"
21 : using namespace llvm;
22 :
23 : #include <stdint.h>
24 : #include <string.h>
25 :
26 : #if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
27 : #define SHA_BIG_ENDIAN
28 : #endif
29 :
30 : static uint32_t rol(uint32_t Number, int Bits) {
31 281413440 : return (Number << Bits) | (Number >> (32 - Bits));
32 : }
33 :
34 25583040 : static uint32_t blk0(uint32_t *Buf, int I) { return Buf[I]; }
35 :
36 102332160 : static uint32_t blk(uint32_t *Buf, int I) {
37 306996480 : Buf[I & 15] = rol(Buf[(I + 13) & 15] ^ Buf[(I + 8) & 15] ^ Buf[(I + 2) & 15] ^
38 102332160 : Buf[I & 15],
39 : 1);
40 102332160 : return Buf[I & 15];
41 : }
42 :
43 0 : static void r0(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E,
44 : int I, uint32_t *Buf) {
45 76749120 : E += ((B & (C ^ D)) ^ D) + blk0(Buf, I) + 0x5A827999 + rol(A, 5);
46 4796820 : B = rol(B, 30);
47 0 : }
48 :
49 0 : static void r1(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E,
50 : int I, uint32_t *Buf) {
51 0 : E += ((B & (C ^ D)) ^ D) + blk(Buf, I) + 0x5A827999 + rol(A, 5);
52 0 : B = rol(B, 30);
53 0 : }
54 :
55 0 : static void r2(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E,
56 : int I, uint32_t *Buf) {
57 0 : E += (B ^ C ^ D) + blk(Buf, I) + 0x6ED9EBA1 + rol(A, 5);
58 63957600 : B = rol(B, 30);
59 0 : }
60 :
61 0 : static void r3(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E,
62 : int I, uint32_t *Buf) {
63 0 : E += (((B | C) & D) | (B & C)) + blk(Buf, I) + 0x8F1BBCDC + rol(A, 5);
64 0 : B = rol(B, 30);
65 0 : }
66 :
67 0 : static void r4(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E,
68 : int I, uint32_t *Buf) {
69 0 : E += (B ^ C ^ D) + blk(Buf, I) + 0xCA62C1D6 + rol(A, 5);
70 62358660 : B = rol(B, 30);
71 0 : }
72 :
73 : /* code */
74 : #define SHA1_K0 0x5a827999
75 : #define SHA1_K20 0x6ed9eba1
76 : #define SHA1_K40 0x8f1bbcdc
77 : #define SHA1_K60 0xca62c1d6
78 :
79 : #define SEED_0 0x67452301
80 : #define SEED_1 0xefcdab89
81 : #define SEED_2 0x98badcfe
82 : #define SEED_3 0x10325476
83 : #define SEED_4 0xc3d2e1f0
84 :
85 10112 : void SHA1::init() {
86 10112 : InternalState.State[0] = SEED_0;
87 10112 : InternalState.State[1] = SEED_1;
88 10112 : InternalState.State[2] = SEED_2;
89 10112 : InternalState.State[3] = SEED_3;
90 10112 : InternalState.State[4] = SEED_4;
91 10112 : InternalState.ByteCount = 0;
92 10112 : InternalState.BufferOffset = 0;
93 10112 : }
94 :
95 1598940 : void SHA1::hashBlock() {
96 1598940 : uint32_t A = InternalState.State[0];
97 1598940 : uint32_t B = InternalState.State[1];
98 1598940 : uint32_t C = InternalState.State[2];
99 1598940 : uint32_t D = InternalState.State[3];
100 1598940 : uint32_t E = InternalState.State[4];
101 :
102 : // 4 rounds of 20 operations each. Loop unrolled.
103 : r0(A, B, C, D, E, 0, InternalState.Buffer.L);
104 : r0(E, A, B, C, D, 1, InternalState.Buffer.L);
105 : r0(D, E, A, B, C, 2, InternalState.Buffer.L);
106 : r0(C, D, E, A, B, 3, InternalState.Buffer.L);
107 : r0(B, C, D, E, A, 4, InternalState.Buffer.L);
108 : r0(A, B, C, D, E, 5, InternalState.Buffer.L);
109 : r0(E, A, B, C, D, 6, InternalState.Buffer.L);
110 : r0(D, E, A, B, C, 7, InternalState.Buffer.L);
111 : r0(C, D, E, A, B, 8, InternalState.Buffer.L);
112 : r0(B, C, D, E, A, 9, InternalState.Buffer.L);
113 : r0(A, B, C, D, E, 10, InternalState.Buffer.L);
114 : r0(E, A, B, C, D, 11, InternalState.Buffer.L);
115 : r0(D, E, A, B, C, 12, InternalState.Buffer.L);
116 : r0(C, D, E, A, B, 13, InternalState.Buffer.L);
117 : r0(B, C, D, E, A, 14, InternalState.Buffer.L);
118 : r0(A, B, C, D, E, 15, InternalState.Buffer.L);
119 1598940 : r1(E, A, B, C, D, 16, InternalState.Buffer.L);
120 1598940 : r1(D, E, A, B, C, 17, InternalState.Buffer.L);
121 1598940 : r1(C, D, E, A, B, 18, InternalState.Buffer.L);
122 1598940 : r1(B, C, D, E, A, 19, InternalState.Buffer.L);
123 :
124 1598940 : r2(A, B, C, D, E, 20, InternalState.Buffer.L);
125 1598940 : r2(E, A, B, C, D, 21, InternalState.Buffer.L);
126 1598940 : r2(D, E, A, B, C, 22, InternalState.Buffer.L);
127 1598940 : r2(C, D, E, A, B, 23, InternalState.Buffer.L);
128 1598940 : r2(B, C, D, E, A, 24, InternalState.Buffer.L);
129 1598940 : r2(A, B, C, D, E, 25, InternalState.Buffer.L);
130 1598940 : r2(E, A, B, C, D, 26, InternalState.Buffer.L);
131 1598940 : r2(D, E, A, B, C, 27, InternalState.Buffer.L);
132 1598940 : r2(C, D, E, A, B, 28, InternalState.Buffer.L);
133 1598940 : r2(B, C, D, E, A, 29, InternalState.Buffer.L);
134 1598940 : r2(A, B, C, D, E, 30, InternalState.Buffer.L);
135 1598940 : r2(E, A, B, C, D, 31, InternalState.Buffer.L);
136 1598940 : r2(D, E, A, B, C, 32, InternalState.Buffer.L);
137 1598940 : r2(C, D, E, A, B, 33, InternalState.Buffer.L);
138 1598940 : r2(B, C, D, E, A, 34, InternalState.Buffer.L);
139 1598940 : r2(A, B, C, D, E, 35, InternalState.Buffer.L);
140 1598940 : r2(E, A, B, C, D, 36, InternalState.Buffer.L);
141 1598940 : r2(D, E, A, B, C, 37, InternalState.Buffer.L);
142 1598940 : r2(C, D, E, A, B, 38, InternalState.Buffer.L);
143 1598940 : r2(B, C, D, E, A, 39, InternalState.Buffer.L);
144 :
145 1598940 : r3(A, B, C, D, E, 40, InternalState.Buffer.L);
146 1598940 : r3(E, A, B, C, D, 41, InternalState.Buffer.L);
147 1598940 : r3(D, E, A, B, C, 42, InternalState.Buffer.L);
148 1598940 : r3(C, D, E, A, B, 43, InternalState.Buffer.L);
149 1598940 : r3(B, C, D, E, A, 44, InternalState.Buffer.L);
150 1598940 : r3(A, B, C, D, E, 45, InternalState.Buffer.L);
151 1598940 : r3(E, A, B, C, D, 46, InternalState.Buffer.L);
152 1598940 : r3(D, E, A, B, C, 47, InternalState.Buffer.L);
153 1598940 : r3(C, D, E, A, B, 48, InternalState.Buffer.L);
154 1598940 : r3(B, C, D, E, A, 49, InternalState.Buffer.L);
155 1598940 : r3(A, B, C, D, E, 50, InternalState.Buffer.L);
156 1598940 : r3(E, A, B, C, D, 51, InternalState.Buffer.L);
157 1598940 : r3(D, E, A, B, C, 52, InternalState.Buffer.L);
158 1598940 : r3(C, D, E, A, B, 53, InternalState.Buffer.L);
159 1598940 : r3(B, C, D, E, A, 54, InternalState.Buffer.L);
160 1598940 : r3(A, B, C, D, E, 55, InternalState.Buffer.L);
161 1598940 : r3(E, A, B, C, D, 56, InternalState.Buffer.L);
162 1598940 : r3(D, E, A, B, C, 57, InternalState.Buffer.L);
163 1598940 : r3(C, D, E, A, B, 58, InternalState.Buffer.L);
164 1598940 : r3(B, C, D, E, A, 59, InternalState.Buffer.L);
165 :
166 1598940 : r4(A, B, C, D, E, 60, InternalState.Buffer.L);
167 1598940 : r4(E, A, B, C, D, 61, InternalState.Buffer.L);
168 1598940 : r4(D, E, A, B, C, 62, InternalState.Buffer.L);
169 1598940 : r4(C, D, E, A, B, 63, InternalState.Buffer.L);
170 1598940 : r4(B, C, D, E, A, 64, InternalState.Buffer.L);
171 1598940 : r4(A, B, C, D, E, 65, InternalState.Buffer.L);
172 1598940 : r4(E, A, B, C, D, 66, InternalState.Buffer.L);
173 1598940 : r4(D, E, A, B, C, 67, InternalState.Buffer.L);
174 1598940 : r4(C, D, E, A, B, 68, InternalState.Buffer.L);
175 1598940 : r4(B, C, D, E, A, 69, InternalState.Buffer.L);
176 1598940 : r4(A, B, C, D, E, 70, InternalState.Buffer.L);
177 1598940 : r4(E, A, B, C, D, 71, InternalState.Buffer.L);
178 1598940 : r4(D, E, A, B, C, 72, InternalState.Buffer.L);
179 1598940 : r4(C, D, E, A, B, 73, InternalState.Buffer.L);
180 1598940 : r4(B, C, D, E, A, 74, InternalState.Buffer.L);
181 1598940 : r4(A, B, C, D, E, 75, InternalState.Buffer.L);
182 1598940 : r4(E, A, B, C, D, 76, InternalState.Buffer.L);
183 1598940 : r4(D, E, A, B, C, 77, InternalState.Buffer.L);
184 1598940 : r4(C, D, E, A, B, 78, InternalState.Buffer.L);
185 1598940 : r4(B, C, D, E, A, 79, InternalState.Buffer.L);
186 :
187 1598940 : InternalState.State[0] += A;
188 1598940 : InternalState.State[1] += B;
189 1598940 : InternalState.State[2] += C;
190 1598940 : InternalState.State[3] += D;
191 1598940 : InternalState.State[4] += E;
192 1598940 : }
193 :
194 102332155 : void SHA1::addUncounted(uint8_t Data) {
195 : #ifdef SHA_BIG_ENDIAN
196 : InternalState.Buffer.C[InternalState.BufferOffset] = Data;
197 : #else
198 102332155 : InternalState.Buffer.C[InternalState.BufferOffset ^ 3] = Data;
199 : #endif
200 :
201 102332155 : InternalState.BufferOffset++;
202 102332155 : if (InternalState.BufferOffset == BLOCK_LENGTH) {
203 1598940 : hashBlock();
204 1598940 : InternalState.BufferOffset = 0;
205 : }
206 102332155 : }
207 :
208 102183987 : void SHA1::writebyte(uint8_t Data) {
209 102183987 : ++InternalState.ByteCount;
210 102183987 : addUncounted(Data);
211 102183987 : }
212 :
213 14882 : void SHA1::update(ArrayRef<uint8_t> Data) {
214 102198869 : for (auto &C : Data)
215 102183987 : writebyte(C);
216 14882 : }
217 :
218 3519 : void SHA1::pad() {
219 : // Implement SHA-1 padding (fips180-2 5.1.1)
220 :
221 : // Pad with 0x80 followed by 0x00 until the end of the block
222 3519 : addUncounted(0x80);
223 120016 : while (InternalState.BufferOffset != 56)
224 116497 : addUncounted(0x00);
225 :
226 : // Append length in the last 8 bytes
227 3519 : addUncounted(0); // We're only using 32 bit lengths
228 3519 : addUncounted(0); // But SHA-1 supports 64 bit lengths
229 3519 : addUncounted(0); // So zero pad the top bits
230 3519 : addUncounted(InternalState.ByteCount >> 29); // Shifting to multiply by 8
231 3519 : addUncounted(InternalState.ByteCount >>
232 : 21); // as SHA-1 supports bitstreams as well as
233 3519 : addUncounted(InternalState.ByteCount >> 13); // byte.
234 3519 : addUncounted(InternalState.ByteCount >> 5);
235 3519 : addUncounted(InternalState.ByteCount << 3);
236 3519 : }
237 :
238 3519 : StringRef SHA1::final() {
239 : // Pad to complete the last block
240 3519 : pad();
241 :
242 : #ifdef SHA_BIG_ENDIAN
243 : // Just copy the current state
244 : for (int i = 0; i < 5; i++) {
245 : HashResult[i] = InternalState.State[i];
246 : }
247 : #else
248 : // Swap byte order back
249 21114 : for (int i = 0; i < 5; i++) {
250 52785 : HashResult[i] = (((InternalState.State[i]) << 24) & 0xff000000) |
251 35190 : (((InternalState.State[i]) << 8) & 0x00ff0000) |
252 35190 : (((InternalState.State[i]) >> 8) & 0x0000ff00) |
253 17595 : (((InternalState.State[i]) >> 24) & 0x000000ff);
254 : }
255 : #endif
256 :
257 : // Return pointer to hash (20 characters)
258 3519 : return StringRef((char *)HashResult, HASH_LENGTH);
259 : }
260 :
261 1397 : StringRef SHA1::result() {
262 1397 : auto StateToRestore = InternalState;
263 :
264 1397 : auto Hash = final();
265 :
266 : // Restore the state
267 1397 : InternalState = StateToRestore;
268 :
269 : // Return pointer to hash (20 characters)
270 1397 : return Hash;
271 : }
272 :
273 129 : std::array<uint8_t, 20> SHA1::hash(ArrayRef<uint8_t> Data) {
274 : SHA1 Hash;
275 129 : Hash.update(Data);
276 129 : StringRef S = Hash.final();
277 :
278 : std::array<uint8_t, 20> Arr;
279 129 : memcpy(Arr.data(), S.data(), S.size());
280 129 : return Arr;
281 : }
|
