int SHA1_Final (unsigned char *md, SHA_CTX *c)
{
unsigned char *p = (unsigned char *)c->data;
size_t n = c->num;
p[n] = 0x80; /* there is always room for one */
n++;
if (n > (SHA_CBLOCK-8))
{
memset (p+n,0,SHA_CBLOCK-n);
n=0;
sha1_block_data_order (c,p,1);
}
memset (p+n,0,SHA_CBLOCK-8-n);
p += SHA_CBLOCK-8;
(void)HOST_l2c(c->Nh,p);
(void)HOST_l2c(c->Nl,p);
p -= SHA_CBLOCK;
sha1_block_data_order (c,p,1);
c->num=0;
memset (p,0,SHA_CBLOCK);
HASH_MAKE_STRING(c,md);
return 1;
}
void SHA256_Final (unsigned char *md, SHA256_CTX *c) {
unsigned char *p = c->data;
size_t n = c->num;
SHA_LONG cNl,cNh;
p[n] = 0x80; /* there is always room for one */
n++;
if (n > (SHA_CBLOCK-8))
{
memset (p+n,0,SHA_CBLOCK-n);
n=0;
sha256_block_data_order (c,p);
}
memset (p+n,0,SHA_CBLOCK-8-n);
p += SHA_CBLOCK-8;
cNh=c->Nh; (void)HOST_l2c(cNh,p);
cNl=c->Nl; (void)HOST_l2c(cNl,p);
p -= SHA_CBLOCK;
sha256_block_data_order (c,p);
c->num=0;
memset (p,0,SHA_CBLOCK);
{unsigned long ll;
unsigned int xn;
for (xn=0;xn<SHA256_DIGEST_LENGTH/4;xn++)
{ ll=(c)->h[xn]; HOST_l2c(ll,md); }
}
return;
}
void MD5_finish(md5_t *c, void *md)
{
unsigned char *p = (unsigned char *) c->data;
size_t n = c->num;
char* _md = (char*)md;
p[n] = 0x80; /* there is always room for one */
n++;
if (n > (MD5_CBLOCK - 8))
{
memset(p + n, 0, MD5_CBLOCK - n);
n = 0;
md5_block_data_order(c, p, 1);
}
memset(p + n, 0, MD5_CBLOCK - 8 - n);
p += MD5_CBLOCK - 8;
(void) HOST_l2c(c->Nl,p);
(void) HOST_l2c(c->Nh,p);
p -= MD5_CBLOCK;
md5_block_data_order(c, p, 1);
c->num = 0;
memset(p, 0, MD5_CBLOCK);
HASH_MAKE_STRING(c, _md);
}
//Finish MD4 process
void __fastcall MD4_Final(
uint8_t *md,
MD4_CTX *c)
{
unsigned char *p = (unsigned char *)c->Data;
size_t n = c->Num;
p[n] = 0x80; //There is always room for one.
n++;
if (n > (MD4_SIZE_BLOCK - 8U))
{
memset(p + n, 0, MD4_SIZE_BLOCK - n);
n = 0;
MD4_BlockDataOrder(c, p, 1);
}
memset(p + n, 0, MD4_SIZE_BLOCK - 8U - n);
p += MD4_SIZE_BLOCK - 8U;
#if BYTE_ORDER == LITTLE_ENDIAN
(void)HOST_l2c(c->Nl, p);
(void)HOST_l2c(c->Nh, p);
#else
(void)HOST_l2c(c->Nh, p);
(void)HOST_l2c(c->Nl, p);
#endif
p -= MD4_SIZE_BLOCK;
MD4_BlockDataOrder(c, p, 1U);
c->Num = 0;
memset(p, 0, MD4_SIZE_BLOCK);
HASH_MAKE_STRING(c, md);
return;
}
int
GOSTR341194_Final(unsigned char *md, GOSTR341194_CTX * c)
{
unsigned char *p = (unsigned char *)c->data;
unsigned char T[32];
if (c->num > 0) {
memset(p + c->num, 0, 32);
hash_step(c, c->H, p);
add_blocks(32, c->S, p);
}
p = T;
HOST_l2c(c->Nl, p);
HOST_l2c(c->Nh, p);
memset(p, 0, 32 - 8);
hash_step(c, c->H, T);
hash_step(c, c->H, c->S);
memcpy(md, c->H, 32);
return 1;
}
/*****************************************
* sha256 compression function *
* *
* H points to chaining input *
* in points to the message input *
* *
*****************************************/
void sha256_comp (hashblock res, const hashblock hash, const void *in)
{
uint32_t a,b,c,d,e,f,g,h,s0,s1,T1,T2;
uint32_t H[8];
uint32_t X[16],l;
int i;
// CHANGE type casting added due to c++
const unsigned char *data=static_cast<const unsigned char*>(in);
for (i = 0; i < SHA256_DIGEST_LENGTH/4; i++) {
HOST_c2l(hash, H[i]);
}
a = H[0]; b = H[1]; c = H[2]; d = H[3];
e = H[4]; f = H[5]; g = H[6]; h = H[7];
for (i=0;i<16;i++)
{
HOST_c2l(data,l); T1 = X[i] = l;
T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i];
T2 = Sigma0(a) + Maj(a,b,c);
h = g;
g = f;
f = e;
e = d + T1;
d = c; c = b; b = a; a = T1 + T2;
}
for (;i<64;i++)
{
s0 = X[(i+1)&0x0f]; s0 = sigma0(s0);
s1 = X[(i+14)&0x0f]; s1 = sigma1(s1);
T1 = X[i&0xf] += s0 + s1 + X[(i+9)&0xf];
T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i];
T2 = Sigma0(a) + Maj(a,b,c);
h = g; g = f; f = e; e = d + T1;
d = c; c = b; b = a; a = T1 + T2;
}
H[0] += a; H[1] += b; H[2] += c; H[3] += d;
H[4] += e; H[5] += f; H[6] += g; H[7] += h;
for (i = 0; i < SHA256_DIGEST_LENGTH/4; i++) {
HOST_l2c(H[i], res);
}
}
