void sha256_process (sha256_state * md, const unsigned char *in, unsigned long inlen)
{
unsigned long n;
while (inlen > 0)
{
if (md->curlen == 0 && inlen >= 64)
{
sha256_compress (md, (unsigned char *)in);
md->length += 64 * 8;
in += 64;
inlen -= 64;
}
else
{
n = ( ((inlen)<((64 - md->curlen)))?(inlen):((64 - md->curlen)) );
memcpy(md->buf + md->curlen, in, (size_t)n);
md->curlen += n;
in += n;
inlen -= n;
if (md->curlen == 64)
{
sha256_compress (md, md->buf);
md->length += 8*64; md->curlen = 0;
}
}
}
}
int sha256_process(sha256_state * md, const unsigned char *in, unsigned long inlen)
{
unsigned long n;
int err;
if (md == NULL || in == NULL)
return -1;
if (md->curlen > sizeof(md->buf))
return -1;
while (inlen > 0) {
if (md->curlen == 0 && inlen >= SHA256_BLOCK_SIZE) {
if ((err = sha256_compress(md, (unsigned char *)in)) != 0) {
return err;
}
md->length += SHA256_BLOCK_SIZE * 8;
in += SHA256_BLOCK_SIZE;
inlen -= SHA256_BLOCK_SIZE;
} else {
n = MIN(inlen, (SHA256_BLOCK_SIZE - md->curlen));
tb_memcpy(md->buf + md->curlen, in, (size_t)n);
md->curlen += n;
in += n;
inlen -= n;
if (md->curlen == SHA256_BLOCK_SIZE) {
if ((err = sha256_compress(md, md->buf)) != 0) {
return err;
}
md->length += 8*SHA256_BLOCK_SIZE;
md->curlen = 0;
}
}
}
return 0;
}
/**
* Process a block of memory though the hash
* @param md The hash state
* @param in The data to hash
* @param inlen The length of the data (octets)
* @return CRYPT_OK if successful
*/
int sha256_process(struct sha256_state *md, const unsigned char *in,
unsigned long inlen)
{
unsigned long n;
if (md->curlen >= sizeof(md->buf))
return -1;
while (inlen > 0) {
if (md->curlen == 0 && inlen >= SHA256_BLOCK_SIZE) {
if (sha256_compress(md, (unsigned char *) in) < 0)
return -1;
md->length += SHA256_BLOCK_SIZE * 8;
in += SHA256_BLOCK_SIZE;
inlen -= SHA256_BLOCK_SIZE;
} else {
n = MIN(inlen, (SHA256_BLOCK_SIZE - md->curlen));
memcpy(md->buf + md->curlen, in, n);
md->curlen += n;
in += n;
inlen -= n;
if (md->curlen == SHA256_BLOCK_SIZE) {
if (sha256_compress(md, md->buf) < 0)
return -1;
md->length += 8 * SHA256_BLOCK_SIZE;
md->curlen = 0;
}
}
}
return 0;
}
/**
Process a block of memory though the hash
@param md The hash state
@param in The data to hash
@param inlen The length of the data (octets)
@return CRYPT_OK if successful
*/
int sha256_process (sha256_state * md, const unsigned char *in,
unsigned long inlen)
{
unsigned long n;
int err;
LTC_ARGCHK(md != NULL);
LTC_ARGCHK(in != NULL);
if (md->curlen > sizeof(md->buf)) {
return CRYPT_INVALID_ARG;
}
while (inlen > 0) {
if (md->curlen == 0 && inlen >= 64) {
if ((err = sha256_compress (md, (unsigned char *)in)) != CRYPT_OK) {
return err;
}
md->length += 64 * 8;
in += 64;
inlen -= 64;
} else {
n = MIN(inlen, (64 - md->curlen));
memcpy(md->buf + md->curlen, in, (size_t)n);
md->curlen += n;
in += n;
inlen -= n;
if (md->curlen == 64) {
if ((err = sha256_compress (md, md->buf)) != CRYPT_OK) {
return err;
}
md->length += 8*64;
md->curlen = 0;
}
}
}
return CRYPT_OK;
}
/*
Process a block of memory though the hash
@param in The data to hash
@param inlen The length of the data (octets)
*/
void SHA256::Update(const unsigned char *in, size_t inlen)
{
const size_t block_size = 64;
size_t n;
ASSERT(in != NULL || inlen == 0);
ASSERT(curlen <= sizeof(buf));
while (inlen > 0) {
if (curlen == 0 && inlen >= block_size) {
sha256_compress(state, in);
length += block_size * 8;
in += block_size;
inlen -= block_size;
} else {
n = std::min(inlen, (block_size - curlen));
memcpy(buf + curlen, in, static_cast<size_t>(n));
curlen += n;
in += n;
inlen -= n;
if (curlen == block_size) {
sha256_compress(state, buf);
length += 8*block_size;
curlen = 0;
}
}
}
}
/**
Terminate the hash to get the digest
@param md The hash state
@param out [out] The destination of the hash (32 bytes)
@return CRYPT_OK if successful
*/
static int SHA256_Final(unsigned char *out,
struct sha256_state *md)
{
int i;
if(md->curlen >= sizeof(md->buf))
return -1;
/* increase the length of the message */
md->length += md->curlen * 8;
/* append the '1' bit */
md->buf[md->curlen++] = (unsigned char)0x80;
/* if the length is currently above 56 bytes we append zeros
* then compress. Then we can fall back to padding zeros and length
* encoding like normal.
*/
if(md->curlen > 56) {
while(md->curlen < 64) {
md->buf[md->curlen++] = (unsigned char)0;
}
sha256_compress(md, md->buf);
md->curlen = 0;
}
/* pad upto 56 bytes of zeroes */
while(md->curlen < 56) {
md->buf[md->curlen++] = (unsigned char)0;
}
/* store length */
WPA_PUT_BE64(md->buf + 56, md->length);
sha256_compress(md, md->buf);
/* copy output */
for(i = 0; i < 8; i++)
WPA_PUT_BE32(out + (4 * i), md->state[i]);
return 0;
}
/**
Process a block of memory though the hash
@param md The hash state
@param in The data to hash
@param inlen The length of the data (octets)
@return CRYPT_OK if successful
*/
static int SHA256_Update(struct sha256_state *md,
const unsigned char *in,
unsigned long inlen)
{
unsigned long n;
#define block_size 64
if(md->curlen > sizeof(md->buf))
return -1;
while(inlen > 0) {
if(md->curlen == 0 && inlen >= block_size) {
if(sha256_compress(md, (unsigned char *)in) < 0)
return -1;
md->length += block_size * 8;
in += block_size;
inlen -= block_size;
}
else {
n = MIN(inlen, (block_size - md->curlen));
memcpy(md->buf + md->curlen, in, n);
md->curlen += n;
in += n;
inlen -= n;
if(md->curlen == block_size) {
if(sha256_compress(md, md->buf) < 0)
return -1;
md->length += 8 * block_size;
md->curlen = 0;
}
}
}
return 0;
}
/**
Terminate the hash to get the digest
@param md The hash state
@param out [out] The destination of the hash (32 bytes)
@param pScratchMem [in] Scratch memory; At least 288 bytes
@return CRYPT_OK if successful
*/
static int
sha256_done(void *priv, struct sha256_state *md, UINT8 *out, UINT8 *pScratchMem)
{
int i;
UINT32 *ptrU32;
UINT32 tmpU32;
if (md->curlen >= sizeof(md->buf)) {
return -1;
}
/* increase the length of the message */
md->length += md->curlen * 8;
/* append the '1' bit */
md->buf[md->curlen++] = (unsigned char)0x80;
/* if the length is currently above 56 bytes we append zeros then
compress. Then we can fall back to padding zeros and length
encoding like normal. */
if (md->curlen > 56) {
while (md->curlen < 64) {
md->buf[md->curlen++] = (unsigned char)0;
}
/* pScratchMem = At least 288 bytes of memory */
sha256_compress((void *)priv, md, md->buf, pScratchMem);
md->curlen = 0;
}
/* pad upto 56 bytes of zeroes */
while (md->curlen < 56) {
md->buf[md->curlen++] = (unsigned char)0;
}
/* store length */
ptrU32 = (UINT32 *)&md->length;
for (i = 0; i < 2; i++) {
tmpU32 = *ptrU32++;
WPA_PUT_BE32(md->buf + 60 - 4 * i, tmpU32);
}
/* pScratchMem = At least 288 bytes of memory */
sha256_compress((void *)priv, md, md->buf, pScratchMem);
ptrU32 = md->state;
/* copy output */
for (i = 8; i > 0; i--) {
tmpU32 = *ptrU32++;
WPA_PUT_BE32(out, tmpU32);
out += sizeof(UINT32);
}
return 0;
}
/**
Terminate the hash to get the digest
@param md The hash state
@param out [out] The destination of the hash (32 bytes)
@return CRYPT_OK if successful
*/
int sha256_done(hash_state * md, unsigned char *out)
{
int i;
LTC_ARGCHK(md != NULL);
LTC_ARGCHK(out != NULL);
if (md->sha256.curlen >= sizeof(md->sha256.buf)) {
return CRYPT_INVALID_ARG;
}
/* increase the length of the message */
md->sha256.length += md->sha256.curlen * 8;
/* append the '1' bit */
md->sha256.buf[md->sha256.curlen++] = (unsigned char)0x80;
/* if the length is currently above 56 bytes we append zeros
* then compress. Then we can fall back to padding zeros and length
* encoding like normal.
*/
if (md->sha256.curlen > 56) {
while (md->sha256.curlen < 64) {
md->sha256.buf[md->sha256.curlen++] = (unsigned char)0;
}
sha256_compress(md, md->sha256.buf);
md->sha256.curlen = 0;
}
/* pad upto 56 bytes of zeroes */
while (md->sha256.curlen < 56) {
md->sha256.buf[md->sha256.curlen++] = (unsigned char)0;
}
/* store length */
STORE64H(md->sha256.length, md->sha256.buf+56);
sha256_compress(md, md->sha256.buf);
/* copy output */
for (i = 0; i < 8; i++) {
STORE32H(md->sha256.state[i], out+(4*i));
}
#ifdef LTC_CLEAN_STACK
zeromem(md, sizeof(hash_state));
#endif
return CRYPT_OK;
}
void psSha256Update(psSha256_t *sha256, const unsigned char *buf, uint32_t len)
{
uint32 n;
#ifdef CRYPTO_ASSERT
psAssert(sha256 != NULL);
psAssert(buf != NULL);
#endif
while (len > 0) {
if (sha256->curlen == 0 && len >= 64) {
sha256_compress(sha256, (unsigned char *)buf);
#ifdef HAVE_NATIVE_INT64
sha256->length += 512;
#else
n = (sha256->lengthLo + 512) & 0xFFFFFFFFL;
if (n < sha256->lengthLo) {
sha256->lengthHi++;
}
sha256->lengthLo = n;
#endif /* HAVE_NATIVE_INT64 */
buf += 64;
len -= 64;
} else {
n = min(len, (64 - sha256->curlen));
memcpy(sha256->buf + sha256->curlen, buf, (size_t)n);
sha256->curlen += n;
buf += n;
len -= n;
if (sha256->curlen == 64) {
sha256_compress (sha256, sha256->buf);
#ifdef HAVE_NATIVE_INT64
sha256->length += 512;
#else
n = (sha256->lengthLo + 512) & 0xFFFFFFFFL;
if (n < sha256->lengthLo) {
sha256->lengthHi++;
}
sha256->lengthLo = n;
#endif /* HAVE_NATIVE_INT64 */
sha256->curlen = 0;
}
}
}
return;
}
void psSha256Update(psDigestContext_t *md, const unsigned char *buf, uint32 len)
{
uint32 n;
psAssert(md != NULL);
psAssert(buf != NULL);
while (len > 0) {
if (md->sha256.curlen == 0 && len >= 64) {
sha256_compress(md, (unsigned char *)buf);
#ifdef HAVE_NATIVE_INT64
md->sha256.length += 512;
#else
n = (md->sha256.lengthLo + 512) & 0xFFFFFFFFL;
if (n < md->sha256.lengthLo) {
md->sha256.lengthHi++;
}
md->sha256.lengthLo = n;
#endif /* HAVE_NATIVE_INT64 */
buf += 64;
len -= 64;
} else {
n = min(len, (64 - md->sha256.curlen));
memcpy(md->sha256.buf + md->sha256.curlen, buf, (size_t)n);
md->sha256.curlen += n;
buf += n;
len -= n;
if (md->sha256.curlen == 64) {
sha256_compress (md, md->sha256.buf);
#ifdef HAVE_NATIVE_INT64
md->sha256.length += 512;
#else
n = (md->sha256.lengthLo + 512) & 0xFFFFFFFFL;
if (n < md->sha256.lengthLo) {
md->sha256.lengthHi++;
}
md->sha256.lengthLo = n;
#endif /* HAVE_NATIVE_INT64 */
md->sha256.curlen = 0;
}
}
}
return;
}
/*
Terminate the hash to get the digest
@param digest The destination of the hash (32 bytes)
*/
void SHA256::Final(unsigned char digest[HASHLEN])
{
int i;
ASSERT(digest != NULL);
ASSERT(curlen < sizeof(buf));
/* increase the length of the message */
length += curlen * 8;
/* append the '1' bit */
buf[curlen++] = static_cast<unsigned char>(0x80);
/* if the length is currently above 56 bytes we append zeros
* then compress. Then we can fall back to padding zeros and length
* encoding like normal.
*/
if (curlen > 56) {
while (curlen < 64) {
buf[curlen++] = 0;
}
sha256_compress(state, buf);
curlen = 0;
}
/* pad upto 56 bytes of zeroes */
while (curlen < 56) {
buf[curlen++] = 0;
}
/* store length */
STORE64H(length, buf+56);
sha256_compress(state, buf);
/* copy output */
for (i = 0; i < 8; i++) {
STORE32H(state[i], digest+(4*i));
}
#ifdef LTC_CLEAN_STACK
trashMemory(state, sizeof(state));
trashMemory(buf, sizeof(buf));
#endif
}
/**
Terminate the hash to get the digest
@param md The hash state
@param out [out] The destination of the hash (32 bytes)
@return 0 if successful
*/
int sha256_done(sha256_state * md, unsigned char *out)
{
int i;
if (md == NULL || out == NULL)
return -1;
if (md->curlen >= sizeof(md->buf))
return -1;
/* increase the length of the message */
md->length += md->curlen * 8;
/* append the '1' bit */
md->buf[md->curlen++] = (unsigned char)0x80;
/* if the length is currently above 56 bytes we append zeros
* then compress. Then we can fall back to padding zeros and length
* encoding like normal.
*/
if (md->curlen > 56) {
while (md->curlen < 64) {
md->buf[md->curlen++] = (unsigned char)0;
}
sha256_compress(md, md->buf);
md->curlen = 0;
}
/* pad upto 56 bytes of zeroes */
while (md->curlen < 56) {
md->buf[md->curlen++] = (unsigned char)0;
}
/* store length */
STORE64H(md->length, md->buf+56);
sha256_compress(md, md->buf);
/* copy output */
for (i = 0; i < 8; i++) {
STORE32H(md->state[i], out+(4*i));
}
return 0;
}
/**
Process a block of memory though the hash
@param md The hash state
@param in The data to hash
@param inlen The length of the data (octets)
@param pScratchMem Temporary Memory Buf; At least 288 bytes.
@return CRYPT_OK if successful
*/
static int
sha256_process(void *priv, struct sha256_state *md,
const unsigned char *in, unsigned int inlen, UINT8 *pScratchMem)
{
phostsa_private psapriv = (phostsa_private)priv;
hostsa_util_fns *util_fns = &psapriv->util_fns;
unsigned int n;
#define block_size 64
if (md->curlen > sizeof(md->buf)) {
return -1;
}
while (inlen > 0) {
if (md->curlen == 0 && inlen >= block_size) {
/* pScratchMem = At least 288 bytes of memory */
if (sha256_compress
((void *)priv, md, (UINT8 *)in, pScratchMem) < 0) {
return -1;
}
md->length += block_size * 8;
in += block_size;
inlen -= block_size;
} else {
n = MIN(inlen, (block_size - md->curlen));
memcpy(util_fns, md->buf + md->curlen, in, n);
md->curlen += n;
in += n;
inlen -= n;
if (md->curlen == block_size) {
/* pScratchMem = At least 288 bytes of memory */
if (sha256_compress
((void *)priv, md, md->buf,
pScratchMem) < 0) {
return -1;
}
md->length += 8 * block_size;
md->curlen = 0;
}
}
}
return 0;
}
void tc_sha256_update(sha256_state* s, const uint8_t* data, size_t datalen) {
while (datalen-- > 0) {
s->leftover[s->leftover_offset++] = *(data++);
if (s->leftover_offset >= SHA256_BLOCK_SIZE) {
sha256_compress(s->iv, s->leftover);
s->leftover_offset = 0;
s->bits_hashed += (SHA256_BLOCK_SIZE << 3);
}
}
}
void tc_sha256_final(uint8_t* digest, sha256_state* s) {
unsigned int i;
s->bits_hashed += (s->leftover_offset << 3);
s->leftover[s->leftover_offset++] = 0x80; /* always room for one byte */
if (s->leftover_offset > (sizeof(s->leftover) - 8)) {
/* there is not room for all the padding in this block */
(void)memset(s->leftover + s->leftover_offset, 0x00,
sizeof(s->leftover) - s->leftover_offset);
sha256_compress(s->iv, s->leftover);
s->leftover_offset = 0;
}
/* add the padding and the length in big-Endian format */
(void)memset(s->leftover + s->leftover_offset, 0x00,
sizeof(s->leftover) - 8 - s->leftover_offset);
s->leftover[sizeof(s->leftover) - 1] = (uint8_t)(s->bits_hashed);
s->leftover[sizeof(s->leftover) - 2] = (uint8_t)(s->bits_hashed >> 8);
s->leftover[sizeof(s->leftover) - 3] = (uint8_t)(s->bits_hashed >> 16);
s->leftover[sizeof(s->leftover) - 4] = (uint8_t)(s->bits_hashed >> 24);
s->leftover[sizeof(s->leftover) - 5] = (uint8_t)(s->bits_hashed >> 32);
s->leftover[sizeof(s->leftover) - 6] = (uint8_t)(s->bits_hashed >> 40);
s->leftover[sizeof(s->leftover) - 7] = (uint8_t)(s->bits_hashed >> 48);
s->leftover[sizeof(s->leftover) - 8] = (uint8_t)(s->bits_hashed >> 56);
/* hash the padding and length */
sha256_compress(s->iv, s->leftover);
/* copy the iv out to digest */
for (i = 0; i < SHA256_STATE_BLOCKS; ++i) {
unsigned int t = *((unsigned int*)&s->iv[i]);
*digest++ = (uint8_t)(t >> 24);
*digest++ = (uint8_t)(t >> 16);
*digest++ = (uint8_t)(t >> 8);
*digest++ = (uint8_t)(t);
}
/* destroy the current state */
(void)memset(s, 0, sizeof(*s));
}
void sha224_hash(const uint8_t *message, uint32_t len, uint32_t hash[7]) {
uint32_t state[8] = {
UINT32_C(0xC1059ED8),
UINT32_C(0x367CD507),
UINT32_C(0x3070DD17),
UINT32_C(0xF70E5939),
UINT32_C(0xFFC00B31),
UINT32_C(0x68581511),
UINT32_C(0x64F98FA7),
UINT32_C(0xBEFA4FA4),
};
uint32_t i;
for (i = 0; len - i >= 64; i += 64)
sha256_compress(state, message + i);
uint8_t block[64];
uint32_t rem = len - i;
memcpy(block, message + i, rem);
block[rem] = 0x80;
rem++;
if (64 - rem >= 8)
memset(block + rem, 0, 56 - rem);
else {
memset(block + rem, 0, 64 - rem);
sha256_compress(state, block);
memset(block, 0, 56);
}
uint64_t longLen = ((uint64_t)len) << 3;
for (i = 0; i < 8; i++)
block[64 - 1 - i] = (uint8_t)(longLen >> (i * 8));
sha256_compress(state, block);
memcpy(hash, state, 7 * sizeof(uint32_t));
}
int main(int argc, char **argv) {
if (!self_check()) {
printf("Self-check failed\n");
return 1;
}
printf("Self-check passed\n");
// Benchmark speed
uint32_t state[8] = {};
uint32_t block[16] = {};
const int N = 3000000;
clock_t start_time = clock();
int i;
for (i = 0; i < N; i++)
sha256_compress(state, (uint8_t *)block); // Type-punning
printf("Speed: %.1f MiB/s\n", (double)N * sizeof(block) / (clock() - start_time) * CLOCKS_PER_SEC / 1048576);
return 0;
}
int main(void) {
// Self-check
if (!self_check()) {
printf("Self-check failed\n");
return EXIT_FAILURE;
}
printf("Self-check passed\n");
// Benchmark speed
uint32_t state[STATE_LEN] = {0};
uint8_t block[BLOCK_LEN] = {0};
const long ITERS = 3000000;
clock_t start_time = clock();
for (long i = 0; i < ITERS; i++)
sha256_compress(state, block);
printf("Speed: %.1f MB/s\n", (double)ITERS * (sizeof(block) / sizeof(block[0]))
/ (clock() - start_time) * CLOCKS_PER_SEC / 1000000);
return EXIT_SUCCESS;
}
void sha256_process(hash_state * md, const unsigned char *buf, unsigned long len)
{
unsigned long n;
_ARGCHK(md != NULL);
_ARGCHK(buf != NULL);
while (len > 0) {
n = MIN(len, (64 - md->sha256.curlen));
memcpy(md->sha256.buf + md->sha256.curlen, buf, (size_t)n);
md->sha256.curlen += n;
buf += n;
len -= n;
/* is 64 bytes full? */
if (md->sha256.curlen == 64) {
sha256_compress(md);
md->sha256.length += 512;
md->sha256.curlen = 0;
}
}
}
void psSha256Final(psSha256_t *sha256, unsigned char hash[SHA256_HASHLEN])
{
int32 i;
#ifndef HAVE_NATIVE_INT64
uint32 n;
#endif
#ifdef CRYPTO_ASSERT
psAssert(sha256 != NULL);
psAssert(hash != NULL);
if (sha256->curlen >= sizeof(sha256->buf)) {
psTraceCrypto("psSha256Final error\n");
return;
}
#endif
/* increase the length of the message */
#ifdef HAVE_NATIVE_INT64
sha256->length += sha256->curlen << 3;
#else
n = (sha256->lengthLo + (sha256->curlen << 3)) & 0xFFFFFFFFL;
if (n < sha256->lengthLo) {
sha256->lengthHi++;
}
sha256->lengthHi += (sha256->curlen >> 29);
sha256->lengthLo = n;
#endif /* HAVE_NATIVE_INT64 */
/* append the '1' bit */
sha256->buf[sha256->curlen++] = (unsigned char)0x80;
/*
if the length is currently above 56 bytes we append zeros then compress.
Then we can fall back to padding zeros and length encoding like normal.
*/
if (sha256->curlen > 56) {
while (sha256->curlen < 64) {
sha256->buf[sha256->curlen++] = (unsigned char)0;
}
sha256_compress(sha256, sha256->buf);
sha256->curlen = 0;
}
/* pad upto 56 bytes of zeroes */
while (sha256->curlen < 56) {
sha256->buf[sha256->curlen++] = (unsigned char)0;
}
/* store length */
#ifdef HAVE_NATIVE_INT64
STORE64H(sha256->length, sha256->buf+56);
#else
STORE32H(sha256->lengthHi, sha256->buf+56);
STORE32H(sha256->lengthLo, sha256->buf+60);
#endif /* HAVE_NATIVE_INT64 */
sha256_compress(sha256, sha256->buf);
/* copy output */
for (i = 0; i < 8; i++) {
STORE32H(sha256->state[i], hash+(4*i));
}
memset(sha256, 0x0, sizeof(psSha256_t));
}
int32 psSha256Final(psDigestContext_t * md, unsigned char *hash)
{
int32 i;
#ifndef HAVE_NATIVE_INT64
uint32 n;
#endif
psAssert(md != NULL);
psAssert(hash != NULL);
if (md->sha256.curlen >= sizeof(md->sha256.buf)) {
psTraceCrypto("psSha256Final error\n");
return PS_ARG_FAIL;
}
/*
increase the length of the message
*/
#ifdef HAVE_NATIVE_INT64
md->sha256.length += md->sha256.curlen << 3;
#else
n = (md->sha256.lengthLo + (md->sha256.curlen << 3)) & 0xFFFFFFFFL;
if (n < md->sha256.lengthLo) {
md->sha256.lengthHi++;
}
md->sha256.lengthHi += (md->sha256.curlen >> 29);
md->sha256.lengthLo = n;
#endif /* HAVE_NATIVE_INT64 */
/*
append the '1' bit
*/
md->sha256.buf[md->sha256.curlen++] = (unsigned char)0x80;
/*
if the length is currently above 56 bytes we append zeros then compress.
Then we can fall back to padding zeros and length encoding like normal.
*/
if (md->sha256.curlen > 56) {
while (md->sha256.curlen < 64) {
md->sha256.buf[md->sha256.curlen++] = (unsigned char)0;
}
sha256_compress(md, md->sha256.buf);
md->sha256.curlen = 0;
}
/*
pad upto 56 bytes of zeroes
*/
while (md->sha256.curlen < 56) {
md->sha256.buf[md->sha256.curlen++] = (unsigned char)0;
}
/*
store length
*/
#ifdef HAVE_NATIVE_INT64
STORE64H(md->sha256.length, md->sha256.buf+56);
#else
STORE32H(md->sha256.lengthHi, md->sha256.buf+56);
STORE32H(md->sha256.lengthLo, md->sha256.buf+60);
#endif /* HAVE_NATIVE_INT64 */
sha256_compress(md, md->sha256.buf);
/*
copy output
*/
for (i = 0; i < 8; i++) {
STORE32H(md->sha256.state[i], hash+(4*i));
}
memset(md, 0x0, sizeof(psDigestContext_t));
return SHA256_HASH_SIZE;
}
