区块链学习(2) 计算区块的哈希值

SolidWorks Motion多体动力学仿真实战指南 多体动力学(MBD)是机械系统动态行为建模与分析的核心技术,其原理基于刚体系统微分方程组的数值积分求解,支撑运动轨迹、反作用力、接触响应等关键物理量的预测。该技术显著提升机构可行性验证、零部件寿命预估与机电协同设计的工程可信度,广泛应用于机器人、汽车传动、电动工具等需高精度动态响应的领域。SolidWorks Motion作为集成于CAD环境的MBD求解器,依托ADAMS同源引擎,支持运动副定义、接触建模与动态载荷输出,但其结果可靠性高度依赖约束体系重构、接触参数校准及Motion-Simulation协同 阅读详情

本文的目的:根据一个区块的信息算出他的哈希值


区块信息:
https://www.blockchain.com/zh/btc/block-height/20000


区块头格式:
共80个字节,上图中都是字符串,需要转换为二进制的区块头格式。

字段大小描述
version04字节版本号
previous block hash32字节前一个区块的哈希
merkle root32字节该区块中交易的merkle树根的哈希值
time04字节该区块的创建时间戳 utc时间
bits04字节该区块链工作量证明难度目标
nonce04字节用于证明工作量的计算随机数

程序思路
1、通过区块链浏览器提供的api,获取一个区块的信息。
      这里使用btc.com,以btc的创世块为例。

curl -s https://chain.api.btc.com/v3/block/0
{
	"data": {
		"height": 0,
		"version": 1,
		"mrkl_root": "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b",
		"timestamp": 1231006505,
		"bits": 486604799,
		"nonce": 2083236893,
		"hash": "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
		"prev_block_hash": "0000000000000000000000000000000000000000000000000000000000000000",
		"next_block_hash": "00000000839a8e6886ab5951d76f411475428afc90947ee320161bbf18eb6048",
		"size": 285,
		"pool_difficulty": 2536,
		"difficulty": 1,
		"tx_count": 1,
		"reward_block": 5000000000,
		"reward_fees": 0,
		"created_at": 1488909332,
		"confirmations": 552468,
		"is_orphan": false,
		"curr_max_timestamp": 1231006505,
		"is_sw_block": false,
		"stripped_size": 285,
		"weight": 1140,
		"extras": {
			"pool_name": "unknown",
			"pool_link": ""
		}
	},
	"err_no": 0,
	"err_msg": null
}

2、解析出区块的头部信息,生成结果block_header_t,注意各种字节序的转换。

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          block:0
        version:1
prev_block_hash:0000000000000000000000000000000000000000000000000000000000000000
      mrkl_root:3ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a
      timestamp:1231006505
           bits:486604799
          nonce:2083236893
           hash:000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

3、系统的字节序为小端,80个字节的区块头部信息如下:

0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c

4、对区块头部进行2次哈希得到最终结果。

sha256-1=af42031e805ff493a07341e2f74ff58149d22ab9ba19f61343e2c86c71c5d66d
sha256-2=000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f

完整的代码

// xmain.c
// by maxzero

#include "xutils.h"
#include "xsha256.h"

typedef struct _block_header {
    uint32_t ver;
    uint32_t hash_prev[8];
    uint32_t hash_mkrt[8];
    uint32_t timex;
    uint32_t bits ;
    uint32_t nonce;
}block_header_t;

