LLVM  16.0.0git
SHA1.cpp
Go to the documentation of this file.
1 //====- SHA1.cpp - Private copy of the SHA1 implementation ---*- C++ -* ======//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This code is taken from public domain
10 // (http://oauth.googlecode.com/svn/code/c/liboauth/src/sha1.c and
11 // http://cvsweb.netbsd.org/bsdweb.cgi/src/common/lib/libc/hash/sha1/sha1.c?rev=1.6)
12 // and modified by wrapping it in a C++ interface for LLVM,
13 // and removing unnecessary code.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #include "llvm/Support/SHA1.h"
18 #include "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/Support/Endian.h"
22 #include <string.h>
23 
24 using namespace llvm;
25 
26 static inline uint32_t rol(uint32_t Number, int Bits) {
27  return (Number << Bits) | (Number >> (32 - Bits));
28 }
29 
30 static inline uint32_t blk0(uint32_t *Buf, int I) { return Buf[I]; }
31 
32 static inline uint32_t blk(uint32_t *Buf, int I) {
33  Buf[I & 15] = rol(Buf[(I + 13) & 15] ^ Buf[(I + 8) & 15] ^ Buf[(I + 2) & 15] ^
34  Buf[I & 15],
35  1);
36  return Buf[I & 15];
37 }
38 
39 static inline void r0(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D,
40  uint32_t &E, int I, uint32_t *Buf) {
41  E += ((B & (C ^ D)) ^ D) + blk0(Buf, I) + 0x5A827999 + rol(A, 5);
42  B = rol(B, 30);
43 }
44 
45 static inline void r1(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D,
46  uint32_t &E, int I, uint32_t *Buf) {
47  E += ((B & (C ^ D)) ^ D) + blk(Buf, I) + 0x5A827999 + rol(A, 5);
48  B = rol(B, 30);
49 }
50 
51 static inline void r2(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D,
52  uint32_t &E, int I, uint32_t *Buf) {
53  E += (B ^ C ^ D) + blk(Buf, I) + 0x6ED9EBA1 + rol(A, 5);
54  B = rol(B, 30);
55 }
56 
57 static inline void r3(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D,
58  uint32_t &E, int I, uint32_t *Buf) {
59  E += (((B | C) & D) | (B & C)) + blk(Buf, I) + 0x8F1BBCDC + rol(A, 5);
60  B = rol(B, 30);
61 }
62 
63 static inline void r4(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D,
64  uint32_t &E, int I, uint32_t *Buf) {
65  E += (B ^ C ^ D) + blk(Buf, I) + 0xCA62C1D6 + rol(A, 5);
66  B = rol(B, 30);
67 }
68 
69 /* code */
70 #define SHA1_K0 0x5a827999
71 #define SHA1_K20 0x6ed9eba1
72 #define SHA1_K40 0x8f1bbcdc
73 #define SHA1_K60 0xca62c1d6
74 
75 #define SEED_0 0x67452301
76 #define SEED_1 0xefcdab89
77 #define SEED_2 0x98badcfe
78 #define SEED_3 0x10325476
79 #define SEED_4 0xc3d2e1f0
80 
81 void SHA1::init() {
82  InternalState.State[0] = SEED_0;
83  InternalState.State[1] = SEED_1;
84  InternalState.State[2] = SEED_2;
85  InternalState.State[3] = SEED_3;
86  InternalState.State[4] = SEED_4;
87  InternalState.ByteCount = 0;
88  InternalState.BufferOffset = 0;
89 }
90 
91 void SHA1::hashBlock() {
92  uint32_t A = InternalState.State[0];
93  uint32_t B = InternalState.State[1];
94  uint32_t C = InternalState.State[2];
95  uint32_t D = InternalState.State[3];
96  uint32_t E = InternalState.State[4];
97 
98  // 4 rounds of 20 operations each. Loop unrolled.
99  r0(A, B, C, D, E, 0, InternalState.Buffer.L);
100  r0(E, A, B, C, D, 1, InternalState.Buffer.L);
101  r0(D, E, A, B, C, 2, InternalState.Buffer.L);
102  r0(C, D, E, A, B, 3, InternalState.Buffer.L);
103  r0(B, C, D, E, A, 4, InternalState.Buffer.L);
104  r0(A, B, C, D, E, 5, InternalState.Buffer.L);
105  r0(E, A, B, C, D, 6, InternalState.Buffer.L);
106  r0(D, E, A, B, C, 7, InternalState.Buffer.L);
107  r0(C, D, E, A, B, 8, InternalState.Buffer.L);
108  r0(B, C, D, E, A, 9, InternalState.Buffer.L);
109  r0(A, B, C, D, E, 10, InternalState.Buffer.L);
110  r0(E, A, B, C, D, 11, InternalState.Buffer.L);
111  r0(D, E, A, B, C, 12, InternalState.Buffer.L);
112  r0(C, D, E, A, B, 13, InternalState.Buffer.L);
113  r0(B, C, D, E, A, 14, InternalState.Buffer.L);
114  r0(A, B, C, D, E, 15, InternalState.Buffer.L);
115  r1(E, A, B, C, D, 16, InternalState.Buffer.L);
116  r1(D, E, A, B, C, 17, InternalState.Buffer.L);
117  r1(C, D, E, A, B, 18, InternalState.Buffer.L);
118  r1(B, C, D, E, A, 19, InternalState.Buffer.L);
119 
120  r2(A, B, C, D, E, 20, InternalState.Buffer.L);
121  r2(E, A, B, C, D, 21, InternalState.Buffer.L);
122  r2(D, E, A, B, C, 22, InternalState.Buffer.L);
123  r2(C, D, E, A, B, 23, InternalState.Buffer.L);
124  r2(B, C, D, E, A, 24, InternalState.Buffer.L);
125  r2(A, B, C, D, E, 25, InternalState.Buffer.L);
126  r2(E, A, B, C, D, 26, InternalState.Buffer.L);
127  r2(D, E, A, B, C, 27, InternalState.Buffer.L);
128  r2(C, D, E, A, B, 28, InternalState.Buffer.L);
129  r2(B, C, D, E, A, 29, InternalState.Buffer.L);
130  r2(A, B, C, D, E, 30, InternalState.Buffer.L);
131  r2(E, A, B, C, D, 31, InternalState.Buffer.L);
132  r2(D, E, A, B, C, 32, InternalState.Buffer.L);
133  r2(C, D, E, A, B, 33, InternalState.Buffer.L);
134  r2(B, C, D, E, A, 34, InternalState.Buffer.L);
135  r2(A, B, C, D, E, 35, InternalState.Buffer.L);
136  r2(E, A, B, C, D, 36, InternalState.Buffer.L);
137  r2(D, E, A, B, C, 37, InternalState.Buffer.L);
138  r2(C, D, E, A, B, 38, InternalState.Buffer.L);
139  r2(B, C, D, E, A, 39, InternalState.Buffer.L);
140 
141  r3(A, B, C, D, E, 40, InternalState.Buffer.L);
142  r3(E, A, B, C, D, 41, InternalState.Buffer.L);
143  r3(D, E, A, B, C, 42, InternalState.Buffer.L);
144  r3(C, D, E, A, B, 43, InternalState.Buffer.L);
145  r3(B, C, D, E, A, 44, InternalState.Buffer.L);
146  r3(A, B, C, D, E, 45, InternalState.Buffer.L);
147  r3(E, A, B, C, D, 46, InternalState.Buffer.L);
148  r3(D, E, A, B, C, 47, InternalState.Buffer.L);
149  r3(C, D, E, A, B, 48, InternalState.Buffer.L);
150  r3(B, C, D, E, A, 49, InternalState.Buffer.L);
151  r3(A, B, C, D, E, 50, InternalState.Buffer.L);
152  r3(E, A, B, C, D, 51, InternalState.Buffer.L);
153  r3(D, E, A, B, C, 52, InternalState.Buffer.L);
154  r3(C, D, E, A, B, 53, InternalState.Buffer.L);
155  r3(B, C, D, E, A, 54, InternalState.Buffer.L);
156  r3(A, B, C, D, E, 55, InternalState.Buffer.L);
157  r3(E, A, B, C, D, 56, InternalState.Buffer.L);
158  r3(D, E, A, B, C, 57, InternalState.Buffer.L);
159  r3(C, D, E, A, B, 58, InternalState.Buffer.L);
160  r3(B, C, D, E, A, 59, InternalState.Buffer.L);
161 
162  r4(A, B, C, D, E, 60, InternalState.Buffer.L);
163  r4(E, A, B, C, D, 61, InternalState.Buffer.L);
164  r4(D, E, A, B, C, 62, InternalState.Buffer.L);
165  r4(C, D, E, A, B, 63, InternalState.Buffer.L);
166  r4(B, C, D, E, A, 64, InternalState.Buffer.L);
167  r4(A, B, C, D, E, 65, InternalState.Buffer.L);
168  r4(E, A, B, C, D, 66, InternalState.Buffer.L);
169  r4(D, E, A, B, C, 67, InternalState.Buffer.L);
170  r4(C, D, E, A, B, 68, InternalState.Buffer.L);
171  r4(B, C, D, E, A, 69, InternalState.Buffer.L);
172  r4(A, B, C, D, E, 70, InternalState.Buffer.L);
173  r4(E, A, B, C, D, 71, InternalState.Buffer.L);
174  r4(D, E, A, B, C, 72, InternalState.Buffer.L);
175  r4(C, D, E, A, B, 73, InternalState.Buffer.L);
176  r4(B, C, D, E, A, 74, InternalState.Buffer.L);
177  r4(A, B, C, D, E, 75, InternalState.Buffer.L);
178  r4(E, A, B, C, D, 76, InternalState.Buffer.L);
179  r4(D, E, A, B, C, 77, InternalState.Buffer.L);
180  r4(C, D, E, A, B, 78, InternalState.Buffer.L);
181  r4(B, C, D, E, A, 79, InternalState.Buffer.L);
182 
183  InternalState.State[0] += A;
184  InternalState.State[1] += B;
185  InternalState.State[2] += C;
186  InternalState.State[3] += D;
187  InternalState.State[4] += E;
188 }
189 
190 void SHA1::addUncounted(uint8_t Data) {
191  if constexpr (sys::IsBigEndianHost)
192  InternalState.Buffer.C[InternalState.BufferOffset] = Data;
193  else
194  InternalState.Buffer.C[InternalState.BufferOffset ^ 3] = Data;
195 
196  InternalState.BufferOffset++;
197  if (InternalState.BufferOffset == BLOCK_LENGTH) {
198  hashBlock();
199  InternalState.BufferOffset = 0;
200  }
201 }
202 
203 void SHA1::writebyte(uint8_t Data) {
204  ++InternalState.ByteCount;
205  addUncounted(Data);
206 }
207 
209  InternalState.ByteCount += Data.size();
210 
211  // Finish the current block.
212  if (InternalState.BufferOffset > 0) {
213  const size_t Remainder = std::min<size_t>(
214  Data.size(), BLOCK_LENGTH - InternalState.BufferOffset);
215  for (size_t I = 0; I < Remainder; ++I)
216  addUncounted(Data[I]);
217  Data = Data.drop_front(Remainder);
218  }
219 
220  // Fast buffer filling for large inputs.
221  while (Data.size() >= BLOCK_LENGTH) {
222  assert(InternalState.BufferOffset == 0);
223  static_assert(BLOCK_LENGTH % 4 == 0);
224  constexpr size_t BLOCK_LENGTH_32 = BLOCK_LENGTH / 4;
225  for (size_t I = 0; I < BLOCK_LENGTH_32; ++I)
226  InternalState.Buffer.L[I] = support::endian::read32be(&Data[I * 4]);
227  hashBlock();
228  Data = Data.drop_front(BLOCK_LENGTH);
229  }
230 
231  // Finish the remainder.
232  for (uint8_t C : Data)
233  addUncounted(C);
234 }
235 
237  update(
238  ArrayRef<uint8_t>((uint8_t *)const_cast<char *>(Str.data()), Str.size()));
239 }
240 
241 void SHA1::pad() {
242  // Implement SHA-1 padding (fips180-2 5.1.1)
243 
244  // Pad with 0x80 followed by 0x00 until the end of the block
245  addUncounted(0x80);
246  while (InternalState.BufferOffset != 56)
247  addUncounted(0x00);
248 
249  // Append length in the last 8 bytes
250  addUncounted(0); // We're only using 32 bit lengths
251  addUncounted(0); // But SHA-1 supports 64 bit lengths
252  addUncounted(0); // So zero pad the top bits
253  addUncounted(InternalState.ByteCount >> 29); // Shifting to multiply by 8
254  addUncounted(InternalState.ByteCount >>
255  21); // as SHA-1 supports bitstreams as well as
256  addUncounted(InternalState.ByteCount >> 13); // byte.
257  addUncounted(InternalState.ByteCount >> 5);
258  addUncounted(InternalState.ByteCount << 3);
259 }
260 
261 void SHA1::final(std::array<uint32_t, HASH_LENGTH / 4> &HashResult) {
262  // Pad to complete the last block
263  pad();
264 
265  if constexpr (sys::IsBigEndianHost) {
266  // Just copy the current state
267  for (int i = 0; i < 5; i++) {
268  HashResult[i] = InternalState.State[i];
269  }
270  } else {
271  // Swap byte order back
272  for (int i = 0; i < 5; i++) {
273  HashResult[i] = sys::getSwappedBytes(InternalState.State[i]);
274  }
275  }
276 }
277 
278 std::array<uint8_t, 20> SHA1::final() {
279  union {
280  std::array<uint32_t, HASH_LENGTH / 4> HashResult;
281  std::array<uint8_t, HASH_LENGTH> ReturnResult;
282  };
283  static_assert(sizeof(HashResult) == sizeof(ReturnResult));
284  final(HashResult);
285  return ReturnResult;
286 }
287 
288 std::array<uint8_t, 20> SHA1::result() {
289  auto StateToRestore = InternalState;
290 
291  auto Hash = final();
292 
293  // Restore the state
294  InternalState = StateToRestore;
295 
296  // Return pointer to hash (20 characters)
297  return Hash;
298 }
299 
300 std::array<uint8_t, 20> SHA1::hash(ArrayRef<uint8_t> Data) {
301  SHA1 Hash;
302  Hash.update(Data);
303  return Hash.final();
304 }
SEED_4
#define SEED_4
Definition: SHA1.cpp:79
i
i
Definition: README.txt:29
r1
static void r1(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E, int I, uint32_t *Buf)
Definition: SHA1.cpp:45
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::sys::IsBigEndianHost
constexpr bool IsBigEndianHost
Definition: SwapByteOrder.h:98
r4
static void r4(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E, int I, uint32_t *Buf)
Definition: SHA1.cpp:63
StringRef.h
SEED_0
#define SEED_0
Definition: SHA1.cpp:75
SwapByteOrder.h
llvm::tgtok::Bits
@ Bits
Definition: TGLexer.h:50
llvm::support::endian::read32be
uint32_t read32be(const void *P)
Definition: Endian.h:384
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::SHA1
A class that wrap the SHA1 algorithm.
Definition: SHA1.h:26
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
SEED_3
#define SEED_3
Definition: SHA1.cpp:78
llvm::SHA1::C
uint8_t C[BLOCK_LENGTH]
Definition: SHA1.h:63
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::SHA1::result
std::array< uint8_t, 20 > result()
Return the current raw 160-bits SHA1 for the digested data since the last call to init().
Definition: SHA1.cpp:288
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
r0
static void r0(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E, int I, uint32_t *Buf)
Definition: SHA1.cpp:39
llvm::SHA1::hash
static std::array< uint8_t, 20 > hash(ArrayRef< uint8_t > Data)
Returns a raw 160-bit SHA1 hash for the given data.
Definition: SHA1.cpp:300
SEED_1
#define SEED_1
Definition: SHA1.cpp:76
SEED_2
#define SEED_2
Definition: SHA1.cpp:77
llvm::sys::getSwappedBytes
unsigned char getSwappedBytes(unsigned char C)
Definition: SwapByteOrder.h:103
r3
static void r3(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E, int I, uint32_t *Buf)
Definition: SHA1.cpp:57
blk
static uint32_t blk(uint32_t *Buf, int I)
Definition: SHA1.cpp:32
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
I
#define I(x, y, z)
Definition: MD5.cpp:58
ArrayRef.h
llvm::SHA1::final
std::array< uint8_t, 20 > final()
Return the current raw 160-bits SHA1 for the digested data since the last call to init().
Definition: SHA1.cpp:278
r2
static void r2(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E, int I, uint32_t *Buf)
Definition: SHA1.cpp:51
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::SHA1::init
void init()
Reinitialize the internal state.
Definition: SHA1.cpp:81
blk0
static uint32_t blk0(uint32_t *Buf, int I)
Definition: SHA1.cpp:30
llvm::SHA1::update
void update(ArrayRef< uint8_t > Data)
Digest more data.
Definition: SHA1.cpp:208
llvm::ArrayRef< uint8_t >
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Number
uint32_t Number
Definition: Profile.cpp:47
uint32_t
SHA1.h
Endian.h
rol
static uint32_t rol(uint32_t Number, int Bits)
Definition: SHA1.cpp:26