/***************************************************************************
                              FLSha1.cpp
                         -------------------
begin                : lun ago 02 2004
copyright            : (C) 2004-2005 by InfoSiAL, S.L.
email                : mail@infosial.com
***************************************************************************/
/***************************************************************************
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; version 2 of the License.               *
 ***************************************************************************/
/***************************************************************************
   Este  programa es software libre. Puede redistribuirlo y/o modificarlo
   bajo  los  términos  de  la  Licencia  Pública General de GNU   en  su
   versión 2, publicada  por  la  Free  Software Foundation.
 ***************************************************************************/

#include "FLSha1.h"

#define MAX_FILE_READ_BUFFER 8000

// Rotate x bits to the left
#ifndef ROL32
#define ROL32(_val32, _nBits) (((_val32)<<(_nBits))|((_val32)>>(32-(_nBits))))
#endif

#ifdef SHA1_LITTLE_ENDIAN
#define SHABLK0(i) (m_block->l[i] = \
                                    (ROL32(m_block->l[i],24) & 0xFF00FF00) | (ROL32(m_block->l[i],8) & 0x00FF00FF))
#else
#define SHABLK0(i) (m_block->l[i])
#endif

#define SHABLK(i) (m_block->l[i&15] = ROL32(m_block->l[(i+13)&15] ^ m_block->l[(i+8)&15] \
                                            ^ m_block->l[(i+2)&15] ^ m_block->l[i&15],1))

// SHA-1 rounds
#define _R0(v,w,x,y,z,i) { z+=((w&(x^y))^y)+SHABLK0(i)+0x5A827999+ROL32(v,5); w=ROL32(w,30); }
#define _R1(v,w,x,y,z,i) { z+=((w&(x^y))^y)+SHABLK(i)+0x5A827999+ROL32(v,5); w=ROL32(w,30); }
#define _R2(v,w,x,y,z,i) { z+=(w^x^y)+SHABLK(i)+0x6ED9EBA1+ROL32(v,5); w=ROL32(w,30); }
#define _R3(v,w,x,y,z,i) { z+=(((w|x)&y)|(w&x))+SHABLK(i)+0x8F1BBCDC+ROL32(v,5); w=ROL32(w,30); }
#define _R4(v,w,x,y,z,i) { z+=(w^x^y)+SHABLK(i)+0xCA62C1D6+ROL32(v,5); w=ROL32(w,30); }

FLSha1::FLSha1()
{
  m_block = (SHA1_WORKSPACE_BLOCK *) m_workspace;

  Reset();
}

FLSha1::~FLSha1()
{
  Reset();
}

void FLSha1::Reset()
{
  // SHA1 initialization constants
  m_state[ 0 ] = 0x67452301;
  m_state[ 1 ] = 0xEFCDAB89;
  m_state[ 2 ] = 0x98BADCFE;
  m_state[ 3 ] = 0x10325476;
  m_state[ 4 ] = 0xC3D2E1F0;

  m_count[ 0 ] = 0;
  m_count[ 1 ] = 0;
}

