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;
}
int SHA256_Final (unsigned char *md, SHA256_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 > (SHA256_CBLOCK-8))
{
memset (p+n,0,SHA256_CBLOCK-n);
n=0;
sha256_block_data_order (c,p,1);
}
memset (p+n,0,SHA256_CBLOCK-8-n);
p += SHA256_CBLOCK-8;
(void)HOST_l2c(c->Nh,p);
(void)HOST_l2c(c->Nl,p);
p -= SHA256_CBLOCK;
sha256_block_data_order (c,p,1);
c->num=0;
memset (p,0,SHA256_CBLOCK);
HASH_MAKE_STRING(c,md);
return 1;
}
int SHA256_Update(SHA256_CTX *c, const void *data_, size_t len)
{
const unsigned char *data=(const unsigned char *)data_;
unsigned char *p;
SHA_LONG l;
size_t n;
if (len==0) return 1;
l=(c->Nl+(((SHA_LONG)len)<<3))&0xffffffffUL;
/* 95-05-24 eay Fixed a bug with the overflow handling, thanks to
* Wei Dai <*****@*****.**> for pointing it out. */
if (l < c->Nl) /* overflow */
c->Nh++;
c->Nh+=(SHA_LONG)(len>>29); /* might cause compiler warning on 16-bit */
c->Nl=l;
n = c->num;
if (n != 0)
{
p=(unsigned char *)c->data;
if (len >= SHA256_CBLOCK || len+n >= SHA256_CBLOCK)
{
memcpy (p+n,data,SHA256_CBLOCK-n);
sha256_block_data_order (c,p,1);
n = SHA256_CBLOCK-n;
data += n;
len -= n;
c->num = 0;
memset (p,0,SHA256_CBLOCK); /* keep it zeroed */
}
else
{
memcpy (p+n,data,len);
c->num += (unsigned int)len;
return 1;
}
}
n = len/SHA256_CBLOCK;
if (n > 0)
{
sha256_block_data_order (c,data,n);
n *= SHA256_CBLOCK;
data += n;
len -= n;
}
if (len != 0)
{
p = (unsigned char *)c->data;
c->num = (unsigned int)len;
memcpy (p,data,len);
}
return 1;
}
static void sha256_update(SHA256_CTX *c, const void *data, size_t len)
{
const unsigned char *ptr = data;
size_t res;
if ((res = c->num)) {
res = SHA256_CBLOCK - res;
if (len < res)
res = len;
SHA256_Update(c, ptr, res);
ptr += res;
len -= res;
}
res = len % SHA256_CBLOCK;
len -= res;
if (len) {
sha256_block_data_order(c, ptr, len / SHA256_CBLOCK);
ptr += len;
c->Nh += len >> 29;
c->Nl += len <<= 3;
if (c->Nl < (unsigned int)len)
c->Nh++;
}
if (res)
SHA256_Update(c, ptr, res);
}
void SHA256_Update (SHA256_CTX *c, const void *data_, size_t len) {
const unsigned char *data=data_;
unsigned char *p;
size_t n, fragment;
SHA256_addlength(c, len);
n = c->num;
p=c->data;
if (n != 0) {
fragment = SHA_CBLOCK-n;
if (len >= fragment) {
memcpy (p+n,data,fragment);
sha256_block_data_order (c,p);
data += fragment;
len -= fragment;
memset (p,0,SHA_CBLOCK); /* keep it zeroed */
}
else {
memcpy (p+n,data,len);
c->num = n+(unsigned int)len;
return;
}
}
while (len >= SHA_CBLOCK) {
sha256_block_data_order (c,data);
data += SHA_CBLOCK;
len -= SHA_CBLOCK;
}
c->num=len;
if (len != 0) {
memcpy (p,data,len);
}
return;
}
void SHA256_TransformBlocks(uint32_t state[8], const uint8_t *data,
size_t num_blocks) {
sha256_block_data_order(state, data, num_blocks);
}
void SHA256_Transform (SHA256_CTX *c, const unsigned char *data)
{
sha256_block_data_order (c,data,1);
}
