/* * 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); }