Line data    Source code

       1             : //==- SHA1.h - SHA1 implementation for LLVM                     --*- C++ -*-==//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : // This code is taken from public domain
      10             : // (http://oauth.googlecode.com/svn/code/c/liboauth/src/sha1.c)
      11             : // and modified by wrapping it in a C++ interface for LLVM,
      12             : // and removing unnecessary code.
      13             : //
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_SUPPORT_SHA1_H
      17             : #define LLVM_SUPPORT_SHA1_H
      18             : 
      19             : #include "llvm/ADT/ArrayRef.h"
      20             : 
      21             : #include <array>
      22             : #include <cstdint>
      23             : 
      24             : namespace llvm {
      25             : template <typename T> class ArrayRef;
      26             : class StringRef;
      27             : 
      28             : /// A class that wrap the SHA1 algorithm.
      29             : class SHA1 {
      30             : public:
      31        8131 :   SHA1() { init(); }
      32             : 
      33             :   /// Reinitialize the internal state
      34             :   void init();
      35             : 
      36             :   /// Digest more data.
      37             :   void update(ArrayRef<uint8_t> Data);
      38             : 
      39             :   /// Digest more data.
      40             :   void update(StringRef Str) {
      41         411 :     update(ArrayRef<uint8_t>((uint8_t *)const_cast<char *>(Str.data()),
      42             :                              Str.size()));
      43             :   }
      44             : 
      45             :   /// Return a reference to the current raw 160-bits SHA1 for the digested data
      46             :   /// since the last call to init(). This call will add data to the internal
      47             :   /// state and as such is not suited for getting an intermediate result
      48             :   /// (see result()).
      49             :   StringRef final();
      50             : 
      51             :   /// Return a reference to the current raw 160-bits SHA1 for the digested data
      52             :   /// since the last call to init(). This is suitable for getting the SHA1 at
      53             :   /// any time without invalidating the internal state so that more calls can be
      54             :   /// made into update.
      55             :   StringRef result();
      56             : 
      57             :   /// Returns a raw 160-bit SHA1 hash for the given data.
      58             :   static std::array<uint8_t, 20> hash(ArrayRef<uint8_t> Data);
      59             : 
      60             : private:
      61             :   /// Define some constants.
      62             :   /// "static constexpr" would be cleaner but MSVC does not support it yet.
      63             :   enum { BLOCK_LENGTH = 64 };
      64             :   enum { HASH_LENGTH = 20 };
      65             : 
      66             :   // Internal State
      67             :   struct {
      68             :     union {
      69             :       uint8_t C[BLOCK_LENGTH];
      70             :       uint32_t L[BLOCK_LENGTH / 4];
      71             :     } Buffer;
      72             :     uint32_t State[HASH_LENGTH / 4];
      73             :     uint32_t ByteCount;
      74             :     uint8_t BufferOffset;
      75             :   } InternalState;
      76             : 
      77             :   // Internal copy of the hash, populated and accessed on calls to result()
      78             :   uint32_t HashResult[HASH_LENGTH / 4];
      79             : 
      80             :   // Helper
      81             :   void writebyte(uint8_t data);
      82             :   void hashBlock();
      83             :   void addUncounted(uint8_t data);
      84             :   void pad();
      85             : };
      86             : 
      87             : } // end llvm namespace
      88             : 
      89             : #endif