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. 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 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]; 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