cpp 區塊鏈模擬示例(四) 區塊鏈工做量證實

時間 2019-11-14

標籤 cpp 區塊模擬示例證實欄目比特幣简体版

原文原文鏈接

本文主要在以前的區塊鏈原形上添加了工做量證實，而且爲後繼的交易功能作好準備.ios

上一個章節咱們已經建立了區塊鏈的基本原形，可是區塊的哈希計算和加入太過於簡單，若是按照這種速度添加區塊那麼區塊鏈估計一個小時就爆滿了。c++

真實的比特幣中是全網一個小時產生6個區塊，咱們的示例中也須要調整區塊哈希計算的難度。程序員

工做量證實算法

人爲的提高哈希計算的閥值，加大哈希計算難度與工做量，這樣的工做機制才能保證整個區塊鏈數據的安全性和一致性。數據庫

工做量證實

區塊鏈的一個關鍵點就是，一我的必須通過一系列困難的工做，才能將數據放入到區塊鏈中。正是這種困難的工做，才使得區塊鏈是安全和一致的。此外，完成這個工做的人也會得到獎勵（這也就是經過挖礦得到幣）。windows

這個機制與生活的一個現象很是相似：一我的必須經過努力工做，纔可以得到回報或者獎勵，用以支撐他們的生活。在區塊鏈中，是經過網絡中的參與者（礦工）不斷的工做來支撐整個網絡，也就是礦工不斷地向區塊鏈中加入新塊，而後得到相應的獎勵。做爲他們努力工做的結果，新生成的區塊就可以被安全地被加入到區塊鏈中，這種機制維護了整個區塊鏈數據庫的穩定性。值得注意的是，完成了這個工做的人必需要證實這一點，他必需要證實確實是他完成了這些工做。安全

整個「努力工做並進行證實」的機制，就叫作工做量證實（proof-of-work）。要想完成工做很是地不容易，由於這須要大量的計算能力：即使是高性能計算機，也沒法在短期內快速完成。此外，這個工做的困難度會隨着時間不斷增加，以保持每一個小時大概出 6 個新塊的速度。在比特幣中，這個工做的目的是爲了找到一個塊的哈希，同時這個哈希知足了一些必要條件。這個哈希，也就充當了證實的角色。所以，尋求證實（尋找有效哈希），就是實際要作的事情。服務器

Hashcash

比特幣使用 Hashcash ，一個最初用來防止垃圾郵件的工做量證實算法。它能夠被分解爲如下步驟：網絡

取一些公開的數據（好比，若是是 email 的話，它能夠是接收者的郵件地址；在比特幣中，它是區塊頭）
給這個公開數據添加一個計數器。計數器默認從 0 開始
將 data(數據) 和 counter(計數器) 組合到一塊兒，得到一個哈希
檢查哈希是否符合必定的條件：
1. 若是符合條件，結束
2. 若是不符合，增長計數器，重複步驟 3-4

所以，這是一個暴力算法：改變計數器，計算一個新的哈希，檢查，增長計數器，計算一個哈希，檢查，如此反覆。這也是爲何說它是在計算上是很是昂貴的，由於這一步須要如此反覆不斷地計算和檢查。ide

如今，讓咱們來仔細看一下一個哈希要知足的必要條件。在原始的 Hashcash 實現中，它的要求是「一個哈希的前 20 位必須是 0」。在比特幣中，這個要求會隨着時間而不斷變化。由於按照設計，必須保證每 10 分鐘生成一個塊，而不論計算能力會隨着時間增加，或者是會有愈來愈多的礦工進入網絡，因此須要動態調整這個必要條件。

首先定義挖礦難度，也就是哈希值前多少位必須爲0的檢測標準。

#define DifficultyNum    6

咱們刪除原來在Block類中的Sethash()函數，取而代之的是string Block::CalculateHash() 和 void Block::ProofOfWork(int difficultNum)

string Block::CalculateHash() 是根據區塊Block的建立時間和區塊描述和上一個區塊的哈希以及_nNonce來計算一個哈希值並放回。返回的值會發送給ProofOfWork()函數驗證是否符合標準(前DifficultyNum位必須爲零).

string Block::CalculateHash() {
    stringstream ss;
    ss << _tTime << _data << _prevHash << _nNonce;
    return sha256(ss.str());
}