void FLSha1::Transform(Q_UINT32 state[ 5 ], Q_UINT8 buffer[ 64 ])
{
  Q_UINT32 a = 0, b = 0, c = 0, d = 0, e = 0;

  memcpy(m_block, buffer, 64);

  // Copy state[] to working vars
  a = state[ 0 ];
  b = state[ 1 ];
  c = state[ 2 ];
  d = state[ 3 ];
  e = state[ 4 ];

  // 4 rounds of 20 operations each. Loop unrolled.
  _R0(a, b, c, d, e, 0);
  _R0(e, a, b, c, d, 1);
  _R0(d, e, a, b, c, 2);
  _R0(c, d, e, a, b, 3);
  _R0(b, c, d, e, a, 4);
  _R0(a, b, c, d, e, 5);
  _R0(e, a, b, c, d, 6);
  _R0(d, e, a, b, c, 7);
  _R0(c, d, e, a, b, 8);
  _R0(b, c, d, e, a, 9);
  _R0(a, b, c, d, e, 10);
  _R0(e, a, b, c, d, 11);
  _R0(d, e, a, b, c, 12);
  _R0(c, d, e, a, b, 13);
  _R0(b, c, d, e, a, 14);
  _R0(a, b, c, d, e, 15);
  _R1(e, a, b, c, d, 16);
  _R1(d, e, a, b, c, 17);
  _R1(c, d, e, a, b, 18);
  _R1(b, c, d, e, a, 19);
  _R2(a, b, c, d, e, 20);
  _R2(e, a, b, c, d, 21);
  _R2(d, e, a, b, c, 22);
  _R2(c, d, e, a, b, 23);
  _R2(b, c, d, e, a, 24);
  _R2(a, b, c, d, e, 25);
  _R2(e, a, b, c, d, 26);
  _R2(d, e, a, b, c, 27);
  _R2(c, d, e, a, b, 28);
  _R2(b, c, d, e, a, 29);
  _R2(a, b, c, d, e, 30);
  _R2(e, a, b, c, d, 31);
  _R2(d, e, a, b, c, 32);
  _R2(c, d, e, a, b, 33);
  _R2(b, c, d, e, a, 34);
  _R2(a, b, c, d, e, 35);
  _R2(e, a, b, c, d, 36);
  _R2(d, e, a, b, c, 37);
  _R2(c, d, e, a, b, 38);
  _R2(b, c, d, e, a, 39);
  _R3(a, b, c, d, e, 40);
  _R3(e, a, b, c, d, 41);
  _R3(d, e, a, b, c, 42);
  _R3(c, d, e, a, b, 43);
  _R3(b, c, d, e, a, 44);
  _R3(a, b, c, d, e, 45);
  _R3(e, a, b, c, d, 46);
  _R3(d, e, a, b, c, 47);
  _R3(c, d, e, a, b, 48);
  _R3(b, c, d, e, a, 49);
  _R3(a, b, c, d, e, 50);
  _R3(e, a, b, c, d, 51);
  _R3(d, e, a, b, c, 52);
  _R3(c, d, e, a, b, 53);
  _R3(b, c, d, e, a, 54);
  _R3(a, b, c, d, e, 55);
  _R3(e, a, b, c, d, 56);
  _R3(d, e, a, b, c, 57);
  _R3(c, d, e, a, b, 58);
  _R3(b, c, d, e, a, 59);
  _R4(a, b, c, d, e, 60);
  _R4(e, a, b, c, d, 61);
  _R4(d, e, a, b, c, 62);
  _R4(c, d, e, a, b, 63);
  _R4(b, c, d, e, a, 64);
  _R4(a, b, c, d, e, 65);
  _R4(e, a, b, c, d, 66);
  _R4(d, e, a, b, c, 67);
  _R4(c, d, e, a, b, 68);
  _R4(b, c, d, e, a, 69);
  _R4(a, b, c, d, e, 70);
  _R4(e, a, b, c, d, 71);
  _R4(d, e, a, b, c, 72);
  _R4(c, d, e, a, b, 73);
  _R4(b, c, d, e, a, 74);
  _R4(a, b, c, d, e, 75);
  _R4(e, a, b, c, d, 76);
  _R4(d, e, a, b, c, 77);
  _R4(c, d, e, a, b, 78);
  _R4(b, c, d, e, a, 79);

  // Add the working vars back into state[]
  state[ 0 ] += a;
  state[ 1 ] += b;
  state[ 2 ] += c;
  state[ 3 ] += d;
  state[ 4 ] += e;

  // Wipe variables
  a = b = c = d = e = 0;
}

