/*
* Entropy accumulator update
*/
static int entropy_update( entropy_context *ctx, unsigned char source_id,
const unsigned char *data, size_t len )
{
unsigned char header[2];
unsigned char tmp[ENTROPY_BLOCK_SIZE];
size_t use_len = len;
const unsigned char *p = data;
if( use_len > ENTROPY_BLOCK_SIZE )
{
#if defined(POLARSSL_ENTROPY_SHA512_ACCUMULATOR)
sha512( data, len, tmp, 0 );
#else
sha256( data, len, tmp, 0 );
#endif
p = tmp;
use_len = ENTROPY_BLOCK_SIZE;
}
header[0] = source_id;
header[1] = use_len & 0xFF;
#if defined(POLARSSL_ENTROPY_SHA512_ACCUMULATOR)
sha512_update( &ctx->accumulator, header, 2 );
sha512_update( &ctx->accumulator, p, use_len );
#else
sha256_update( &ctx->accumulator, header, 2 );
sha256_update( &ctx->accumulator, p, use_len );
#endif
return( 0 );
}
static void calculate_hmac(uint8_t key[32],
char* buf, size_t len, uint8_t res[32]){
int i;
uint8_t hmacbuf[32];
uint8_t hmac_keybuf[64];
sha256_context sc;
for (i = 0; i < 32; i++){
hmac_keybuf[i] = key[i] ^ 0x36;
}
memset(hmac_keybuf + 32, 0x36, 32);
sha256_starts(&sc);
sha256_update(&sc, hmac_keybuf, 32);
sha256_update(&sc, buf, len);
sha256_finish(&sc, hmacbuf);
for (i = 0; i < 32; i++){
hmac_keybuf[i] = key[i] ^ 0x5c;
}
memset(hmac_keybuf + 32, 0x5c, 32);
sha256_starts(&sc);
sha256_update(&sc, hmac_keybuf, 32);
sha256_update(&sc, hmacbuf, 32);
sha256_finish(&sc, res);
}
void do_gpu_sha(){
int i;
uint32_t digest[8*STRIDE];
uint32_t block[20*STRIDE] = {0};
block[(72/4)*STRIDE] = 0x9FEF014;
block[(76/4)*STRIDE] = 0x2a400100;
sha256cl_context ctx;
sha256_init(0,&ctx);
sha256_starts(0,&ctx);
sha256_update(0,&ctx,block,80);
sha256_finish(0,&ctx,digest);
for(i=0; i < 8; i++)
printf("%8.8X",D_REF(digest,7-i,0));
printf("\n");
sha256_starts(0,&ctx);
sha256_update(0,&ctx,digest,32);
sha256_finish(0,&ctx,digest);
for(i=0; i < 8; i++)
printf("%8.8X",D_REF(digest,7-i,0));
printf("\n");
}
int main()
{
unsigned char text1[]={"abc"},
text2[]={"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"},
text3[]={"aaaaaaaaaa"},
hash[32];
int idx;
SHA256_CTX ctx;
// Hash one
sha256_init(&ctx);
sha256_update(&ctx,text1,strlen(text1));
sha256_final(&ctx,hash);
print_hash(hash);
// Hash two
sha256_init(&ctx);
sha256_update(&ctx,text2,strlen(text2));
sha256_final(&ctx,hash);
print_hash(hash);
// Hash three
sha256_init(&ctx);
for (idx=0; idx < 100000; ++idx)
sha256_update(&ctx,text3,strlen(text3));
sha256_final(&ctx,hash);
print_hash(hash);
getchar();
return 0;
}
static void
yarrow_iterate(uint8_t *digest)
{
uint8_t v0[SHA256_DIGEST_SIZE];
unsigned i;
memcpy(v0, digest, SHA256_DIGEST_SIZE);
/* When hashed inside the loop, i should run from 1 to
* YARROW_RESEED_ITERATIONS */
for (i = 0; ++i < YARROW_RESEED_ITERATIONS; )
{
uint8_t count[4];
struct sha256_ctx hash;
sha256_init(&hash);
/* Hash v_i | v_0 | i */
WRITE_UINT32(count, i);
sha256_update(&hash, SHA256_DIGEST_SIZE, digest);
sha256_update(&hash, sizeof(v0), v0);
sha256_update(&hash, sizeof(count), count);
sha256_digest(&hash, SHA256_DIGEST_SIZE, digest);
}
}
/*
* \brief Computes the master secret.
*
* \param ps The premaster secret.
* \param client_random The random value from the client hello.
* \param server_random The random value from the server hello.
* \param master_secret A pointer to the final value of the master secret.
* Write the end result here.
*/
void
compute_master_secret(int ps, int client_random, int server_random, char *master_secret)
{
SHA256_CTX ctx;
sha256_init(&ctx);
unsigned char data[sizeof(int)];
unsigned char data1[sizeof(int)];
unsigned char data2[sizeof(int)];
unsigned char data3[sizeof(int)];
char master_secret0[16], master_secret1[16], master_secret2[16], master_secret3[16];
memcpy(data, &ps, sizeof(ps));
sha256_update(&ctx, data, (int) sizeof(data));
memcpy(data1, &client_random, sizeof(client_random));
sha256_update(&ctx, data1, (int) sizeof(data1));
memcpy(data2, &server_random, sizeof(server_random));
sha256_update(&ctx, data2, (int) sizeof(data2));
memcpy(data3, &ps, sizeof(ps));
sha256_update(&ctx, data3, (int) sizeof(data3));
sha256_final(&ctx, (unsigned char*) master_secret);
}
void
hmac_sha256_init(hmac_sha256_ctx *ctx, const void *key, size_t keylen)
{
uint8_t keybuf[SHA256_BLOCK_LEN], pad[SHA256_BLOCK_LEN];
/* prepare key */
memset(keybuf, 0, sizeof keybuf);
if (keylen > sizeof keybuf)
sha256_complete(key, keylen, keybuf);
else
memcpy(keybuf, key, keylen);
/* input pad */
for (unsigned int i = 0; i < sizeof pad; ++i)
pad[i] = 0x36 ^ keybuf[i];
sha256_init(&ctx->ictx);
sha256_update(&ctx->ictx, pad, sizeof pad);
/* output pad */
for (unsigned int i = 0; i < sizeof pad; ++i)
pad[i] = 0x5c ^ keybuf[i];
sha256_init(&ctx->octx);
sha256_update(&ctx->octx, pad, sizeof pad);
/* hide the evidence */
memset(keybuf, 0, sizeof keybuf);
memset(pad, 0, sizeof pad);
}
void hmac(char* key,char* m,char len,char* buf){
SHA256_CTX ctx;
BYTE concat[130];
BYTE o_key_pad[65];
BYTE i_key_pad[65];
memset(o_key_pad,0,sizeof o_key_pad);
memset(i_key_pad,0,sizeof i_key_pad);
memcpy(o_key_pad,key,SHA256_BLOCK_SIZE);
memcpy(i_key_pad,key,SHA256_BLOCK_SIZE);
for(char i=0;i<64;i++){
o_key_pad[i]^=0x5c;
i_key_pad[i]^=0x36;
}
memset(concat,0,sizeof concat);
memcpy(concat,i_key_pad,64);
memcpy(concat+64,m,len);
sha256_init(&ctx);
sha256_update(&ctx, concat, 64+len);
sha256_final(&ctx, buf);
memset(concat,0,sizeof concat);
memcpy(concat,o_key_pad,64);
memcpy(concat+64,buf,SHA256_BLOCK_SIZE);
sha256_init(&ctx);
sha256_update(&ctx, concat, 64+SHA256_BLOCK_SIZE);
sha256_final(&ctx, buf);
}
/*********************** FUNCTION DEFINITIONS ***********************/
void sha256_test()
{
BYTE text1[] = {"abc"};
BYTE text2[] = {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"};
BYTE text3[] = {"aaaaaaaaaa"};
BYTE hash1[SHA256_BLOCK_SIZE] = {0xba,0x78,0x16,0xbf,0x8f,0x01,0xcf,0xea,0x41,0x41,0x40,0xde,0x5d,0xae,0x22,0x23,
0xb0,0x03,0x61,0xa3,0x96,0x17,0x7a,0x9c,0xb4,0x10,0xff,0x61,0xf2,0x00,0x15,0xad};
BYTE hash2[SHA256_BLOCK_SIZE] = {0x24,0x8d,0x6a,0x61,0xd2,0x06,0x38,0xb8,0xe5,0xc0,0x26,0x93,0x0c,0x3e,0x60,0x39,
0xa3,0x3c,0xe4,0x59,0x64,0xff,0x21,0x67,0xf6,0xec,0xed,0xd4,0x19,0xdb,0x06,0xc1};
BYTE hash3[SHA256_BLOCK_SIZE] = {0xcd,0xc7,0x6e,0x5c,0x99,0x14,0xfb,0x92,0x81,0xa1,0xc7,0xe2,0x84,0xd7,0x3e,0x67,
0xf1,0x80,0x9a,0x48,0xa4,0x97,0x20,0x0e,0x04,0x6d,0x39,0xcc,0xc7,0x11,0x2c,0xd0};
BYTE buf[SHA256_BLOCK_SIZE];
SHA256_CTX ctx;
int idx;
sha256_init(&ctx);
sha256_update(&ctx, text1, strlen((char *)text1));
sha256_final(&ctx, buf);
ok (!memcmp(hash1, buf, SHA256_BLOCK_SIZE),
"text1 OK");
sha256_init(&ctx);
sha256_update(&ctx, text2, strlen((char *)text2));
sha256_final(&ctx, buf);
ok (!memcmp(hash2, buf, SHA256_BLOCK_SIZE),
"text2 OK");
sha256_init(&ctx);
for (idx = 0; idx < 100000; ++idx)
sha256_update(&ctx, text3, strlen((char *)text3));
sha256_final(&ctx, buf);
ok (!memcmp(hash3, buf, SHA256_BLOCK_SIZE),
"text3 OK");
}
void mgf1_sha256(uint8_t *seed, size_t seedLen, size_t maskLen, uint8_t *out) {
SHA256_CTX base, ctrhash;
sha256_init(&base);
sha256_update(&base, seed, seedLen);
uint8_t ctrbuf[4];
uint8_t hashbuf[32];
uint64_t ctr;
for(ctr = 0; ctr < maskLen; ctr+=32) {
memcpy(&ctrhash, &base, sizeof(SHA256_CTX));
encbe32(ctr / 32, ctrbuf);
sha256_update(&ctrhash, ctrbuf, 4);
sha256_final(&ctrhash, hashbuf);
if(maskLen - ctr < 32) {
memcpy(&out[ctr], hashbuf, maskLen - ctr);
} else {
memcpy(&out[ctr], hashbuf, 32);
}
}
memsets(&base, 0, sizeof(SHA256_CTX));
memsets(&ctrhash, 0, sizeof(SHA256_CTX));
memsets(ctrbuf, 0, 4);
memsets(hashbuf, 0, 32);
}
static void
yarrow_iterate(quint8 *digest)
{
quint8 v0[SHA256_DIGEST_SIZE];
unsigned i;
memcpy(v0, digest, SHA256_DIGEST_SIZE);
/* When hashed inside the loop, i should run from 1 to
* YARROW_RESEED_ITERATIONS */
for (i = 0; ++i < YARROW_RESEED_ITERATIONS; )
{
quint8 count[4];
sha256_context hash;
sha256_starts(&hash);
/* Hash v_i | v_0 | i */
WRITE_UINT32(count, i);
sha256_update(&hash, digest, SHA256_DIGEST_SIZE);
sha256_update(&hash, v0, sizeof(v0));
sha256_update(&hash, count, sizeof(count));
sha256_finish(&hash,digest);
}
}
uint64_t xdag_hash_final_multi(void *ctxv, uint64_t *nonce, int attempts, int step, xdag_hash_t hash)
{
SHA256REF_CTX ctx;
xdag_hash_t hash0;
uint64_t min_nonce = 0;
int i;
for (i = 0; i < attempts; ++i) {
memcpy(&ctx, ctxv, sizeof(ctx));
sha256_update(&ctx, (uint8_t*)nonce, sizeof(uint64_t));
sha256_final(&ctx, (uint8_t*)hash0);
sha256_init(&ctx);
sha256_update(&ctx, (uint8_t*)hash0, sizeof(xdag_hash_t));
sha256_final(&ctx, (uint8_t*)hash0);
if (!i || xdag_cmphash(hash0, hash) < 0) {
memcpy(hash, hash0, sizeof(xdag_hash_t));
min_nonce = *nonce;
}
*nonce += step;
}
return min_nonce;
}
static int sha256_final(struct shash_desc *desc, u8 *out)
{
struct sha256_state *sctx = shash_desc_ctx(desc);
__be32 *dst = (__be32 *)out;
__be64 bits;
unsigned int index, pad_len;
int i;
static const u8 padding[64] = { 0x80, };
/* Save number of bits */
bits = cpu_to_be64(sctx->count << 3);
/* Pad out to 56 mod 64. */
index = sctx->count & 0x3f;
pad_len = (index < 56) ? (56 - index) : ((64+56) - index);
sha256_update(desc, padding, pad_len);
/* Append length (before padding) */
sha256_update(desc, (const u8 *)&bits, sizeof(bits));
/* Store state in digest */
for (i = 0; i < 8; i++)
dst[i] = cpu_to_be32(sctx->state[i]);
/* Zeroize sensitive information. */
memset(sctx, 0, sizeof(*sctx));
return 0;
}
void bitclient_generateTxHash(uint32 nonce1, uint32 userExtraNonceLength, uint8* userExtraNonce, uint32 coinBase1Length, uint8* coinBase1, uint32 coinBase2Length, uint8* coinBase2, uint8* txHash)
{
stream_t* streamTXData = streamEx_fromDynamicMemoryRange(1024*32);
stream_writeData(streamTXData, coinBase1, coinBase1Length);
stream_writeData(streamTXData, &nonce1, 4);
stream_writeData(streamTXData, userExtraNonce, userExtraNonceLength);
stream_writeData(streamTXData, coinBase2, coinBase2Length);
sint32 transactionDataLength = 0;
uint8* transactionData = (uint8*)streamEx_map(streamTXData, &transactionDataLength);
// special case, we can use the hash of the transaction
#if 0
int i;
printf("Merkle:\n");
for(i=0; i < transactionDataLength; i++){
printf("%2.2x ", transactionData[i]);
}
printf("\n");
#endif
uint8 hashOut[32];
sha256_context sctx;
sha256_starts(&sctx);
sha256_update(&sctx, transactionData, transactionDataLength);
sha256_finish(&sctx, hashOut);
sha256_starts(&sctx);
sha256_update(&sctx, hashOut, 32);
sha256_finish(&sctx, txHash);
free(transactionData);
stream_destroy(streamTXData);
}
void testHash()
{
unsigned char Digest[32];
sha256_context ctx;
sha256_init( &ctx );
sha256_starts( &ctx, 0 );
sha256_update( &ctx, sha256_test_buf[0], sha256_test_buflen[0] );
sha256_finish( &ctx, Digest );
print_buffer(Digest, sizeof(Digest));
memset(Digest, 0, sizeof(Digest));
uint8 buffer[1];
sha256_init( &ctx );
sha256_starts( &ctx, 0 );
buffer[0] = 'a';
sha256_update( &ctx, buffer, 1 );
buffer[0] = 'b';
sha256_update( &ctx, buffer, 1 );
buffer[0] = 'c';
sha256_update( &ctx, buffer, 1 );
buffer[0] = '\0';
sha256_update( &ctx, buffer, 1 );
sha256_finish( &ctx, Digest );
print_buffer(Digest, sizeof(Digest));
}
void protoshares_process_8(minerProtosharesBlock_t* block)
{
// generate mid hash using sha256 (header hash)
uint8 midHash[32];
sha256_ctx c256;
sha256_init(&c256);
sha256_update(&c256, (unsigned char*)block, 80);
sha256_final(&c256, midHash);
sha256_init(&c256);
sha256_update(&c256, (unsigned char*)midHash, 32);
sha256_final(&c256, midHash);
// init collision map
if( __collisionMap == NULL )
__collisionMap = (uint32*)malloc(sizeof(uint32)*COLLISION_TABLE_SIZE);
uint32* collisionIndices = __collisionMap;
memset(collisionIndices, 0x00, sizeof(uint32)*COLLISION_TABLE_SIZE);
// start search
// uint8 midHash[64];
uint8 tempHash[32+4];
sha512_ctx c512;
uint64 resultHashStorage[8*CACHED_HASHES];
memcpy(tempHash+4, midHash, 32);
for(uint32 n=0; n<MAX_MOMENTUM_NONCE; n += BIRTHDAYS_PER_HASH * CACHED_HASHES)
{
if( block->height != monitorCurrentBlockHeight )
break;
for(uint32 m=0; m<CACHED_HASHES; m++)
{
sha512_init(&c512);
*(uint32*)tempHash = n+m*8;
sha512_update_final(&c512, tempHash, 32+4, (unsigned char*)(resultHashStorage+8*m));
}
for(uint32 m=0; m<CACHED_HASHES; m++)
{
uint64* resultHash = resultHashStorage + 8*m;
uint32 i = n + m*8;
for(uint32 f=0; f<8; f++)
{
uint64 birthday = resultHash[f] >> (64ULL-SEARCH_SPACE_BITS);
uint32 collisionKey = (uint32)((birthday>>18) & COLLISION_KEY_MASK);
birthday %= COLLISION_TABLE_SIZE;
if( collisionIndices[birthday] )
{
if( ((collisionIndices[birthday]&COLLISION_KEY_MASK) != collisionKey) || protoshares_revalidateCollision(block, midHash, collisionIndices[birthday]&~COLLISION_KEY_MASK, i+f) == false )
{
// invalid collision -> ignore
}
}
collisionIndices[birthday] = i+f | collisionKey; // we have 6 bits available for validation
}
}
}
}
void xdag_hash_final(void *ctxv, void *data, size_t size, xdag_hash_t hash)
{
SHA256REF_CTX ctx;
memcpy(&ctx, ctxv, sizeof(ctx));
sha256_update(&ctx, (uint8_t*)data, size);
sha256_final(&ctx, (uint8_t*)hash);
sha256_init(&ctx);
sha256_update(&ctx, (uint8_t*)hash, sizeof(xdag_hash_t));
sha256_final(&ctx, (uint8_t*)hash);
}
void xdag_hash(void *data, size_t size, xdag_hash_t hash)
{
SHA256REF_CTX ctx;
sha256_init(&ctx);
sha256_update(&ctx, data, size);
sha256_final(&ctx, (uint8_t*)hash);
sha256_init(&ctx);
sha256_update(&ctx, (uint8_t*)hash, sizeof(xdag_hash_t));
sha256_final(&ctx, (uint8_t*)hash);
}
/* Direct mapping from MD5 example in RFC2104 */
void hmac_sha256(struct hmac_sha256 *hmac,
const void *key, size_t key_len,
const void *text, size_t text_len)
{
struct sha256_ctx context;
unsigned char k_ipad[65]; /* inner padding -
* key XORd with ipad
*/
unsigned char k_opad[65]; /* outer padding -
* key XORd with opad
*//* start out by storing key in pads */
unsigned char tk[32];
int i;
/* if key is longer than 64 bytes reset it to key=MD5(key) */
if (key_len > 64) {
struct sha256_ctx tctx;
sha256_init(&tctx);
sha256_update(&tctx, key, key_len);
sha256_done(&tctx, tk);
key = tk;
key_len = 32;
}
bzero( k_ipad, sizeof k_ipad);
bzero( k_opad, sizeof k_opad);
bcopy( key, k_ipad, key_len);
bcopy( key, k_opad, key_len);
/* XOR key with ipad and opad values */
for (i=0; i<64; i++) {
k_ipad[i] ^= 0x36;
k_opad[i] ^= 0x5c;
}
/*
* perform inner MD5
*/
sha256_init(&context); /* init context for 1st
* pass */
sha256_update(&context, k_ipad, 64); /* start with inner pad */
sha256_update(&context, text, text_len); /* then text of datagram */
sha256_done(&context, &hmac->sha); /* finish up 1st pass */
/*
* perform outer MD5
*/
sha256_init(&context); /* init context for 2nd
* pass */
sha256_update(&context, k_opad, 64); /* start with outer pad */
sha256_update(&context, &hmac->sha, 32); /* then results of 1st
* hash */
sha256_done(&context, &hmac->sha); /* finish up 2nd pass */
}
static int hash_match(const struct regex_matcher *rlist, const char *host, size_t hlen, const char *path, size_t plen, int *prefix_matched)
{
const char *virname;
#if 0
char s[1024];
strncpy(s, host, hlen);
strncpy(s+hlen, path, plen);
s[hlen+plen] = '\0';
cli_dbgmsg("hash lookup for: %s\n",s);
#endif
if(rlist->sha256_hashes.bm_patterns) {
const char hexchars[] = "0123456789ABCDEF";
unsigned char h[65];
unsigned char sha256_dig[32];
unsigned i;
SHA256_CTX sha256;
sha256_init(&sha256);
sha256_update(&sha256, host, hlen);
sha256_update(&sha256, path, plen);
sha256_final(&sha256, sha256_dig);
for(i=0;i<32;i++) {
h[2*i] = hexchars[sha256_dig[i]>>4];
h[2*i+1] = hexchars[sha256_dig[i]&0xf];
}
h[64]='\0';
cli_dbgmsg("Looking up hash %s for %s(%u)%s(%u)\n", h, host, (unsigned)hlen, path, (unsigned)plen);
#if 0
if (prefix_matched) {
if (cli_bm_scanbuff(sha256_dig, 4, &virname, NULL, &rlist->hostkey_prefix,0,NULL,NULL,NULL) == CL_VIRUS) {
cli_dbgmsg("prefix matched\n");
*prefix_matched = 1;
} else
return CL_SUCCESS;
}
#endif
if (cli_bm_scanbuff(sha256_dig, 32, &virname, NULL, &rlist->sha256_hashes,0,NULL,NULL,NULL) == CL_VIRUS) {
cli_dbgmsg("This hash matched: %s\n", h);
switch(*virname) {
case 'W':
cli_dbgmsg("Hash is whitelisted, skipping\n");
break;
case '1':
return CL_PHISH_HASH1;
case '2':
return CL_PHISH_HASH2;
default:
return CL_PHISH_HASH0;
}
}
}
return CL_SUCCESS;
}
/* BOLT #1:
* * sending-key: SHA256(shared-secret || sending-node-session-pubkey)
* * receiving-key: SHA256(shared-secret || receiving-node-session-pubkey)
*/
static struct enckey enckey_from_secret(const unsigned char secret[32],
const unsigned char serial_pubkey[33])
{
struct sha256_ctx ctx;
struct enckey enckey;
sha256_init(&ctx);
sha256_update(&ctx, memcheck(secret, 32), 32);
sha256_update(&ctx, memcheck(serial_pubkey, 33), 33);
sha256_done(&ctx, &enckey.k);
return enckey;
}
void heavycoin_hash(const char* input, int len, char* output)
{
unsigned char hash1[32];
HEFTY1((unsigned char *)input, len, hash1);
/* HEFTY1 is new, so take an extra security measure to eliminate
* the possiblity of collisions:
*
* Hash(x) = SHA256(x + HEFTY1(x))
*
* N.B. '+' is concatenation.
*/
unsigned char hash2[32];;
sha256_ctx ctx;
sha256_init(&ctx);
sha256_update(&ctx, (const unsigned char *)input, len);
sha256_update(&ctx, hash1, sizeof(hash1));
sha256_final(&ctx, hash2);
/* Additional security: Do not rely on a single cryptographic hash
* function. Instead, combine the outputs of 4 of the most secure
* cryptographic hash functions-- SHA256, KECCAK512, GROESTL512
* and BLAKE512.
*/
uint32_t hash3[16];
sph_keccak512_context keccakCtx;
sph_keccak512_init(&keccakCtx);
sph_keccak512(&keccakCtx, input, len);
sph_keccak512(&keccakCtx, hash1, sizeof(hash1));
sph_keccak512_close(&keccakCtx, (void *)&hash3);
uint32_t hash4[16];
sph_groestl512_context groestlCtx;
sph_groestl512_init(&groestlCtx);
sph_groestl512(&groestlCtx, input, len);
sph_groestl512(&groestlCtx, hash1, sizeof(hash1));
sph_groestl512_close(&groestlCtx, (void *)&hash4);
uint32_t hash5[16];
sph_blake512_context blakeCtx;
sph_blake512_init(&blakeCtx);
sph_blake512(&blakeCtx, input, len);
sph_blake512(&blakeCtx, (unsigned char *)&hash1, sizeof(hash1));
sph_blake512_close(&blakeCtx, (void *)&hash5);
uint32_t *final = (uint32_t *)output;
combine_hashes(final, (uint32_t *)hash2, hash3, hash4, hash5);
}
static void _update_sha256(const uECC_HashContext *base,
const uint8_t *message,
unsigned message_size)
{
uECC_SHA256_HashContext *context = (uECC_SHA256_HashContext*)base;
sha256_update(&context->ctx, message, message_size);
}
static int
__archive_nettle_sha256update(archive_sha256_ctx *ctx, const void *indata,
size_t insize)
{
sha256_update(ctx, insize, indata);
return (ARCHIVE_OK);
}
static uint32_t ota_package_verify(struct ota *ota)
{
uint32_t err_code;
uint32_t offset;
uint8_t buffer[32];
sha256_context_t c __attribute__((aligned(4)));
unsigned char md[SHA256_DIGEST_LENGTH] __attribute__((aligned(4)));
size_t len;
sha256_init(&c);
len = sizeof(buffer);
for (offset = 0; offset < ota->sig.size; offset += sizeof(buffer)) {
if (offset + len >= ota->sig.size)
{
len = ota->sig.size - offset;
}
err_code = ota_read_bytes(ota_get_cache_offset(ota) * ERASE_PAGE_SIZE
+ OTA_HEADER_OFFSET + offset,
buffer, len);
if (err_code)
return err_code;
sha256_update(&c, buffer, len);
}
sha256_final(md, &c);
uint8_t *buf;
buf = (uint8_t *) (ota_get_cache_offset(ota) * ERASE_PAGE_SIZE + OTA_HEADER_OFFSET);
ota->payload = buf + ota->header.hdr_length;
return !secure_update(& (ota->sig), md);
}
static void calc_sha256(BYTE* buffer32,
const uint8* text, size_t size) {
sha256_context ctx;
sha256_starts(&ctx);
sha256_update(&ctx, (uint8*)text, size);
sha256_finish(&ctx, buffer32);
}
int create_passphrase_digest(const unsigned char* passphrase, unsigned char* digest)
{
int was_successful = 0;
do{
if(!passphrase)
break;
SHA256_CTX ctx;
size_t passphrase_len = strlen((char*)passphrase);
sha256_init(&ctx);
sha256_update(&ctx, passphrase, passphrase_len);
sha256_final(&ctx, digest);
was_successful = 1;
}while(0);
if(!was_successful)
{
}
return was_successful;
}
void verify_sha256_digest(void)
{
struct sha256_region *ptr, *end;
sha256_digest_t digest;
int i;
sha256_context ctx;
sha256_starts(&ctx);
end = &sha256_regions[sizeof(sha256_regions)/sizeof(sha256_regions[0])];
for(ptr = sha256_regions; ptr < end; ptr++) {
sha256_update(&ctx, (uint8_t *)((uintptr_t)ptr->start),
ptr->len);
}
sha256_finish(&ctx, digest);
if (memcmp(digest, sha256_digest, sizeof(digest)) != 0) {
printf("sha256 digests do not match :(\n");
printf(" digest: ");
for(i = 0; i < sizeof(digest); i++) {
printf("%hhx ", digest[i]);
}
printf("\n");
printf("sha256_digest: ");
for(i = 0; i < sizeof(sha256_digest); i++) {
printf("%hhx ", sha256_digest[i]);
}
printf("\n");
for(;;) {
/* loop forever */
}
}
}
Status FileHashUploader::loop_sha() {
auto limit = resource_state_.unused();
if (limit == 0) {
return Status::OK();
}
if (limit > size_left_) {
limit = size_left_;
}
resource_state_.start_use(limit);
fd_.update_flags(Fd::Flag::Read);
TRY_RESULT(read_size, fd_.flush_read(static_cast<size_t>(limit)));
if (read_size != static_cast<size_t>(limit)) {
return Status::Error("unexpected end of file");
}
while (true) {
auto ready = fd_.input_buffer().prepare_read();
if (ready.empty()) {
break;
}
sha256_update(ready, &sha256_state_);
fd_.input_buffer().confirm_read(ready.size());
}
resource_state_.stop_use(limit);
size_left_ -= narrow_cast<int64>(read_size);
CHECK(size_left_ >= 0);
if (size_left_ == 0) {
state_ = NetRequest;
return Status::OK();
}
return Status::OK();
}
SHA256_DIGEST sha256(const void *message, size_t message_len)
{
SHA256_CTX ctxt;
sha256_init(&ctxt);
sha256_update(&ctxt, message, message_len);
return sha256_finish(&ctxt);
}