void Block::ProofOfWork(int difficultNum) {
    char cstr[DifficultyNum + 1];
    for (uint32_t i = 0; i < DifficultyNum; ++i) {
        cstr[i] = '0';
    }
    cstr[DifficultyNum] = '\0';
    string str(cstr);
    do {
        _nNonce++;
        _hash = CalculateHash();
    } while (_hash.substr(0, difficultNum) != str);

    std::cout << "Block mined: " << _hash << std::endl;
}

相應的在建立區塊後都要調用工做量證實函數

void Blockchain::AddBlock(string datain) {
    Block* prev = blocks.back();
    Block* newblock = new  Block(datain, prev->_hash);
    newblock->ProofOfWork(DifficultyNum);
    blocks.push_back(newblock);
}

static Block* NewBlock(string datain, string prevBlockHash) {
        Block* p = new Block( datain, prevBlockHash);
        p->ProofOfWork(DifficultyNum);
        return p;
    }

main函數基本沒有變化咱們運行查看效果

int main()
{
    Blockchain* bc = TOOLS::NewBlockchain();

    bc->AddBlock("Send 1 BTC to Ivan");
    bc->AddBlock("Send 2 more BTC to Ivan");

    for (int i = 0; i < bc->blocks.size(); i++) {
        std::cout << "Prev hash = " << bc->blocks[i]->_prevHash << std::endl;
        std::cout << "data  = " << bc->blocks[i]->_data << std::endl;
        std::cout << "hash  = " << bc->blocks[i]->_hash << std::endl << std::endl;

    }

    //退出以前 刪除
    delete bc;

    return 0;
}

這個是難度爲4的計算結果:

這是難度爲6的計算結果

代碼以下:

#include "stdafx.h"
#include "Blockchain.h"
#include "util.h"
#include <vector>
#include <iostream>


using namespace std;

int main()
{
    Blockchain* bc = TOOLS::NewBlockchain();

    bc->AddBlock("Send 1 BTC to Ivan");
    bc->AddBlock("Send 2 more BTC to Ivan");

    for (int i = 0; i < bc->blocks.size(); i++) {
        std::cout << "Prev hash = " << bc->blocks[i]->_prevHash << std::endl;
        std::cout << "data  = " << bc->blocks[i]->_data << std::endl;
        std::cout << "hash  = " << bc->blocks[i]->_hash << std::endl << std::endl;
    }

    //退出以前 刪除
    delete bc;
    system("pause");
    return 0;
}

main.cpp

