LLVM  10.0.0svn
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 "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/StringRef.h"
20 
21 #include <array>
22 #include <cstdint>
23 
24 namespace llvm {
25 template <typename T> class ArrayRef;
26 
27 /// A class that wrap the SHA1 algorithm.
28 class SHA1 {
29 public:
30  SHA1() { init(); }
31 
32  /// Reinitialize the internal state
33  void init();
34 
35  /// Digest more data.
37 
38  /// Digest more data.
39  void update(StringRef Str) {
40  update(ArrayRef<uint8_t>((uint8_t *)const_cast<char *>(Str.data()),
41  Str.size()));
42  }
43 
44  /// Return a reference to the current raw 160-bits SHA1 for the digested data
45  /// since the last call to init(). This call will add data to the internal
46  /// state and as such is not suited for getting an intermediate result
47  /// (see result()).
48  StringRef final();
49 
50  /// Return a reference to the current raw 160-bits SHA1 for the digested data
51  /// since the last call to init(). This is suitable for getting the SHA1 at
52  /// any time without invalidating the internal state so that more calls can be
53  /// made into update.
54  StringRef result();
55 
56  /// Returns a raw 160-bit SHA1 hash for the given data.
57  static std::array<uint8_t, 20> hash(ArrayRef<uint8_t> Data);
58 
59 private:
60  /// Define some constants.
61  /// "static constexpr" would be cleaner but MSVC does not support it yet.
62  enum { BLOCK_LENGTH = 64 };
63  enum { HASH_LENGTH = 20 };
64 
65  // Internal State
66  struct {
67  union {
68  uint8_t C[BLOCK_LENGTH];
69  uint32_t L[BLOCK_LENGTH / 4];
70  } Buffer;
71  uint32_t State[HASH_LENGTH / 4];
73  uint8_t BufferOffset;
74  } InternalState;
75 
76  // Internal copy of the hash, populated and accessed on calls to result()
77  uint32_t HashResult[HASH_LENGTH / 4];
78 
79  // Helper
80  void writebyte(uint8_t data);
81  void hashBlock();
82  void addUncounted(uint8_t data);
83  void pad();
84 };
85 
86 } // end llvm namespace
87 
88 #endif
This class represents lattice values for constants.
Definition: AllocatorList.h:23
uint8_t BufferOffset
Definition: SHA1.h:73
SHA1()
Definition: SHA1.h:30
A class that wrap the SHA1 algorithm.
Definition: SHA1.h:28
void init()
Reinitialize the internal state.
Definition: SHA1.cpp:84
void update(StringRef Str)
Digest more data.
Definition: SHA1.h:39
uint32_t State[HASH_LENGTH/4]
Definition: SHA1.h:71
StringRef result()
Return a reference to the current raw 160-bits SHA1 for the digested data since the last call to init...
Definition: SHA1.cpp:260
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:144
void update(ArrayRef< uint8_t > Data)
Digest more data.
Definition: SHA1.cpp:212
union llvm::SHA1::@339::@340 Buffer
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:272
uint32_t L[BLOCK_LENGTH/4]
Definition: SHA1.h:69
uint32_t ByteCount
Definition: SHA1.h:72
uint8_t C[BLOCK_LENGTH]
Definition: SHA1.h:68
LLVM_NODISCARD const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:136
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48