md5.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 "md5.hpp"
//---------------------------------------------------------------------------
 
using namespace std;
//---------------------------------------------------------------------------
 
 
namespace libxcks
{
// For doxygen
//---------------------------------------------------------------------------
 
 
/*
 * Default constructor.
 */
MD5::MD5()
{
  reset();
}
//---------------------------------------------------------------------------
 
 
/*
 * Resets the MD5 hash to initial value.
 */
void MD5::reset()
{
  A_ = 0x67452301;
  B_ = 0xefcdab89;
  C_ = 0x98badcfe;
  D_ = 0x10325476;
 
  nblocks = 0;
  count = 0;
}
//---------------------------------------------------------------------------
 
 
/*
 * Process the remaining bytes in the internal buffer and the usual
 * prolog according to the standard.
 */
void MD5::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] = lsb;
  ibuffer[57] = lsb >>  8;
  ibuffer[58] = lsb >> 16;
  ibuffer[59] = lsb >> 24;
  ibuffer[60] = msb;
  ibuffer[61] = msb >>  8;
  ibuffer[62] = msb >> 16;
  ibuffer[63] = msb >> 24;
  transform(ibuffer);
  //_gcry_burn_stack (80+6*sizeof(void*));
 
  p = ibuffer;
  #if (LIBXCKS_BYTE_ORDER == LIBXCKS_LITTLE_ENDIAN)
  #define X(a) do { *(uint32_t*)p = a ; p += 4; } while(0)
  #else /* big endian */
  #define X(a) do { *p++ = a;       *p++ = a >> 8; \
                    *p++ = a >> 16; *p++ = a >> 24; } while(0)
  #endif
  X(A_);
  X(B_);
  X(C_);
  X(D_);
  #undef X
}
//---------------------------------------------------------------------------
 
 
/*
 * Updates the MD5 hash with specified array of bytes.
 */