#include <cstring>
#include <fstream>
#include "sha256.h"
const unsigned int SHA256::sha256_k[64] = //UL = uint32
{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};
void SHA256::transform(const unsigned char *message, unsigned int block_nb)
{
uint32 w[64];
uint32 wv[8];
uint32 t1, t2;
const unsigned char *sub_block;
int i;
int j;
for (i = 0; i < (int) block_nb; i++) {
sub_block = message + (i << 6);
for (j = 0; j < 16; j++) {
SHA2_PACK32(&sub_block[j << 2], &w[j]);
}
for (j = 16; j < 64; j++) {
w[j] = SHA256_F4(w[j - 2]) + w[j - 7] + SHA256_F3(w[j - 15]) + w[j - 16];
}
for (j = 0; j < 8; j++) {
wv[j] = m_h[j];
}
for (j = 0; j < 64; j++) {
t1 = wv[7] + SHA256_F2(wv[4]) + SHA2_CH(wv[4], wv[5], wv[6])
+ sha256_k[j] + w[j];
t2 = SHA256_F1(wv[0]) + SHA2_MAJ(wv[0], wv[1], wv[2]);
wv[7] = wv[6];
wv[6] = wv[5];
wv[5] = wv[4];
wv[4] = wv[3] + t1;
wv[3] = wv[2];
wv[2] = wv[1];
wv[1] = wv[0];
wv[0] = t1 + t2;
}
for (j = 0; j < 8; j++) {
m_h[j] += wv[j];
}
}
}
void SHA256::init()
{
m_h[0] = 0x6a09e667;
m_h[1] = 0xbb67ae85;
m_h[2] = 0x3c6ef372;
m_h[3] = 0xa54ff53a;
m_h[4] = 0x510e527f;
m_h[5] = 0x9b05688c;
m_h[6] = 0x1f83d9ab;
m_h[7] = 0x5be0cd19;
m_len = 0;
m_tot_len = 0;
}
void SHA256::update(const unsigned char *message, unsigned int len)
{
unsigned int block_nb;
unsigned int new_len, rem_len, tmp_len;
const unsigned char *shifted_message;
tmp_len = SHA224_256_BLOCK_SIZE - m_len;
rem_len = len < tmp_len ? len : tmp_len;
memcpy(&m_block[m_len], message, rem_len);
if (m_len + len < SHA224_256_BLOCK_SIZE) {
m_len += len;
return;
}
new_len = len - rem_len;
block_nb = new_len / SHA224_256_BLOCK_SIZE;
shifted_message = message + rem_len;
transform(m_block, 1);
transform(shifted_message, block_nb);
rem_len = new_len % SHA224_256_BLOCK_SIZE;
memcpy(m_block, &shifted_message[block_nb << 6], rem_len);
m_len = rem_len;
m_tot_len += (block_nb + 1) << 6;
}
void SHA256::final(unsigned char *digest)
{
unsigned int block_nb;
unsigned int pm_len;
unsigned int len_b;
int i;
block_nb = (1 + ((SHA224_256_BLOCK_SIZE - 9)
< (m_len % SHA224_256_BLOCK_SIZE)));
len_b = (m_tot_len + m_len) << 3;
pm_len = block_nb << 6;
memset(m_block + m_len, 0, pm_len - m_len);
m_block[m_len] = 0x80;
SHA2_UNPACK32(len_b, m_block + pm_len - 4);
transform(m_block, block_nb);
for (i = 0 ; i < 8; i++) {
SHA2_UNPACK32(m_h[i], &digest[i << 2]);
}
}
std::string sha256(std::string input)
{
unsigned char digest[SHA256::DIGEST_SIZE];
memset(digest,0,SHA256::DIGEST_SIZE);
SHA256 ctx = SHA256();
ctx.init();
ctx.update( (unsigned char*)input.c_str(), input.length());
ctx.final(digest);
char buf[2*SHA256::DIGEST_SIZE+1];
buf[2*SHA256::DIGEST_SIZE] = 0;
for (int i = 0; i < SHA256::DIGEST_SIZE; i++)
sprintf(buf+i*2, "%02x", digest[i]);
return std::string(buf);
}

sha256.cpp

#ifndef SHA256_H
#define SHA256_H
#include <string>
class SHA256
{
protected:
typedef unsigned char uint8;
typedef unsigned int uint32;
typedef unsigned long long uint64;
const static uint32 sha256_k[];
static const unsigned int SHA224_256_BLOCK_SIZE = (512/8);
public:
void init();
void update(const unsigned char *message, unsigned int len);
void final(unsigned char *digest);
static const unsigned int DIGEST_SIZE = ( 256 / 8);
protected:
void transform(const unsigned char *message, unsigned int block_nb);
unsigned int m_tot_len;
unsigned int m_len;
unsigned char m_block[2*SHA224_256_BLOCK_SIZE];
uint32 m_h[8];
};
std::string sha256(std::string input);
#define SHA2_SHFR(x, n) (x >> n)
#define SHA2_ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n)))
#define SHA2_ROTL(x, n) ((x << n) | (x >> ((sizeof(x) << 3) - n)))
#define SHA2_CH(x, y, z) ((x & y) ^ (~x & z))
#define SHA2_MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
#define SHA256_F1(x) (SHA2_ROTR(x, 2) ^ SHA2_ROTR(x, 13) ^ SHA2_ROTR(x, 22))
#define SHA256_F2(x) (SHA2_ROTR(x, 6) ^ SHA2_ROTR(x, 11) ^ SHA2_ROTR(x, 25))
#define SHA256_F3(x) (SHA2_ROTR(x, 7) ^ SHA2_ROTR(x, 18) ^ SHA2_SHFR(x, 3))
#define SHA256_F4(x) (SHA2_ROTR(x, 17) ^ SHA2_ROTR(x, 19) ^ SHA2_SHFR(x, 10))
#define SHA2_UNPACK32(x, str) \
{ \
*((str) + 3) = (uint8) ((x) ); \
*((str) + 2) = (uint8) ((x) >> 8); \
*((str) + 1) = (uint8) ((x) >> 16); \
*((str) + 0) = (uint8) ((x) >> 24); \
}
#define SHA2_PACK32(str, x) \
{ \
*(x) = ((uint32) *((str) + 3) ) \
| ((uint32) *((str) + 2) << 8) \
| ((uint32) *((str) + 1) << 16) \
| ((uint32) *((str) + 0) << 24); \
}
#endif

