LCOV - code coverage report
Current view: top level - lib/Support - SHA1.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 168 168 100.0 %
Date: 2017-09-14 15:23:50 Functions: 12 12 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //======- SHA1.h - Private copy of the SHA1 implementation ---*- 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             : //
      10             : // This code is taken from public domain
      11             : // (http://oauth.googlecode.com/svn/code/c/liboauth/src/sha1.c and
      12             : // http://cvsweb.netbsd.org/bsdweb.cgi/src/common/lib/libc/hash/sha1/sha1.c?rev=1.6)
      13             : // and modified by wrapping it in a C++ interface for LLVM,
      14             : // and removing unnecessary code.
      15             : //
      16             : //===----------------------------------------------------------------------===//
      17             : 
      18             : #include "llvm/Support/SHA1.h"
      19             : #include "llvm/ADT/ArrayRef.h"
      20             : #include "llvm/Support/Host.h"
      21             : using namespace llvm;
      22             : 
      23             : #include <stdint.h>
      24             : #include <string.h>
      25             : 
      26             : #if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
      27             : #define SHA_BIG_ENDIAN
      28             : #endif
      29             : 
      30             : static uint32_t rol(uint32_t Number, int Bits) {
      31   282780162 :   return (Number << Bits) | (Number >> (32 - Bits));
      32             : }
      33             : 
      34    20198576 : static uint32_t blk0(uint32_t *Buf, int I) { return Buf[I]; }
      35             : 
      36    80794300 : static uint32_t blk(uint32_t *Buf, int I) {
      37   242382900 :   Buf[I & 15] = rol(Buf[(I + 13) & 15] ^ Buf[(I + 8) & 15] ^ Buf[(I + 2) & 15] ^
      38    80794300 :                         Buf[I & 15],
      39             :                     1);
      40    80794300 :   return Buf[I & 15];
      41             : }
      42             : 
      43             : static void r0(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E,
      44             :                int I, uint32_t *Buf) {
      45    60595728 :   E += ((B & (C ^ D)) ^ D) + blk0(Buf, I) + 0x5A827999 + rol(A, 5);
      46    40397152 :   B = rol(B, 30);
      47             : }
      48             : 
      49     5049648 : static void r1(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E,
      50             :                int I, uint32_t *Buf) {
      51    10099296 :   E += ((B & (C ^ D)) ^ D) + blk(Buf, I) + 0x5A827999 + rol(A, 5);
      52    10099296 :   B = rol(B, 30);
      53     5049648 : }
      54             : 
      55             : static void r2(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E,
      56             :                int I, uint32_t *Buf) {
      57    50496474 :   E += (B ^ C ^ D) + blk(Buf, I) + 0x6ED9EBA1 + rol(A, 5);
      58    50496474 :   B = rol(B, 30);
      59             : }
      60             : 
      61    25248229 : static void r3(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E,
      62             :                int I, uint32_t *Buf) {
      63    50496464 :   E += (((B | C) & D) | (B & C)) + blk(Buf, I) + 0x8F1BBCDC + rol(A, 5);
      64    50496470 :   B = rol(B, 30);
      65    25248235 : }
      66             : 
      67             : static void r4(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D, uint32_t &E,
      68             :                int I, uint32_t *Buf) {
      69    50496471 :   E += (B ^ C ^ D) + blk(Buf, I) + 0xCA62C1D6 + rol(A, 5);
      70    50496470 :   B = rol(B, 30);
      71             : }
      72             : 
      73             : /* code */
      74             : #define SHA1_K0 0x5a827999
      75             : #define SHA1_K20 0x6ed9eba1
      76             : #define SHA1_K40 0x8f1bbcdc
      77             : #define SHA1_K60 0xca62c1d6
      78             : 
      79             : #define SEED_0 0x67452301
      80             : #define SEED_1 0xefcdab89
      81             : #define SEED_2 0x98badcfe
      82             : #define SEED_3 0x10325476
      83             : #define SEED_4 0xc3d2e1f0
      84             : 
      85        4758 : void SHA1::init() {
      86        4758 :   InternalState.State[0] = SEED_0;
      87        4758 :   InternalState.State[1] = SEED_1;
      88        4758 :   InternalState.State[2] = SEED_2;
      89        4758 :   InternalState.State[3] = SEED_3;
      90        4758 :   InternalState.State[4] = SEED_4;
      91        4758 :   InternalState.ByteCount = 0;
      92        4758 :   InternalState.BufferOffset = 0;
      93        4758 : }
      94             : 
      95     1262411 : void SHA1::hashBlock() {
      96     1262411 :   uint32_t A = InternalState.State[0];
      97     1262411 :   uint32_t B = InternalState.State[1];
      98     1262411 :   uint32_t C = InternalState.State[2];
      99     1262411 :   uint32_t D = InternalState.State[3];
     100     1262411 :   uint32_t E = InternalState.State[4];
     101             : 
     102             :   // 4 rounds of 20 operations each. Loop unrolled.
     103     2524822 :   r0(A, B, C, D, E, 0, InternalState.Buffer.L);
     104     2524822 :   r0(E, A, B, C, D, 1, InternalState.Buffer.L);
     105     2524822 :   r0(D, E, A, B, C, 2, InternalState.Buffer.L);
     106     2524822 :   r0(C, D, E, A, B, 3, InternalState.Buffer.L);
     107     2524822 :   r0(B, C, D, E, A, 4, InternalState.Buffer.L);
     108     2524822 :   r0(A, B, C, D, E, 5, InternalState.Buffer.L);
     109     2524822 :   r0(E, A, B, C, D, 6, InternalState.Buffer.L);
     110     2524822 :   r0(D, E, A, B, C, 7, InternalState.Buffer.L);
     111     2524822 :   r0(C, D, E, A, B, 8, InternalState.Buffer.L);
     112     2524822 :   r0(B, C, D, E, A, 9, InternalState.Buffer.L);
     113     2524822 :   r0(A, B, C, D, E, 10, InternalState.Buffer.L);
     114     2524822 :   r0(E, A, B, C, D, 11, InternalState.Buffer.L);
     115     2524822 :   r0(D, E, A, B, C, 12, InternalState.Buffer.L);
     116     2524822 :   r0(C, D, E, A, B, 13, InternalState.Buffer.L);
     117     2524822 :   r0(B, C, D, E, A, 14, InternalState.Buffer.L);
     118     2524822 :   r0(A, B, C, D, E, 15, InternalState.Buffer.L);
     119     1262411 :   r1(E, A, B, C, D, 16, InternalState.Buffer.L);
     120     1262412 :   r1(D, E, A, B, C, 17, InternalState.Buffer.L);
     121     1262412 :   r1(C, D, E, A, B, 18, InternalState.Buffer.L);
     122     1262412 :   r1(B, C, D, E, A, 19, InternalState.Buffer.L);
     123             : 
     124     2524824 :   r2(A, B, C, D, E, 20, InternalState.Buffer.L);
     125     2524824 :   r2(E, A, B, C, D, 21, InternalState.Buffer.L);
     126     2524824 :   r2(D, E, A, B, C, 22, InternalState.Buffer.L);
     127     2524824 :   r2(C, D, E, A, B, 23, InternalState.Buffer.L);
     128     2524824 :   r2(B, C, D, E, A, 24, InternalState.Buffer.L);
     129     2524824 :   r2(A, B, C, D, E, 25, InternalState.Buffer.L);
     130     2524824 :   r2(E, A, B, C, D, 26, InternalState.Buffer.L);
     131     2524824 :   r2(D, E, A, B, C, 27, InternalState.Buffer.L);
     132     2524824 :   r2(C, D, E, A, B, 28, InternalState.Buffer.L);
     133     2524824 :   r2(B, C, D, E, A, 29, InternalState.Buffer.L);
     134     2524824 :   r2(A, B, C, D, E, 30, InternalState.Buffer.L);
     135     2524824 :   r2(E, A, B, C, D, 31, InternalState.Buffer.L);
     136     2524824 :   r2(D, E, A, B, C, 32, InternalState.Buffer.L);
     137     2524824 :   r2(C, D, E, A, B, 33, InternalState.Buffer.L);
     138     2524823 :   r2(B, C, D, E, A, 34, InternalState.Buffer.L);
     139     2524823 :   r2(A, B, C, D, E, 35, InternalState.Buffer.L);
     140     2524824 :   r2(E, A, B, C, D, 36, InternalState.Buffer.L);
     141     2524823 :   r2(D, E, A, B, C, 37, InternalState.Buffer.L);
     142     2524822 :   r2(C, D, E, A, B, 38, InternalState.Buffer.L);
     143     2524823 :   r2(B, C, D, E, A, 39, InternalState.Buffer.L);
     144             : 
     145     1262412 :   r3(A, B, C, D, E, 40, InternalState.Buffer.L);
     146     1262412 :   r3(E, A, B, C, D, 41, InternalState.Buffer.L);
     147     1262412 :   r3(D, E, A, B, C, 42, InternalState.Buffer.L);
     148     1262412 :   r3(C, D, E, A, B, 43, InternalState.Buffer.L);
     149     1262412 :   r3(B, C, D, E, A, 44, InternalState.Buffer.L);
     150     1262412 :   r3(A, B, C, D, E, 45, InternalState.Buffer.L);
     151     1262412 :   r3(E, A, B, C, D, 46, InternalState.Buffer.L);
     152     1262412 :   r3(D, E, A, B, C, 47, InternalState.Buffer.L);
     153     1262412 :   r3(C, D, E, A, B, 48, InternalState.Buffer.L);
     154     1262412 :   r3(B, C, D, E, A, 49, InternalState.Buffer.L);
     155     1262412 :   r3(A, B, C, D, E, 50, InternalState.Buffer.L);
     156     1262412 :   r3(E, A, B, C, D, 51, InternalState.Buffer.L);
     157     1262412 :   r3(D, E, A, B, C, 52, InternalState.Buffer.L);
     158     1262412 :   r3(C, D, E, A, B, 53, InternalState.Buffer.L);
     159     1262412 :   r3(B, C, D, E, A, 54, InternalState.Buffer.L);
     160     1262412 :   r3(A, B, C, D, E, 55, InternalState.Buffer.L);
     161     1262412 :   r3(E, A, B, C, D, 56, InternalState.Buffer.L);
     162     1262412 :   r3(D, E, A, B, C, 57, InternalState.Buffer.L);
     163     1262412 :   r3(C, D, E, A, B, 58, InternalState.Buffer.L);
     164     1262412 :   r3(B, C, D, E, A, 59, InternalState.Buffer.L);
     165             : 
     166     2524824 :   r4(A, B, C, D, E, 60, InternalState.Buffer.L);
     167     2524823 :   r4(E, A, B, C, D, 61, InternalState.Buffer.L);
     168     2524822 :   r4(D, E, A, B, C, 62, InternalState.Buffer.L);
     169     2524823 :   r4(C, D, E, A, B, 63, InternalState.Buffer.L);
     170     2524824 :   r4(B, C, D, E, A, 64, InternalState.Buffer.L);
     171     2524824 :   r4(A, B, C, D, E, 65, InternalState.Buffer.L);
     172     2524823 :   r4(E, A, B, C, D, 66, InternalState.Buffer.L);
     173     2524823 :   r4(D, E, A, B, C, 67, InternalState.Buffer.L);
     174     2524824 :   r4(C, D, E, A, B, 68, InternalState.Buffer.L);
     175     2524824 :   r4(B, C, D, E, A, 69, InternalState.Buffer.L);
     176     2524824 :   r4(A, B, C, D, E, 70, InternalState.Buffer.L);
     177     2524823 :   r4(E, A, B, C, D, 71, InternalState.Buffer.L);
     178     2524823 :   r4(D, E, A, B, C, 72, InternalState.Buffer.L);
     179     2524824 :   r4(C, D, E, A, B, 73, InternalState.Buffer.L);
     180     2524824 :   r4(B, C, D, E, A, 74, InternalState.Buffer.L);
     181     2524824 :   r4(A, B, C, D, E, 75, InternalState.Buffer.L);
     182     2524824 :   r4(E, A, B, C, D, 76, InternalState.Buffer.L);
     183     2524824 :   r4(D, E, A, B, C, 77, InternalState.Buffer.L);
     184     2524824 :   r4(C, D, E, A, B, 78, InternalState.Buffer.L);
     185     2524823 :   r4(B, C, D, E, A, 79, InternalState.Buffer.L);
     186             : 
     187     1262411 :   InternalState.State[0] += A;
     188     1262411 :   InternalState.State[1] += B;
     189     1262411 :   InternalState.State[2] += C;
     190     1262411 :   InternalState.State[3] += D;
     191     1262411 :   InternalState.State[4] += E;
     192     1262411 : }
     193             : 
     194    80794332 : void SHA1::addUncounted(uint8_t Data) {
     195             : #ifdef SHA_BIG_ENDIAN
     196             :   InternalState.Buffer.C[InternalState.BufferOffset] = Data;
     197             : #else
     198    80794332 :   InternalState.Buffer.C[InternalState.BufferOffset ^ 3] = Data;
     199             : #endif
     200             : 
     201    80794332 :   InternalState.BufferOffset++;
     202    80794332 :   if (InternalState.BufferOffset == BLOCK_LENGTH) {
     203     1262412 :     hashBlock();
     204     1262411 :     InternalState.BufferOffset = 0;
     205             :   }
     206    80794331 : }
     207             : 
     208    80741882 : void SHA1::writebyte(uint8_t Data) {
     209    80741882 :   ++InternalState.ByteCount;
     210    80741882 :   addUncounted(Data);
     211    80741885 : }
     212             : 
     213        2867 : void SHA1::update(ArrayRef<uint8_t> Data) {
     214    80747620 :   for (auto &C : Data)
     215    80741875 :     writebyte(C);
     216        2878 : }
     217             : 
     218        1206 : void SHA1::pad() {
     219             :   // Implement SHA-1 padding (fips180-2 5.1.1)
     220             : 
     221             :   // Pad with 0x80 followed by 0x00 until the end of the block
     222        1206 :   addUncounted(0x80);
     223       84397 :   while (InternalState.BufferOffset != 56)
     224       41596 :     addUncounted(0x00);
     225             : 
     226             :   // Append length in the last 8 bytes
     227        1206 :   addUncounted(0); // We're only using 32 bit lengths
     228        1206 :   addUncounted(0); // But SHA-1 supports 64 bit lengths
     229        1206 :   addUncounted(0); // So zero pad the top bits
     230        1206 :   addUncounted(InternalState.ByteCount >> 29); // Shifting to multiply by 8
     231        1206 :   addUncounted(InternalState.ByteCount >>
     232             :                21); // as SHA-1 supports bitstreams as well as
     233        1206 :   addUncounted(InternalState.ByteCount >> 13); // byte.
     234        1206 :   addUncounted(InternalState.ByteCount >> 5);
     235        1206 :   addUncounted(InternalState.ByteCount << 3);
     236        1206 : }
     237             : 
     238        1206 : StringRef SHA1::final() {
     239             :   // Pad to complete the last block
     240        1206 :   pad();
     241             : 
     242             : #ifdef SHA_BIG_ENDIAN
     243             :   // Just copy the current state
     244             :   for (int i = 0; i < 5; i++) {
     245             :     HashResult[i] = InternalState.State[i];
     246             :   }
     247             : #else
     248             :   // Swap byte order back
     249        7236 :   for (int i = 0; i < 5; i++) {
     250       18090 :     HashResult[i] = (((InternalState.State[i]) << 24) & 0xff000000) |
     251       12060 :                     (((InternalState.State[i]) << 8) & 0x00ff0000) |
     252       12060 :                     (((InternalState.State[i]) >> 8) & 0x0000ff00) |
     253        6030 :                     (((InternalState.State[i]) >> 24) & 0x000000ff);
     254             :   }
     255             : #endif
     256             : 
     257             :   // Return pointer to hash (20 characters)
     258        1206 :   return StringRef((char *)HashResult, HASH_LENGTH);
     259             : }
     260             : 
     261        1184 : StringRef SHA1::result() {
     262        1184 :   auto StateToRestore = InternalState;
     263             : 
     264        1184 :   auto Hash = final();
     265             : 
     266             :   // Restore the state
     267        1184 :   InternalState = StateToRestore;
     268             : 
     269             :   // Return pointer to hash (20 characters)
     270        1184 :   return Hash;
     271             : }
     272             : 
     273           9 : std::array<uint8_t, 20> SHA1::hash(ArrayRef<uint8_t> Data) {
     274           9 :   SHA1 Hash;
     275           9 :   Hash.update(Data);
     276           9 :   StringRef S = Hash.final();
     277             : 
     278             :   std::array<uint8_t, 20> Arr;
     279          27 :   memcpy(Arr.data(), S.data(), S.size());
     280           9 :   return Arr;
     281             : }

Generated by: LCOV version 1.13