// Use this function to hash in binary data and strings
void FLSha1::Update(Q_UINT8 *data, unsigned int len)
{
  Q_UINT32 i = 0, j;

  j = (m_count[ 0 ] >> 3) & 63;

  if ((m_count[ 0 ] += len << 3) < (len << 3))
    m_count[ 1 ] ++;

  m_count[ 1 ] += (len >> 29);

  if ((j + len) > 63) {
    memcpy(&m_buffer[ j ], data, (i = 64 - j));
    Transform(m_state, m_buffer);

    for (; i + 63 < len; i += 64)
      Transform(m_state, &data[ i ]);

    j = 0;
  } else
    i = 0;

  memcpy(&m_buffer[ j ], &data[ i ], len - i);
}

// Hash in file contents
bool FLSha1::HashFile(char *szFileName)
{
  Q_UINT32 ulFileSize = 0, ulRest = 0, ulBlocks = 0;
  Q_UINT32 i = 0;
  Q_UINT8 uData[ MAX_FILE_READ_BUFFER ];
  FILE *fIn = NULL;

  if (szFileName == NULL)
    return (false);

  if ((fIn = fopen(szFileName, "rb")) == NULL)
    return (false);

  fseek(fIn, 0, SEEK_END);
  ulFileSize = ftell(fIn);
  fseek(fIn, 0, SEEK_SET);

  ulRest = ulFileSize % MAX_FILE_READ_BUFFER;
  ulBlocks = ulFileSize / MAX_FILE_READ_BUFFER;

  for (i = 0; i < ulBlocks; i++) {
    fread(uData, 1, MAX_FILE_READ_BUFFER, fIn);
    Update(uData, MAX_FILE_READ_BUFFER);
  }

  if (ulRest != 0) {
    fread(uData, 1, ulRest, fIn);
    Update(uData, ulRest);
  }

  fclose(fIn);
  fIn = NULL;

  return (true);
}

void FLSha1::Final()
{
  Q_UINT32 i = 0, j = 0;
  Q_UINT8 finalcount[ 8 ] = { 0, 0, 0, 0, 0, 0, 0, 0 };

  for (i = 0; i < 8; i++)
    finalcount[ i ] = (Q_UINT8)((m_count[(i >= 4 ? 0 : 1)]
                                 >> ((3 - (i & 3)) * 8)) & 255);         // Endian independent

  Update((Q_UINT8 *) "\200", 1);

  while ((m_count[ 0 ] & 504) != 448)
    Update((Q_UINT8 *) "\0", 1);

  Update(finalcount, 8);   // Cause a SHA1Transform()

  for (i = 0; i < 20; i++) {
    m_digest[ i ] = (Q_UINT8)((m_state[ i >> 2 ] >> ((3 - (i & 3)) * 8)) & 255);
  }

  // Wipe variables for security reasons
  i = 0;
  j = 0;
  memset(m_buffer, 0, 64);
  memset(m_state, 0, 20);
  memset(m_count, 0, 8);
  memset(finalcount, 0, 8);

  Transform(m_state, m_buffer);
}

// Get the final hash as a pre-formatted string
void FLSha1::ReportHash(char *szReport, Q_UINT8 uReportType)
{
  Q_UINT8 i = 0;
  char szTemp[ 12 ];

  if (szReport == NULL)
    return ;

  if (uReportType == REPORT_HEX) {
    sprintf(szTemp, "%02X", m_digest[ 0 ]);
    strcat(szReport, szTemp);

    for (i = 1; i < 20; i++) {
      sprintf(szTemp, "%02X", m_digest[ i ]);
      strcat(szReport, szTemp);
    }
  } else if (uReportType == REPORT_DIGIT) {
    sprintf(szTemp, "%u", m_digest[ 0 ]);
    strcat(szReport, szTemp);

    for (i = 1; i < 20; i++) {
      sprintf(szTemp, " %u", m_digest[ i ]);
      strcat(szReport, szTemp);
    }
  } else
    strcpy(szReport, "Error: Unknown report type!");
}

// Get the raw message digest
void FLSha1::GetHash(Q_UINT8 *uDest)
{
  memcpy(uDest, m_digest, 20);
}