sha256.h

#include "Blockchain.h"


class TOOLS{
public:
    static Block* NewGenesisBlock() {
        return NewBlock("Genesis Block", "");
    }

    static Blockchain* NewBlockchain() {
        Block* pblock = NewGenesisBlock();
        Blockchain* p = new Blockchain(pblock);
        return  p;
    }
    static Block* NewBlock(string datain, string prevBlockHash) {
        Block* p = new Block( datain, prevBlockHash);
        p->ProofOfWork(DifficultyNum);
        return p;
    }
private:

};

util.h

#include <string>

using namespace std;

#define DifficultyNum    6

class Block {
public:
    string    _hash;                //當前區塊的哈希
    string    _data;                //區塊描述字符
    string    _prevHash;            //記錄上個塊的哈希值
    Block(const string&    prevHash, const string& dataIn);    //構造函數
    string CalculateHash();            //計算本區塊的可能哈希 返回值在MineBlock函數中驗證
    void ProofOfWork(int difficultNum);
private:
    int64_t _nNonce;            //區塊隨機數 用於哈希值的產生
    time_t    _tTime;                //建立時間
    
};

Block.h

#include "Block.h"
#include "sha256.h"
#include <time.h>
#include <string>
#include <sstream>
#include <iostream>

using namespace std;

string Block::CalculateHash() {
    stringstream ss;
    ss << _tTime << _data << _prevHash << _nNonce;
    return sha256(ss.str());
}

Block::Block( const string& dataIn, const string&    prevHash) {
    _tTime = time(nullptr);
    _nNonce = 0;
    _data = dataIn;    
    _prevHash = prevHash;
    
}

void Block::ProofOfWork(int difficultNum) {
    char cstr[DifficultyNum + 1];
    for (uint32_t i = 0; i < DifficultyNum; ++i) {
        cstr[i] = '0';
    }
    cstr[DifficultyNum] = '\0';
    string str(cstr);
    do {
        _nNonce++;
        _hash = CalculateHash();
        //std::cout << _hash ;
    } while (_hash.substr(0, difficultNum) != str);

    std::cout << "Block mined: " << _hash << std::endl;
}

Block.cpp

#include <vector>
#include "Block.h"

using namespace std;


class Blockchain {
public:
    Blockchain(Block* p);
    vector<Block*>    blocks;
    void AddBlock(string datain);
    ~Blockchain() {
        for (int i = 0; i < blocks.size(); i++) {
            if (blocks[i] != NULL) {
                delete blocks[i];
                blocks[i] = NULL;
            }
        }
    }
private:

};

Blockchain.h

#include "Blockchain.h"

void Blockchain::AddBlock(string datain) {
    Block* prev = blocks.back();
    Block* newblock = new  Block(datain, prev->_hash);
    newblock->ProofOfWork(DifficultyNum);
    blocks.push_back(newblock);
}


Blockchain::Blockchain(Block* p) {
    blocks.clear();
    blocks.push_back(p);
}

Blockchain.cpp

/*
* Updated to C++, zedwood.com 2012
* Based on Olivier Gay's version
* See Modified BSD License below:
*
* FIPS 180-2 SHA-224/256/384/512 implementation
* Issue date: 04/30/2005
* http://www.ouah.org/ogay/sha2/
*
* Copyright (C) 2005, 2007 Olivier Gay <olivier.gay@a3.epfl.ch>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the project nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

SHA256-LICENSE.txt

工程文件也能夠在qq羣中找到，文件名爲 MyBlockChainCppSample_part2

下一個章節介紹持久化

做者: itdef

歡迎轉帖請保持文本完整並註明出處
技術博客 http://www.cnblogs.com/itdef/
技術交流羣羣號碼：432336863
歡迎c c++ windows驅動愛好者服務器程序員溝通交流
部分老代碼存放地點
http://www.oschina.net/code/list_by_user?id=614253

參考博文：

https://blog.csdn.net/simple_the_best/article/details/78104604

https://jeiwan.cc/posts/building-blockchain-in-go-part-2/