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 21 namespace llvm { 22 template <typename T> class ArrayRef; 23 class StringRef; 24 25 /// A class that wrap the SHA1 algorithm. 26 class SHA1 { 27 public: SHA1()28 SHA1() { init(); } 29 30 /// Reinitialize the internal state 31 void init(); 32 33 /// Digest more data. 34 void update(ArrayRef<uint8_t> 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 54 private: 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]; 65 } Buffer; 66 uint32_t State[HASH_LENGTH / 4]; 67 uint32_t ByteCount; 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 83