kc3-lang/angle/src/common/base/anglebase/sha1.cc

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Scott Violet
  Date : 2023-04-17 10:08:18
  Hash : 65f4d2a4
  Message : Adds features to enable loading/saving metallibs to blobcache CompileMetalShaders results in the appropriate command line tool being run to generate metallib blobs from shader source. DisableProgramCaching results in not saving programs to BlobCache LoadMetalShadersFromBlobCache results in trying to load metallibs from BlobCache. Bug: chromium:1423136 Change-Id: I01a4d7a5d60ed5ac978fb99db01b741e0f19e76b Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4434293 Reviewed-by: Geoff Lang <geofflang@chromium.org> Commit-Queue: Scott Violet <sky@chromium.org>

• src/common/base/anglebase/sha1.cc

• // Copyright (c) 2011 The Chromium Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  
  #include "anglebase/sha1.h"
  
  #include <stddef.h>
  #include <stdint.h>
  #include <string.h>
  
  #include "anglebase/sys_byteorder.h"
  
  namespace angle
  {
  
  namespace base
  {
  
  static inline uint32_t f(uint32_t t, uint32_t B, uint32_t C, uint32_t D)
  {
      if (t < 20)
      {
          return (B & C) | ((~B) & D);
      }
      else if (t < 40)
      {
          return B ^ C ^ D;
      }
      else if (t < 60)
      {
          return (B & C) | (B & D) | (C & D);
      }
      else
      {
          return B ^ C ^ D;
      }
  }
  
  static inline uint32_t S(uint32_t n, uint32_t X)
  {
      return (X << n) | (X >> (32 - n));
  }
  
  static inline uint32_t K(uint32_t t)
  {
      if (t < 20)
      {
          return 0x5a827999;
      }
      else if (t < 40)
      {
          return 0x6ed9eba1;
      }
      else if (t < 60)
      {
          return 0x8f1bbcdc;
      }
      else
      {
          return 0xca62c1d6;
      }
  }
  
  const int SecureHashAlgorithm::kDigestSizeBytes = 20;
  
  void SecureHashAlgorithm::Init()
  {
      A      = 0;
      B      = 0;
      C      = 0;
      D      = 0;
      E      = 0;
      cursor = 0;
      l      = 0;
      H[0]   = 0x67452301;
      H[1]   = 0xefcdab89;
      H[2]   = 0x98badcfe;
      H[3]   = 0x10325476;
      H[4]   = 0xc3d2e1f0;
  }
  
  void SecureHashAlgorithm::Final()
  {
      Pad();
      Process();
  
      for (int t = 0; t < 5; ++t)
          H[t] = ByteSwap(H[t]);
  }
  
  void SecureHashAlgorithm::Update(const void *data, size_t nbytes)
  {
      const uint8_t *d = reinterpret_cast<const uint8_t *>(data);
      while (nbytes--)
      {
          M[cursor++] = *d++;
          if (cursor >= 64)
              Process();
          l += 8;
      }
  }
  
  void SecureHashAlgorithm::Pad()
  {
      M[cursor++] = 0x80;
  
      if (cursor > 64 - 8)
      {
          // pad out to next block
          while (cursor < 64)
              M[cursor++] = 0;
  
          Process();
      }
  
      while (cursor < 64 - 8)
          M[cursor++] = 0;
  
      M[cursor++] = (l >> 56) & 0xff;
      M[cursor++] = (l >> 48) & 0xff;
      M[cursor++] = (l >> 40) & 0xff;
      M[cursor++] = (l >> 32) & 0xff;
      M[cursor++] = (l >> 24) & 0xff;
      M[cursor++] = (l >> 16) & 0xff;
      M[cursor++] = (l >> 8) & 0xff;
      M[cursor++] = l & 0xff;
  }
  
  void SecureHashAlgorithm::Process()
  {
      uint32_t t;
  
      // Each a...e corresponds to a section in the FIPS 180-3 algorithm.
  
      // a.
      //
      // W and M are in a union, so no need to memcpy.
      // memcpy(W, M, sizeof(M));
      for (t = 0; t < 16; ++t)
          W[t] = ByteSwap(W[t]);
  
      // b.
      for (t = 16; t < 80; ++t)
          W[t] = S(1, W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16]);
  
      // c.
      A = H[0];
      B = H[1];
      C = H[2];
      D = H[3];
      E = H[4];
  
      // d.
      for (t = 0; t < 80; ++t)
      {
          uint32_t TEMP = S(5, A) + f(t, B, C, D) + E + W[t] + K(t);
          E             = D;
          D             = C;
          C             = S(30, B);
          B             = A;
          A             = TEMP;
      }
  
      // e.
      H[0] += A;
      H[1] += B;
      H[2] += C;
      H[3] += D;
      H[4] += E;
  
      cursor = 0;
  }
  
  std::array<uint8_t, kSHA1Length> SecureHashAlgorithm::DigestAsArray() const
  {
      std::array<uint8_t, kSHA1Length> digest;
      memcpy(digest.data(), Digest(), SecureHashAlgorithm::kDigestSizeBytes);
      return digest;
  }
  
  std::string SHA1HashString(const std::string &str)
  {
      char hash[SecureHashAlgorithm::kDigestSizeBytes];
      SHA1HashBytes(reinterpret_cast<const unsigned char *>(str.c_str()), str.length(),
                    reinterpret_cast<unsigned char *>(hash));
      return std::string(hash, SecureHashAlgorithm::kDigestSizeBytes);
  }
  
  void SHA1HashBytes(const unsigned char *data, size_t len, unsigned char *hash)
  {
      SecureHashAlgorithm sha;
      sha.Update(data, len);
      sha.Final();
  
      memcpy(hash, sha.Digest(), SecureHashAlgorithm::kDigestSizeBytes);
  }
  
  }  // namespace base
  
  }  // namespace angle