void SHA1::Update(__UINT8_TYPE__ *input, __UINT16_TYPE__ inputlength)
{
__UINT16_TYPE__ i, index, partlength;
index = (__UINT16_TYPE__)((context.count[0] >> 3) & 0x3F);
if ((context.count[0] += ((__UINT32_TYPE__)inputlength << 3)) < ((__UINT32_TYPE__)inputlength << 3))
context.count[1]++;
context.count[1] += ((__UINT32_TYPE__)inputlength >> 29);
partlength = 64 - index;
if (inputlength >= partlength)
{
memcpy((unsigned short *) & context.buffer[index], (unsigned short *)input, partlength);
SHA1Transform (context.state, context.buffer);
for (i = partlength; i + 63 < inputlength; i += 64)
SHA1Transform (context.state, &input[i]);
index = 0;
}
else
i = 0;
memcpy((unsigned short *) & context.buffer[index], (unsigned short *)&input[i], inputlength - i);
}
void Sha1Stream::Finish(byte *hash20)
{
Flush();
memset(buffer + pos, 0, 64 - pos);
buffer[pos] = 128;
if(pos > 55) {
SHA1Transform(state, buffer);
memset(buffer, 0, 64);
}
SHA1Size(buffer, size);
SHA1Transform(state, buffer);
SHA1Result(hash20, state);
Cleanup();
}
void SHA1Final(SHA1_CTX* context, unsigned char digest[SHA1_DIGEST_LENGTH])
{
unsigned i;
unsigned blen = context->bytes % SHA1_BLOCK_LENGTH;
context->buffer[blen++] = 0x80;
memset(context->buffer + blen, 0, SHA1_BLOCK_LENGTH - blen);
if (blen > SHA1_BLOCK_LENGTH-8) {
SHA1Transform(context->state, context->buffer);
memset(context->buffer, 0, SHA1_BLOCK_LENGTH-8);
}
uint64_pack_msb((context->bytes << 3),
context->buffer + SHA1_BLOCK_LENGTH - 8);
SHA1Transform(context->state, context->buffer);
for (i = 0; i < 5; ++i, digest += 4)
uint32_pack_msb(context->state[i], digest);
/* Wipe variables */
memset(context, 0, sizeof(*context));
}
void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32 len)
{
unsigned blen = context->bytes % SHA1_BLOCK_LENGTH;
unsigned use;
context->bytes += len;
if (blen > 0 && len >= (use = SHA1_BLOCK_LENGTH - blen)) {
memcpy(context->buffer + blen, data, use);
SHA1Transform(context->state, context->buffer);
blen = 0;
len -= use;
data += use;
}
while (len >= SHA1_BLOCK_LENGTH) {
SHA1Transform(context->state, data);
len -= SHA1_BLOCK_LENGTH;
data += SHA1_BLOCK_LENGTH;
}
memcpy(context->buffer + blen, data, len);
}
int fips186_2_prf(const u8 *seed, size_t seed_len, u8 *x, size_t xlen)
{
u8 xkey[64];
u32 t[5], _t[5];
int i, j, m, k;
u8 *xpos = x;
u32 carry;
if (seed_len < sizeof(xkey))
os_memset(xkey + seed_len, 0, sizeof(xkey) - seed_len);
else
seed_len = sizeof(xkey);
/* FIPS 186-2 + change notice 1 */
os_memcpy(xkey, seed, seed_len);
t[0] = 0x67452301;
t[1] = 0xEFCDAB89;
t[2] = 0x98BADCFE;
t[3] = 0x10325476;
t[4] = 0xC3D2E1F0;
m = xlen / 40;
for (j = 0; j < m; j++) {
/* XSEED_j = 0 */
for (i = 0; i < 2; i++) {
/* XVAL = (XKEY + XSEED_j) mod 2^b */
/* w_i = G(t, XVAL) */
os_memcpy(_t, t, 20);
SHA1Transform(_t, xkey);
_t[0] = host_to_be32(_t[0]);
_t[1] = host_to_be32(_t[1]);
_t[2] = host_to_be32(_t[2]);
_t[3] = host_to_be32(_t[3]);
_t[4] = host_to_be32(_t[4]);
os_memcpy(xpos, _t, 20);
/* XKEY = (1 + XKEY + w_i) mod 2^b */
carry = 1;
for (k = 19; k >= 0; k--) {
carry += xkey[k] + xpos[k];
xkey[k] = carry & 0xff;
carry >>= 8;
}
xpos += SHA1_MAC_LEN;
}
/* x_j = w_0|w_1 */
}
return 0;
}
void Sha1Stream::Out(const void *data, dword length)
{
const byte *s = (const byte *)data;
size += length;
while(pos + length >= 64) {
int n = 64 - pos;
memcpy(buffer + pos, s, n);
SHA1Transform(state, buffer);
s += n;
length -= n;
pos = 0;
}
memcpy(buffer + pos, s, length);
pos += length;
}
void Random_init(void)
{
struct timeval tv;
unsigned long seed;
u_int8_t buffer[64];
gettimeofday(&tv, (__timezone_ptr_t) 0);
seed = (unsigned long) (tv.tv_usec + (tv.tv_sec * getpid()));
snprintf((char *) &buffer, 64, "%lu", seed);
seed = 0ul;
u_int32_t state[5] = {0x67452301u, 0xefcdab89u, 0x98badcfeu, 0x10325476u, 0xc3d2e1f0u};
SHA1Transform(state, buffer);
seed = (unsigned long) ((state[0] ^ state[3]) ^ (state[1] ^ state[4]));
srand48(seed);
}
