sha1.cpp

Go to the documentation of this file.

/*
 * libxcks
 * Copyright (C) 2022 Julien Couot
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
//---------------------------------------------------------------------------
#include <cstring>
 
#include "sha1.hpp"
//---------------------------------------------------------------------------
 
using namespace std;
//---------------------------------------------------------------------------
 
 
namespace libxcks
{
// For doxygen
//---------------------------------------------------------------------------
 
 
/*
 * Default constructor.
 */
SHA1::SHA1()
{
  reset();
}
//---------------------------------------------------------------------------
 
 
/*
 * Resets the SHA1 hash to initial value.
 */
void SHA1::reset()
{
  h0 = 0x67452301;
  h1 = 0xefcdab89;
  h2 = 0x98badcfe;
  h3 = 0x10325476;
  h4 = 0xc3d2e1f0;
  nblocks = 0;
  count = 0;
}
//---------------------------------------------------------------------------
 
 
/*
 * Process the remaining bytes in the internal buffer and the usual
 * prolog according to the standard.
 */
void SHA1::finish()
{
  uint32_t t, msb, lsb;
  uint8_t *p;
 
  update(nullptr, 0); // flush
 
  t = nblocks;
  // multiply by 64 to make a byte count
  lsb = t << 6;
  msb = t >> 26;
  // add the count
  t = lsb;
  if ((lsb += count) < t)
    msb++;
  // multiply by 8 to make a bit count
  t = lsb;
  lsb <<= 3;
  msb <<= 3;
  msb |= t >> 29;
 
  if (count < 56)  // enough room
  {
    ibuffer[count++] = 0x80; // pad
    while (count < 56)
      ibuffer[count++] = 0;  // pad
  }
  else  // need one extra block
  {
    ibuffer[count++] = 0x80;  // pad character
    while (count < 64)
      ibuffer[count++] = 0;
    update(nullptr, 0);  // flush
    memset(ibuffer, 0, 56);  // fill next block with zeroes
  }
  /* append the 64 bit count */
  ibuffer[56] = msb >> 24;
  ibuffer[57] = msb >> 16;
  ibuffer[58] = msb >>  8;
  ibuffer[59] = msb;
  ibuffer[60] = lsb >> 24;
  ibuffer[61] = lsb >> 16;
  ibuffer[62] = lsb >>  8;
  ibuffer[63] = lsb;
  transform(ibuffer);
  //_gcry_burn_stack (88+4*sizeof(void*));
 
  p = ibuffer;
  #if (LIBXCKS_BYTE_ORDER == LIBXCKS_BIG_ENDIAN)
  #define X(a) do { *(uint32_t*)p = h##a ; p += 4; } while(0)
  #else /* little endian */
  #define X(a) do { *p++ = h##a >> 24; *p++ = h##a >> 16;    \
                    *p++ = h##a >> 8; *p++ = h##a; } while(0)
  #endif
  X(0);
  X(1);
  X(2);
  X(3);
  X(4);
  #undef X
}
//---------------------------------------------------------------------------
 
 
/*
 * Updates the SHA1 hash with specified array of bytes.
 */
void SHA1::update(const uint8_t* buf, size_t len)
{
  if (count == 64)  // flush the buffer
  {
    transform(ibuffer);
    // _gcry_burn_stack (88+4*sizeof(void*));
    count = 0;
    nblocks++;
  }
  if (buf == nullptr)
    return;
 
  if (count != 0)
  {
    for (; len && count < 64; len--)
      ibuffer[count++] = *buf++;
    update(nullptr, 0);
    if (len == 0)
      return;
  }
 
  while (len >= 64)
  {
    uint8_t tmpBuf[sizeof(uint32_t) * 16];
    memcpy(tmpBuf, buf, sizeof(uint32_t) * 16);
    transform(tmpBuf);
    count = 0;
    nblocks++;
    len -= 64;
    buf += 64;
  }
  //_gcry_burn_stack (88+4*sizeof(void*));
  for(; len && count < 64; len--)
    ibuffer[count++] = *buf++;
}
//---------------------------------------------------------------------------
 
 
/*
 * Transform the message X which consists of 16 32-bit-words.
 */