static int make_block_header(block_header_t *block_header, int block_num)
{
    FILE* f = NULL;
    int   n = 0;
    int   r = 0;

    char  url[1024];
    char* buf = NULL;
    int   len = 1*1024*1024*sizeof(char);;
    char  temp[128];

    memset(url, 0x00, sizeof(url));
    sprintf(url, "curl -s https://chain.api.btc.com/v3/block/%d", block_num);
    f = popen(url, "r");

    buf = (char*)malloc(len);
    if (NULL == buf) {
        xprint_err("malloc() failed. len=%d\n", len);
        pclose(f);
        return -1;
    }

    memset(buf, 0x00, len);
    n = fread(buf, 1, len, f);
    if (n <= 0) {
        xprint_err("fread() failed. n=%d\n", n);
        goto xexit;
    }

    printf("n=%d l=%d\n", n, len);
    printf("%s\n\n", buf);

    memset(temp, 0x00, sizeof(temp));
    if (-1 == xkey_value_parser(buf, "\"version\":", ",", temp, sizeof(temp))) {
        r = -1;
        goto xexit;
    }
    else {
        block_header->ver = atoi(temp);
    }

    memset(temp, 0x00, sizeof(temp));
    if (-1 == xkey_value_parser(buf, "\"mrkl_root\":\"", "\",", temp, sizeof(temp))) {
        r = -1;
        goto xexit;
    }
    else {
        hex2bin((uint8_t*)block_header->hash_mkrt, temp, strlen(temp));
        xreverse_dword((uint32_t*)block_header->hash_mkrt, 8, 1);
    }

    memset(temp, 0x00, sizeof(temp));
    if (-1 == xkey_value_parser(buf, "\"timestamp\":", ",", temp, sizeof(temp))) {
        r = -1;
        goto xexit;
    }
    else {
        block_header->timex = atoi(temp);
    }

    memset(temp, 0x00, sizeof(temp));
    if (-1 == xkey_value_parser(buf, "\"bits\":", ",", temp, sizeof(temp))) {
        r = -1;
        goto xexit;
    }
    else {
        block_header->bits = atoi(temp);
    }

    memset(temp, 0x00, sizeof(temp));
    if (-1 == xkey_value_parser(buf, "\"nonce\":", ",", temp, sizeof(temp))) {
        r = -1;
        goto xexit;
    }
    else {
        block_header->nonce = atoi(temp);
    }

    memset(temp, 0x00, sizeof(temp));
    if (-1 == xkey_value_parser(buf, "\"prev_block_hash\":\"", "\",", temp, sizeof(temp))) {
        r = -1;
        goto xexit;
    }
    else {
        hex2bin((uint8_t*)block_header->hash_prev, temp, strlen(temp));
        xreverse_dword((uint32_t*)block_header->hash_prev, 8, 1);
    }

    memset(temp, 0x00, sizeof(temp));
    if (-1 == xkey_value_parser(buf, "\"hash\":\"", "\",", temp, sizeof(temp))) {
        r = -1;
        goto xexit;
    }

    printf("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
    printf("          block:%u\n", block_num);
    printf("        version:%u\n", block_header->ver);
    printf("prev_block_hash:");    xdump_byte((uint8_t*)block_header->hash_prev, 32, 32, 0);
    printf("      mrkl_root:");    xdump_byte((uint8_t*)block_header->hash_mkrt, 32, 32, 0);
    printf("      timestamp:%u\n", block_header->timex);
    printf("           bits:%u\n", block_header->bits);
    printf("          nonce:%u\n", block_header->nonce);
    printf("           hash:%s\n", temp);
    printf("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
    printf("\n");

xexit:
    free(buf);
    pclose(f);
    return r;
}

int hash_block_header(int block_num)
{
    block_header_t block_header;
    uint32_t sha1[8];
    uint32_t sha2[8];
    int i = 0;

    memset(&block_header, 0x00, sizeof(block_header));
    if (0 != make_block_header(&block_header, block_num)) {
        return -1;
    }

    xdump_byte((uint8_t*)&block_header, 80, 80, 0);
    xsha256((uint8_t*)&block_header, 80, sha1);
    printf("sha256-1=");
    for (i=0; i<8; i++) {
        printf("%08x", sha1[i]);
        sha1[i] = htonl(sha1[i]);
    }
    printf("\n");

    xsha256((uint8_t*)sha1, sizeof(sha1), sha2);
    xreverse_dword(sha2, 8, 1);
    printf("sha256-2=");
    for (i=0; i<8; i++) {
        printf("%08x", sha2[i]);
    }
    printf("\n");
    printf("\n");
    return 0;
}

int main(int argc, char* argv[])
{
    int block_num = 0;
    
    if (argc != 2) {
        printf("usage: a.out [block number]\n");
        printf("   ex: a.out 100\n");
        return -1;
    }

    block_num = atoi(argv[1]);
    hash_block_header(block_num);
    return 0;
}

// xsha256.h
// by maxzero

#ifndef _M_XSHA256_H
#define _M_XSHA256_H

#include "xutils.h"

#ifdef  __cplusplus  
extern "C" {  
#endif 

int xsha256(const uint8_t *src, uint32_t len, uint32_t *hash);

#ifdef  __cplusplus  
}
#endif 
#endif

////////////////////////////////////////////////////////////////////////////////

// xsha256.c
// by maxzero

#include "xsha256.h"

#define XSHA_DBG 0
#define SHFR(x, n) (((x) >> (n)))
#define ROTR(x, n) (((x) >> (n)) | ((x) << ((sizeof(x) << 3) - (n))))
#define ROTL(x, n) (((x) << (n)) | ((x) >> ((sizeof(x) << 3) - (n))))

#define CHX(x, y, z) (((x) &  (y)) ^ (~(x) & (z)))
#define MAJ(x, y, z) (((x) &  (y)) ^ ( (x) & (z)) ^ ((y) & (z)))

#define BSIG0(x) (ROTR(x,  2) ^ ROTR(x, 13) ^ ROTR(x, 22))
#define BSIG1(x) (ROTR(x,  6) ^ ROTR(x, 11) ^ ROTR(x, 25))
#define SSIG0(x) (ROTR(x,  7) ^ ROTR(x, 18) ^ SHFR(x,  3))
#define SSIG1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHFR(x, 10))

#define SHA256_BLOCK_SIZE (512/8)
#define SHA256_COVER_SIZE (SHA256_BLOCK_SIZE*2)


static uint32_t k[64] = {
    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};


static int xtransform(const uint8_t *msg, uint32_t *h)
{
    uint32_t w[64];
    uint32_t a0, b1, c2, d3, e4, f5, g6, h7;
    uint32_t t1, t2;

    int i = 0;
    int j = 0;

    for (i=0; i<16; i++) {
        w[i] = msg[j]<<24 | msg[j+1]<<16 | msg[j+2]<<8 | msg[j+3];
        j += 4;
    }

    for(i=16; i<64; i++){
        w[i] = SSIG1(w[i-2])+w[i-7]+SSIG0(w[i-15])+w[i-16];
    }

#if XSHA_DBG
    xdump_byte((uint8_t*)w, 64*4, 32);
#endif

    a0 = h[0];
    b1 = h[1];
    c2 = h[2];
    d3 = h[3];
    e4 = h[4];
    f5 = h[5];
    g6 = h[6];
    h7 = h[7];

    for (i= 0; i<64; i++) {
        t1 = h7 + BSIG1(e4) + CHX(e4, f5, g6) + k[i] + w[i];
        t2 = BSIG0(a0) + MAJ(a0, b1, c2);

        h7 = g6;
        g6 = f5;
        f5 = e4;
        e4 = d3 + t1;
        d3 = c2;
        c2 = b1;
        b1 = a0;
        a0 = t1 + t2;
    }

    h[0] += a0;
    h[1] += b1;
    h[2] += c2;
    h[3] += d3;
    h[4] += e4;
    h[5] += f5;
    h[6] += g6;
    h[7] += h7;

    return 0;
}

int xsha256(const uint8_t *src, uint32_t len, uint32_t *hash)
{
    uint8_t *tmp = (uint8_t*)src;
    uint8_t  cover_data[SHA256_COVER_SIZE];
    uint32_t cover_size = 0;
    
    uint32_t i = 0;
    uint32_t n = 0;
    uint32_t m = 0;
    uint32_t h[8];

    h[0] = 0x6a09e667;
    h[1] = 0xbb67ae85;
    h[2] = 0x3c6ef372;
    h[3] = 0xa54ff53a;
    h[4] = 0x510e527f;
    h[5] = 0x9b05688c;
    h[6] = 0x1f83d9ab;
    h[7] = 0x5be0cd19;

    memset(cover_data, 0x00, sizeof(uint8_t)*SHA256_COVER_SIZE);

    n = len / SHA256_BLOCK_SIZE;
    m = len % SHA256_BLOCK_SIZE;

    if (m < 56 ) {
        cover_size = SHA256_BLOCK_SIZE;
    }else {
        cover_size = SHA256_BLOCK_SIZE*2;
        
    }

    if (m !=0) {
        memcpy(cover_data, tmp + (n * SHA256_BLOCK_SIZE), m);
    }
    cover_data[m] = 0x80;
    cover_data[cover_size-4]  = ((len*8)&0xff000000) >> 24;
    cover_data[cover_size-3]  = ((len*8)&0x00ff0000) >> 16;
    cover_data[cover_size-2]  = ((len*8)&0x0000ff00) >> 8;
    cover_data[cover_size-1]  = ((len*8)&0x000000ff);

#if XSHA_DBG
    xdump_hex(tmp, len-m, 32);
    xdump_hex(cover_data, cover_size, 32);
#endif

    for (i=0; i<n; i++) {
        xtransform(tmp, h);
        tmp += SHA256_BLOCK_SIZE;
    }

    tmp = cover_data;
    n = cover_size / SHA256_BLOCK_SIZE;
    for (i=0; i<n; i++) {
        xtransform(tmp, h);
        tmp += SHA256_BLOCK_SIZE;
    }
    
    if (NULL != hash) {
        memcpy(hash, h, sizeof(uint32_t)*8);
    }
    return 0;
}

// xutils.h
// by maxzero


#ifndef _M_XUTILS_H
#define _M_XUTILS_H

#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <memory.h>
#include <string.h>
#include <time.h>
#include <arpa/inet.h>
#include <stdbool.h>

#ifdef  __cplusplus  
extern "C" {  
#endif 

#define xdbg 1

#if xdbg
#define xprint_log(fmt, ...) \
    printf("[%s:%04d] %s() "      fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
#define xprint_err(fmt, ...) \
    printf("[%s:%04d] %s() err: " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
#else
#define xprint_log(fmt, ...)
#define xprint_err(fmt, ...)
#endif

#define XDUMP_LINEN 0x01 
#define XDUMP_SPACE 0x02
#define XDEMP_DEFAULT (XDUMP_SPACE|XDUMP_LINEN)

int xdump_byte(const uint8_t *data, int size, int line, int flag);
uint8_t crc5(uint8_t *data, uint8_t size);
bool hex2bin(unsigned char *binstr, const char *hexstr, size_t len);
void xreverse_byte(unsigned char *s, size_t n);
void xreverse_dword(uint32_t *s, size_t n, int f);
int xkey_value_parser(char *data, char *key, char *end, char *value, int len);

#ifdef  __cplusplus  
}
#endif 

#endif


/////////////////////////////////////////////////////////////////////////////////

// xutils.c
// by maxzero

#include "xutils.h"

static const int hex2bin_tbl[256] = {
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
    -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
};

int xdump_byte(const uint8_t *data, int size, int line, int flag)
{
    int i;
    int l = line;
    
    if (size <= 0) { return 0; }

    for (i=0; i<size; i++) {
        if (((i%l)==0) && ((flag&XDUMP_LINEN)==XDUMP_LINEN)) {
            printf( "[%02x] ", i/l );
        }
        printf( "%02x", data[i] );
        if ((flag&XDUMP_SPACE) == XDUMP_SPACE) {
            printf(" ");
        }
        if(((i+1)%l) == 0) {
            printf( "\n" );
        }
    }

    if (size%line != 0) { printf("\n"); }
    return 0;
}

uint8_t crc5(uint8_t *data, uint8_t size)
{
    uint8_t i, j, k;
    uint8_t crc = 0x1f;
    uint8_t crcin [5] = {1, 1, 1, 1, 1};
    uint8_t crcout[5] = {1, 1, 1, 1, 1};
    uint8_t din = 0;

    j = 0x80;
    k = 0;
    for (i=0; i<size; i++) {
        if (*data & j) {
            din = 1;
        } else {
            din = 0;
        }
        crcout[0] = crcin[4] ^ din;
        crcout[1] = crcin[0];
        crcout[2] = crcin[1] ^ crcin[4] ^ din;
        crcout[3] = crcin[2];
        crcout[4] = crcin[3];

        j = j >> 1;
        k++;
        if (k == 8) {
            j = 0x80;
            k = 0;
            data++;
        }
        memcpy(crcin, crcout, 5);
    }

    crc = 0;
    if(crcin[4]) crc |= 0x10;
    if(crcin[3]) crc |= 0x08;
    if(crcin[2]) crc |= 0x04;
    if(crcin[1]) crc |= 0x02;
    if(crcin[0]) crc |= 0x01;
    return crc;
}

bool hex2bin(unsigned char *bin, const char *hexstr, size_t len)
{
    int nibble1, nibble2;
    unsigned char idx;
    bool ret = false;

    while (*hexstr && len) {
        if (!hexstr[1]) {
            xprint_err("hex string truncated.\n");
            return ret;
        }

        idx = *hexstr++;
        nibble1 = hex2bin_tbl[idx];
        idx = *hexstr++;
        nibble2 = hex2bin_tbl[idx];

        if ((nibble1<0) || (nibble2<0)) {
            xprint_err("hex string scan failed.\n");
            return ret;
        }

        *bin++ = (((unsigned char)nibble1)<<4) | ((unsigned char)nibble2);
        --len;
    }

    if (len == 0 && *hexstr == 0) {
        ret = true;
    }

    return ret;
}

void xreverse_byte(unsigned char *s, size_t n)
{
    size_t i = 0;
    size_t j = 0;

    for (i=0, j=n-1; i<j; i++, j--) {
        s[i] = s[i] ^ s[j];
        s[j] = s[j] ^ s[i];
        s[i] = s[i] ^ s[j];
    }
    return ;
}

void xreverse_dword(uint32_t *s, size_t n, int f)
{
    size_t i = 0;
    size_t j = 0;

    for (i=0, j=n-1; i<j; i++, j--) {
        s[i] = s[i] ^ s[j];
        s[j] = s[j] ^ s[i];
        s[i] = s[i] ^ s[j];
        if (1 == f) {
            s[i] = htonl(s[i]);
            s[j] = htonl(s[j]);
        }
    }

    return ;
}

/*解析规则
1、查找关键字 key,key不存在返回失败
2、查找结束符 end  value取值 key到end之间
3、end不存在 尝试空格当结束符 value取值 key到空格之间
4、空格不存在 value取值 key到data结束
*/
int xkey_value_parser(char *data, char *key, char *end, char *value, int len)
{
    char *a = NULL;
    char *b = NULL; 

    int n = 0;    
    int r = 0;

    a = strstr(data, key);
    if (NULL != a) {
        a += strlen(key);
        b = strstr(a, end);
        if (NULL != b) {
            n = b - a;
            n = (n > len) ? len : n;
            memcpy(value, a, n);
            r = b - data;
        }
        else {
            b = strstr(a, " ");
            if (NULL == b) {
                b = data + strlen(data);
            }
            n = b - a;
            n = (n > len) ? len : n;
            memcpy(value, a, n);
            r = b - data;
        }
    }
    else {
        r = -1;
    }

    if (-1 == r) {
        xprint_err("%s not find. pls check uri\n %s \n", key, data);
    }
    
    return r;
}

编译运行
ubuntu 14.04 gcc 5.5.0 

[root@ubuntu:src]# gcc xmain.c xsha256.c xutils.c
[root@ubuntu:src]# ./a.out 0

{"data":{"height":0,"version":1,"mrkl_root":"4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b","timestamp":1231006505,"bits":486604799,"nonce":2083236893,"hash":"000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f","prev_block_hash":"0000000000000000000000000000000000000000000000000000000000000000","next_block_hash":"00000000839a8e6886ab5951d76f411475428afc90947ee320161bbf18eb6048","size":285,"pool_difficulty":2536,"difficulty":1,"tx_count":1,"reward_block":5000000000,"reward_fees":0,"created_at":1488909332,"confirmations":553612,"is_orphan":false,"curr_max_timestamp":1231006505,"is_sw_block":false,"stripped_size":285,"weight":1140,"extras":{"pool_name":"unknown","pool_link":""}},"err_no":0,"err_msg":null}

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          block:0
        version:1
prev_block_hash:0000000000000000000000000000000000000000000000000000000000000000
      mrkl_root:3ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a
      timestamp:1231006505
           bits:486604799
          nonce:2083236893
           hash:000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c
sha256-1=af42031e805ff493a07341e2f74ff58149d22ab9ba19f61343e2c86c71c5d66d
sha256-2=000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f

 

C语言的区块链 首先,我们需要定义一个区块结构体。index:区块在链中的位置。timestamp:区块生成的时间戳。data:区块中存储的交易数据。prev_hash:前一个区块的哈希值。hash:当前区块的哈希值。以下是C语言中区块结构体的定义:```c本文介绍了如何使用C语言构建一个简单的区块链。在区块链的实现过程中,我们创建了区块结构体,设计了哈希计算方法,编写了添加区块和打印区块链的功能。这为我们深入理解区块链技术提供了一个基础平台。 阅读详情

相关推荐

区块链 01(简化后的区块包括父区块哈希值、数据、时间戳、哈希值这四个字段,区块的哈希值由父区块哈希值、数据、时间戳、3个字段拼接通过 哈希算法计算而成)

"""区块包括区块头和区块体两个部分。区块头由版本、父区块哈希值、数据、Merkle根、时间戳、目标难度、 #Nonce值组成;区块体实际上可以包含任何内容,在比特币中包含交易输入数量、交易输出数量 和长度不等的交易记录等信息。在以太坊中的区块体中除了交易数据还包含中智能合约""" #简单版区块链 """简化后的区块包括父区块哈希值、数据、时间戳、哈希值这四个字段,区块的哈希值由父区块哈希值、数据、时间戳、3个字段拼接通过 哈希算法计算而成""" import hashlib from datetim.

shs1012052034的博客 3608

区块链学习笔记(二)

区块链的基本结构 区块链分为两个基本的概念,那就是区块和链。我们会首先介绍区块的基本结构,然后介绍区块之间如何串联起来。 区块 区块是一个包含了很多有效交易的数字账簿。这些交易通过Merkle hash tree的形式组织起来。那么每个区块包含什么东西呢? ...

alexanderzjs的博客 574

区块链读书笔记01-区块链基础

区块链介绍什么是区块链(Block Chain)关键特征去中心化(Decentralization)(Persistency)(Anonymity)(Auditability) 什么是区块链(Block Chain) ——本质上是一个去中心化的分布式数据库。这个数据库中记录了所有提交的交易(all committed transactions)。 区块(block):一个一个的存储单元,记录了一定...

鱼板: RE的博客 1766

基于区块链的分布式存储系统开发论文研究

区块链是由多独立节点参与的分布式数据系统

qq_41247688的博客 2007

[Windows] 发票识别工具。支持xml、pdf、ofd文件。

发票识别是财务自动化中的关键环节,支持多种格式(XML、PDF、OFD)的识别工具能显著提升工作效率。以下介绍基于Windows平台开发此类工具的技术方案。发票识别是财务自动化中的关键环节,支持多种格式(XML、PDF、OFD)的识别工具能显著提升工作效率。以下介绍基于Windows平台开发此类工具的技术方案。

pZC_dqux的博客 670

Windows11 升级到24H2后,原本的protel99se软件的DDB图纸文件打不开解决办法

Windows11更新后无法打开DDB文件

xingchen2837的博客 427

哈希算法

对于哈希算法,在我们平时的开发中,都是基本上拿来就用就行了,所以这节我们将重点放在如何使用,并不进行哈希算法的原理剖析和如何设计一个哈希算法的讲解. 什么是哈希算法? 将任意长度的二进制值串映射为固定长度的二进制值串,这个映射的规则就是哈希算法,而通过原始数据映射之后得到的二进制值串就是哈希值(散列值).一个优秀的哈希算法需要满足: 从哈希值不能反...

weixin_30577801的博客 1786

MySQL安装配置教程(超级详细)

一、 下载MySQL Mysql官网下载地址:MySQL :: Download MySQL Installer (Archived Versions) 1. 选择要安装的版本,本篇文章选择的是5.7.31版本,点击Download下载 正在上传…重新上传取消 二、 安装MySQL 1. 选择设置类型双击运行mysql-installer-community-5.7.31.0.msi 这里选择是自定义安装,所以直接选择“Custom”,点击“Next” “Developer Default”是

m0_67322837的博客 5万+

区块链相关术语(中英对照)

说明:阅读英文文档是编程开发过程中最常做的一件事,英文阅读也是一个程序员的基本能力。区块链刚刚起步,每天各种新概念层出不穷,为方便大家学习和使用。

深入浅出区块链 5万+

1. 在 SAP ABAP 事物码 SEGW 里创建 SAP OData 项目

本文介绍如何在 SAP ABAP 事物码 SEGW 里创建 SEGW 项目,使用工具生成 Runtime 运行时需要的资源。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 5446

基于 Simulink 的 PFC + LLC 级联系统联合仿真与优化实战教程

摘要:本教程详细介绍了2kW级AC-DC变换器建模方法,采用"BoostPFC+LLC谐振变换器"组合架构。重点解析了双级系统的核心控制策略:前级BoostPFC实现功率因数校正(PF>0.95),后级LLC通过变频调制(PFM)实现高效能量传输。教程包含四大关键步骤:PFC建模与控制、LLC参数计算与实现、母线电容优化设计以及系统联合调试,特别针对级联系统常见的母线电容震荡问题提供了解决方案。同时给出了仿真波形分析指南和避坑建议,包括代数环处理、仿真步长设置等实用技巧,为新能源车

MHD0815的博客 121

区块链-区块标识符:区块头哈希值和区块高度

目录:https://blog.youkuaiyun.com/qq_40452317/article/details/89646633 区块链的数据结构是由包含交易信息的区块按照从远及近的顺序有序链接起来的。区块被从远及近有序地链接在这个链条里,每个区块都指向前一个区块。 区块链经常被视为一个垂直的栈,第一个区块作为栈底的首区块,随后每个区块都被放置在之前的区块之上。用栈来形象化表示区块依次堆叠这一概...

朝歌 8315

【LLM技术全景】规模定律与模型演进:为什么模型越大越强?

规模定律性能 ∝ 参数量^N性能 ∝ 数据量^M性能 ∝ 计算量^L其中 N, M, L 是小于1的正数(通常0.05~0.15)关键观察损失与规模的关系呈幂律(不是线性,也不是对数)三个要素(参数、数据、计算)需要协调增长只增加其中一个要素,收益会边际递减规模定律(Scaling Law):1. 模型性能与参数量、数据量、计算量呈幂律关系2. Kaplan定律(2020):参数量是主要因素3. Chinchilla定律(2022):数据和参数同等重要,最优比例1:20。

专注:太空算力、AI infra、异构调度、大模型成本工程 496

区块链-为什么区块链是不可篡改的

目录:https://blog.youkuaiyun.com/qq_40452317/article/details/89646633 区块链的数据结构是由包含交易信息的区块按照从远及近的顺序有序链接起来的。区块被从远及近有序地链接在这个链条里,每个区块都指向前一个区块。 区块链经常被视为一个垂直的栈,第一个区块作为栈底的首区块,随后每个区块都被放置在之前的区块之上。用栈来形象化表示区块依次堆叠这一概...

朝歌 1万+

fast-lio系列改进版本

2.回环检测的优化结果,更新到FAST-LIO2的当前帧位姿中,幷进行ikdtree的重构,进而更新submap。其它的效果还不清楚,实测lio部分稳定性很好。用fast-lio_slam就很稳定。融合了fast-lio2和sc-pgo,两部分分开运行,SC-PGO从FAST-LIO2节点获取里程计和激光雷达点云主题。的作者kim在FAST-LIO2的基础上,添加SC-PGO模块,通过加入ScanContext全局描述子,进行回环修正,SC-PGO模块与FAST-LIO2解耦,非常方便,很优秀的工作。

z1872385的博客 3189

YOLOv12改进策略【Head】| ASFF 自适应空间特征融合模块,改进检测头Detect_ASFF

在目标检测中,处理多尺度物体是一个具有挑战性的问题。虽然特征金字塔或多级特征塔是解决多尺度问题的常用方法,但在单阶段检测器中,不同尺度特征之间的不一致性限制了其性能提升。为了解决这个问题,提出了自适应空间特征融合(ASFF)模块。

Limiiiing的博客 1174

简易区块链的实现

因为后续的区块的哈希值依赖于前一个区块的哈希值,因此如果前一个区块的数据被篡改,那么它的哈希值也会发生变化,从而导致整个区块链的哈希值序列被破坏。具体来说,当你创建一个新的区块时,你会将前一个区块的哈希值作为当前区块的前一个哈希值存储在当前区块中。每个区块的哈希值都是由该区块的数据和前一个区块的哈希值计算得出的,因此每个区块的哈希值都依赖于前一个区块的哈希值。//因此,通过遍历区块链中的每个区块,你可以逐个检查每个区块的前一个区块的哈希值是否与前一个区块的实际哈希值匹配,从而验证区块链的完整性。

Hock2023的博客 2086

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

区块链实验三 : 区块链编程2

实验报告03orz实验目的及要求实验基本原理实验实施环境实验概述实验内容学习第4章 区块链工作量证明实现区块链工作量证明的代码编写bitcion_part2项目(涵盖项目目录截图、原型代码和运行结果截图)bitcion_part3项目(涵盖项目目录截图、原型代码和运行结果截图) 实验目的及要求 了解编程语言的基本逻辑,理解编程语言运行机理。熟悉区块链的原理。能正确使用编程语言搭建区块和区块链,并进行工作量证明实现。 实验基本原理 通过课堂理论教学准备,动手使用实验软件平台,完成慕课实验项目的要求。 实验实施

陈杉菜 3726

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

区块链学习札记二:“区块”是什么?

区块链学习札记二:区块是什么? 区块是区块链的基本结构单元,甚至“区块链”的名称也由此而来,可见其重要性。下面我们就对区块进行分析解剖,看看里面到底都有哪些东西? 在区块链网络中,数据会以文件的形式被永久记录, 这些文件称为区块。区块是区块链的基本结构单元,由包含元数据的区块头和包含交易数据的区块主体构成。目前比特币区块链系统大约每10分钟会创建一个区块。 一个区块是一些或所有最...

ydyuse的专栏 6712

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

云计算与区块链的结合

一、云计算为什么要与区块链结合?结合指的是什么? 云计算内的存储和区块链内的存储都是由普通存储介质组成。只是相应管理物理介质的“文件系统”有所差异。区块链同时还会采用海量的独立副本来确保数据的不可修改性和数据的完整性。 云计算中区块链的存储服务实现有两种方法:一种是将云中的数据直接写入区块链,对于拥有区块链的节点来说,需要海量的存储空间。 二、 ...

weixin_43783865的博客 1万+

区块链中的哈希值:从理论到代码实现

通过React前端展示区块间的哈希关联,用户可以直观看到数据变动导致的哈希值雪崩效应。建议想体验区块链原理的同学都可以试试这个方案,在平台上从零搭建大概只要2小时。过程中最惊喜的是部署环节——点击按钮后自动配置好服务器环境,还能自定义域名,完全没想到演示项目也能有这么专业的发布体验。最近在研究区块链技术,发现哈希值作为区块链的基石特别有意思。今天就用一个实战项目,带大家从零开始构建区块链哈希验证系统,顺便分享在。:通过调整nonce值寻找符合难度目标的哈希,演示挖矿过程。

BlackStone33的博客 808

隐私计算与区块链的融合思考

隐私计算是使数据“可用不可见”的技术,实践中仍存在着一些问题,例如,多方安全计算受到网络带宽或者延迟的影响,联邦学习对参与方和服务器之间的通信稳定性和带宽要求较高,可信执行环境依靠的是硬件,硬件的升级改造成本较高而且存在侧信道攻击的问题。区块链是能够解决多方信任和协作的有利工具,可以记录从数据发布到使用的全过程,通过智能合约制定策略,实现权限控制、记录、回溯等功能,还能够实现点对点的高效传输网络。...

我相信...... 3219

【区块链技术(01)】区块链概述与认识区块链基础知识;区块链标识、哈希值、梅克尔树、难度确认

区块链是一种**分布式数据库**,这种分布式数据库换种另外的说法: 去中心的、分散式的网络记账本 它由一系列按时间顺序链接的区块组成。 每个区块包含若干条交易记录,并通过密码学算法与前一个区块链接在一起,从而形成一个不可篡改的链条。

拔高、提升、创新! 1134

区块链学习总结

区块链学习总结 区块链 区块链(Blockchain)是指通过去中心化和去信任的方式集体维护一个可靠数据库的技术方案。该技术方案让参与系统中的任意多个节点,把一段时间系统内全部事务通过密码学算法计算并记录到一个数据块(block),生成该数据块的hash用于链接下个数据块,系统所有参与节点来共同检验记录是否为真,并且每个区块的内容都由后续子链上的区块来保证其内容不可被篡改。 各个参与节点可以在新区块产生确认及奖励分配上达成共识,从而逐渐形成的一个庞大、去中心化的公开账本。 作者:诠科教 链接:https:/

qq_42249942的博客 3846
上一篇: 区块链学习(1) sha256算法 c语言实现
下一篇: 区块链学习(3) 计算区块的merkle root
maxzero
博客等级 码龄20年 57粉丝 24原创
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值