void MD5::update(const uint8_t* buf, size_t len)
{
  if (count == 64)  // flush the buffer
  {
    transform(ibuffer);
    // _gcry_burn_stack (80+6*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 (80+6*sizeof(void*));
  for(; len && count < 64; len--)
    ibuffer[count++] = *buf++;
}
//---------------------------------------------------------------------------
 
 
// These are the four functions used in the four steps of the MD5 algorithm
// and defined in the RFC 1321.  The first function is a little bit optimized
// (as found in Colin Plumbs public domain implementation).
// #define FF(b, c, d) ((b & c) | (~b & d))
#define FF(b, c, d) (d ^ (b & (c ^ d)))  
#define FG(b, c, d) FF (d, b, c)         
#define FH(b, c, d) (b ^ c ^ d)          
#define FI(b, c, d) (c ^ (b | ~d))       
 
/*
 * Process [len] bytes of [buf], accumulating context in [this].
 * It is assumed that len % 64 == 0.
 */
void MD5::transform(uint8_t* data)
{
  uint32_t  correct_words[16];
  uint32_t  A = A_;
  uint32_t  B = B_;
  uint32_t  C = C_;
  uint32_t  D = D_;
  uint32_t* cwp = correct_words;
 
  #if (LIBXCKS_BYTE_ORDER == LIBXCKS_BIG_ENDIAN)
  {
    int i;
    uint8_t *p2, *p1;
    for (i = 0, p1 = data, p2 = (uint8_t*)correct_words; i < 16; i++, p2 += 4)
    {
      p2[3] = *p1++;
      p2[2] = *p1++;
      p2[1] = *p1++;
      p2[0] = *p1++;
    }
  }
  #else
  memcpy(correct_words, data, 64);
  #endif
 
 
  // First round: using the given function, the context and a constant the
  // next context is computed.  Because the algorithms processing unit is a
  // 32-bit word and it is determined to work on words in little endian byte
  // order we perhaps have to change the byte order before the computation.
  // To reduce the work for the next steps we store the swapped words in the
  // array CORRECT_WORDS.
  #define OP(a, b, c, d, s, T) \
          do \
          { \
            a += FF(b, c, d) + (*cwp++) + T; \
            a = rol(a, s); \
            a += b; \
          } \
          while (0)
 
  // Before we start, one word to the strange constants.
  // They are defined in RFC 1321 as
  //
  // T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64, or
  // perl -e 'foreach(1..64){printf "0x%08x\n", int (4294967296 * abs (sin $_))}'
 
  // Round 1.
  OP(A, B, C, D,  7, 0xd76aa478);
  OP(D, A, B, C, 12, 0xe8c7b756);
  OP(C, D, A, B, 17, 0x242070db);
  OP(B, C, D, A, 22, 0xc1bdceee);
  OP(A, B, C, D,  7, 0xf57c0faf);
  OP(D, A, B, C, 12, 0x4787c62a);
  OP(C, D, A, B, 17, 0xa8304613);
  OP(B, C, D, A, 22, 0xfd469501);
  OP(A, B, C, D,  7, 0x698098d8);
  OP(D, A, B, C, 12, 0x8b44f7af);
  OP(C, D, A, B, 17, 0xffff5bb1);
  OP(B, C, D, A, 22, 0x895cd7be);
  OP(A, B, C, D,  7, 0x6b901122);
  OP(D, A, B, C, 12, 0xfd987193);
  OP(C, D, A, B, 17, 0xa679438e);
  OP(B, C, D, A, 22, 0x49b40821);
 
  // For the second to fourth round we have the possibly swapped words
  // in CORRECT_WORDS.  Redefine the macro to take an additional first
  // argument specifying the function to use.
  #undef OP
  #define OP(f, a, b, c, d, k, s, T) \
          do \
          { \
            a += f (b, c, d) + correct_words[k] + T; \
            a = rol (a, s); \
            a += b; \
          } \
          while (0)
 
  // Round 2.
  OP(FG, A, B, C, D,  1,  5, 0xf61e2562);
  OP(FG, D, A, B, C,  6,  9, 0xc040b340);
  OP(FG, C, D, A, B, 11, 14, 0x265e5a51);
  OP(FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
  OP(FG, A, B, C, D,  5,  5, 0xd62f105d);
  OP(FG, D, A, B, C, 10,  9, 0x02441453);
  OP(FG, C, D, A, B, 15, 14, 0xd8a1e681);
  OP(FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
  OP(FG, A, B, C, D,  9,  5, 0x21e1cde6);
  OP(FG, D, A, B, C, 14,  9, 0xc33707d6);
  OP(FG, C, D, A, B,  3, 14, 0xf4d50d87);
  OP(FG, B, C, D, A,  8, 20, 0x455a14ed);
  OP(FG, A, B, C, D, 13,  5, 0xa9e3e905);
  OP(FG, D, A, B, C,  2,  9, 0xfcefa3f8);
  OP(FG, C, D, A, B,  7, 14, 0x676f02d9);
  OP(FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
 
  // Round 3.
  OP(FH, A, B, C, D,  5,  4, 0xfffa3942);
  OP(FH, D, A, B, C,  8, 11, 0x8771f681);
  OP(FH, C, D, A, B, 11, 16, 0x6d9d6122);
  OP(FH, B, C, D, A, 14, 23, 0xfde5380c);
  OP(FH, A, B, C, D,  1,  4, 0xa4beea44);
  OP(FH, D, A, B, C,  4, 11, 0x4bdecfa9);
  OP(FH, C, D, A, B,  7, 16, 0xf6bb4b60);
  OP(FH, B, C, D, A, 10, 23, 0xbebfbc70);
  OP(FH, A, B, C, D, 13,  4, 0x289b7ec6);
  OP(FH, D, A, B, C,  0, 11, 0xeaa127fa);
  OP(FH, C, D, A, B,  3, 16, 0xd4ef3085);
  OP(FH, B, C, D, A,  6, 23, 0x04881d05);
  OP(FH, A, B, C, D,  9,  4, 0xd9d4d039);
  OP(FH, D, A, B, C, 12, 11, 0xe6db99e5);
  OP(FH, C, D, A, B, 15, 16, 0x1fa27cf8);
  OP(FH, B, C, D, A,  2, 23, 0xc4ac5665);
 
  // Round 4.
  OP(FI, A, B, C, D,  0,  6, 0xf4292244);
  OP(FI, D, A, B, C,  7, 10, 0x432aff97);
  OP(FI, C, D, A, B, 14, 15, 0xab9423a7);
  OP(FI, B, C, D, A,  5, 21, 0xfc93a039);
  OP(FI, A, B, C, D, 12,  6, 0x655b59c3);
  OP(FI, D, A, B, C,  3, 10, 0x8f0ccc92);
  OP(FI, C, D, A, B, 10, 15, 0xffeff47d);
  OP(FI, B, C, D, A,  1, 21, 0x85845dd1);
  OP(FI, A, B, C, D,  8,  6, 0x6fa87e4f);
  OP(FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
  OP(FI, C, D, A, B,  6, 15, 0xa3014314);
  OP(FI, B, C, D, A, 13, 21, 0x4e0811a1);
  OP(FI, A, B, C, D,  4,  6, 0xf7537e82);
  OP(FI, D, A, B, C, 11, 10, 0xbd3af235);
  OP(FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
  OP(FI, B, C, D, A,  9, 21, 0xeb86d391);
 
 
  // Put hash in the local context.
  A_ += A;
  B_ += B;
  C_ += C;
  D_ += D;
}
//---------------------------------------------------------------------------
 
 
/*
 * Returns the MD5 hash value in the first 16 bytes of the given address.
 */
uint8_t* MD5::getValue(uint8_t* buffer) const
{
  MD5 md5(*this);
  md5.finish();
 
  (reinterpret_cast<uint32_t*>(buffer))[0] = swapOnBE(md5.A_);
  (reinterpret_cast<uint32_t*>(buffer))[1] = swapOnBE(md5.B_);
  (reinterpret_cast<uint32_t*>(buffer))[2] = swapOnBE(md5.C_);
  (reinterpret_cast<uint32_t*>(buffer))[3] = swapOnBE(md5.D_);
 
  return buffer;
}
//---------------------------------------------------------------------------
}  // namespace libxcks
//---------------------------------------------------------------------------