C++ sha256_update函数代码示例

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


}