void SHA1::transform(uint8_t* data)
{
  uint32_t a, b, c, d, e, tm;
  uint32_t x[16];
 
  /* Get values from the chaining vars. */
  a = h0;
  b = h1;
  c = h2;
  d = h3;
  e = h4;
 
  #if (LIBXCKS_BYTE_ORDER == LIBXCKS_BIG_ENDIAN)
  memcpy(x, data, 64);
  #else
  {
    int i;
    uint8_t *p2;
    for (i = 0, p2 = (uint8_t*)x; i < 16; i++, p2 += 4)
    {
      p2[3] = *data++;
      p2[2] = *data++;
      p2[1] = *data++;
      p2[0] = *data++;
    }
  }
  #endif
 
  #define K1  0x5A827999L
  #define K2  0x6ED9EBA1L
  #define K3  0x8F1BBCDCL
  #define K4  0xCA62C1D6L
  #define F1(x,y,z)   ( z ^ ( x & ( y ^ z ) ) )
  #define F2(x,y,z)   ( x ^ y ^ z )
  #define F3(x,y,z)   ( ( x & y ) | ( z & ( x | y ) ) )
  #define F4(x,y,z)   ( x ^ y ^ z )
 
  #define M(i) ( tm =   x[i & 0x0f] ^ x[(i - 14) & 0x0f] \
                      ^ x[(i - 8) & 0x0f] ^ x[(i - 3) & 0x0f] \
                 , (x[i & 0x0f] = rol(tm, 1)) )
 
  #define R(a,b,c,d,e,f,k,m)  do { e += rol(a, 5) \
                                        + f(b, c, d) \
                                        + k \
                                        + m; \
                                   b = rol( b, 30 ); \
                                 } while(0)
 
  R(a, b, c, d, e, F1, K1, x[ 0]);
  R(e, a, b, c, d, F1, K1, x[ 1]);
  R(d, e, a, b, c, F1, K1, x[ 2]);
  R(c, d, e, a, b, F1, K1, x[ 3]);
  R(b, c, d, e, a, F1, K1, x[ 4]);
  R(a, b, c, d, e, F1, K1, x[ 5]);
  R(e, a, b, c, d, F1, K1, x[ 6]);
  R(d, e, a, b, c, F1, K1, x[ 7]);
  R(c, d, e, a, b, F1, K1, x[ 8]);
  R(b, c, d, e, a, F1, K1, x[ 9]);
  R(a, b, c, d, e, F1, K1, x[10]);
  R(e, a, b, c, d, F1, K1, x[11]);
  R(d, e, a, b, c, F1, K1, x[12]);
  R(c, d, e, a, b, F1, K1, x[13]);
  R(b, c, d, e, a, F1, K1, x[14]);
  R(a, b, c, d, e, F1, K1, x[15]);
  R(e, a, b, c, d, F1, K1, M(16));
  R(d, e, a, b, c, F1, K1, M(17));
  R(c, d, e, a, b, F1, K1, M(18));
  R(b, c, d, e, a, F1, K1, M(19));
  R(a, b, c, d, e, F2, K2, M(20));
  R(e, a, b, c, d, F2, K2, M(21));
  R(d, e, a, b, c, F2, K2, M(22));
  R(c, d, e, a, b, F2, K2, M(23));
  R(b, c, d, e, a, F2, K2, M(24));
  R(a, b, c, d, e, F2, K2, M(25));
  R(e, a, b, c, d, F2, K2, M(26));
  R(d, e, a, b, c, F2, K2, M(27));
  R(c, d, e, a, b, F2, K2, M(28));
  R(b, c, d, e, a, F2, K2, M(29));
  R(a, b, c, d, e, F2, K2, M(30));
  R(e, a, b, c, d, F2, K2, M(31));
  R(d, e, a, b, c, F2, K2, M(32));
  R(c, d, e, a, b, F2, K2, M(33));
  R(b, c, d, e, a, F2, K2, M(34));
  R(a, b, c, d, e, F2, K2, M(35));
  R(e, a, b, c, d, F2, K2, M(36));
  R(d, e, a, b, c, F2, K2, M(37));
  R(c, d, e, a, b, F2, K2, M(38));
  R(b, c, d, e, a, F2, K2, M(39));
  R(a, b, c, d, e, F3, K3, M(40));
  R(e, a, b, c, d, F3, K3, M(41));
  R(d, e, a, b, c, F3, K3, M(42));
  R(c, d, e, a, b, F3, K3, M(43));
  R(b, c, d, e, a, F3, K3, M(44));
  R(a, b, c, d, e, F3, K3, M(45));
  R(e, a, b, c, d, F3, K3, M(46));
  R(d, e, a, b, c, F3, K3, M(47));
  R(c, d, e, a, b, F3, K3, M(48));
  R(b, c, d, e, a, F3, K3, M(49));
  R(a, b, c, d, e, F3, K3, M(50));
  R(e, a, b, c, d, F3, K3, M(51));
  R(d, e, a, b, c, F3, K3, M(52));
  R(c, d, e, a, b, F3, K3, M(53));
  R(b, c, d, e, a, F3, K3, M(54));
  R(a, b, c, d, e, F3, K3, M(55));
  R(e, a, b, c, d, F3, K3, M(56));
  R(d, e, a, b, c, F3, K3, M(57));
  R(c, d, e, a, b, F3, K3, M(58));
  R(b, c, d, e, a, F3, K3, M(59));
  R(a, b, c, d, e, F4, K4, M(60));
  R(e, a, b, c, d, F4, K4, M(61));
  R(d, e, a, b, c, F4, K4, M(62));
  R(c, d, e, a, b, F4, K4, M(63));
  R(b, c, d, e, a, F4, K4, M(64));
  R(a, b, c, d, e, F4, K4, M(65));
  R(e, a, b, c, d, F4, K4, M(66));
  R(d, e, a, b, c, F4, K4, M(67));
  R(c, d, e, a, b, F4, K4, M(68));
  R(b, c, d, e, a, F4, K4, M(69));
  R(a, b, c, d, e, F4, K4, M(70));
  R(e, a, b, c, d, F4, K4, M(71));
  R(d, e, a, b, c, F4, K4, M(72));
  R(c, d, e, a, b, F4, K4, M(73));
  R(b, c, d, e, a, F4, K4, M(74));
  R(a, b, c, d, e, F4, K4, M(75));
  R(e, a, b, c, d, F4, K4, M(76));
  R(d, e, a, b, c, F4, K4, M(77));
  R(c, d, e, a, b, F4, K4, M(78));
  R(b, c, d, e, a, F4, K4, M(79));
 
  // Update chaining vars.
  h0 += a;
  h1 += b;
  h2 += c;
  h3 += d;
  h4 += e;
}
//---------------------------------------------------------------------------
 
 
/*
 * Returns the SHA1 hash value in the first 20 bytes of the given address.
 */
uint8_t* SHA1::getValue(uint8_t* buffer) const
{
  SHA1 sha1(*this);
  sha1.finish();
 
  memcpy(buffer, sha1.ibuffer, getSize());
 
  return buffer;
}
//---------------------------------------------------------------------------
 
 
/*
 * Returns the alternative names of the SHA1 hash algorithm.
 */
ArrayString SHA1::getAlternativeNames()
{
  return ArrayString{ "SHA1", "SHA160", "SHA-160" };
}
//---------------------------------------------------------------------------
}  // namespace libxcks
//---------------------------------------------------------------------------