LLVM 20.0.0git
SHA1.h
Go to the documentation of this file.
1//==- SHA1.h - SHA1 implementation for LLVM --*- 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// This code is taken from public domain
9// (http://oauth.googlecode.com/svn/code/c/liboauth/src/sha1.c)
10// and modified by wrapping it in a C++ interface for LLVM,
11// and removing unnecessary code.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_SUPPORT_SHA1_H
16#define LLVM_SUPPORT_SHA1_H
17
18#include <array>
19#include <cstdint>
20
21namespace llvm {
22template <typename T> class ArrayRef;
23class StringRef;
24
25/// A class that wrap the SHA1 algorithm.
26class SHA1 {
27public:
28 SHA1() { init(); }
29
30 /// Reinitialize the internal state
31 void init();
32
33 /// Digest more data.
35
36 /// Digest more data.
37 void update(StringRef Str);
38
39 /// Return the current raw 160-bits SHA1 for the digested data
40 /// since the last call to init(). This call will add data to the internal
41 /// state and as such is not suited for getting an intermediate result
42 /// (see result()).
43 std::array<uint8_t, 20> final();
44
45 /// Return the current raw 160-bits SHA1 for the digested data
46 /// since the last call to init(). This is suitable for getting the SHA1 at
47 /// any time without invalidating the internal state so that more calls can be
48 /// made into update.
49 std::array<uint8_t, 20> result();
50
51 /// Returns a raw 160-bit SHA1 hash for the given data.
52 static std::array<uint8_t, 20> hash(ArrayRef<uint8_t> Data);
53
54private:
55 /// Define some constants.
56 /// "static constexpr" would be cleaner but MSVC does not support it yet.
57 enum { BLOCK_LENGTH = 64 };
58 enum { HASH_LENGTH = 20 };
59
60 // Internal State
61 struct {
62 union {
63 uint8_t C[BLOCK_LENGTH];
64 uint32_t L[BLOCK_LENGTH / 4];
66 uint32_t State[HASH_LENGTH / 4];
68 uint8_t BufferOffset;
69 } InternalState;
70
71 // Helper
72 void writebyte(uint8_t data);
73 void hashBlock();
74 void addUncounted(uint8_t data);
75 void pad();
76
77 void final(std::array<uint32_t, HASH_LENGTH / 4> &HashResult);
78};
79
80} // end llvm namespace
81
82#endif
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
A class that wrap the SHA1 algorithm.
Definition: SHA1.h:26
SHA1()
Definition: SHA1.h:28
void update(ArrayRef< uint8_t > Data)
Digest more data.
Definition: SHA1.cpp:208
uint8_t C[BLOCK_LENGTH]
Definition: SHA1.h:63
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
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
uint32_t ByteCount
Definition: SHA1.h:67
void init()
Reinitialize the internal state.
Definition: SHA1.cpp:81
uint32_t State[HASH_LENGTH/4]
Definition: SHA1.h:66
union llvm::SHA1::@416::@417 Buffer
uint32_t L[BLOCK_LENGTH/4]
Definition: SHA1.h:64
uint8_t BufferOffset
Definition: SHA1.h:68
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
ArrayRef(const T &OneElt) -> ArrayRef< T >