Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  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:
  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.