区块链设计与实现笔记v1

拟定目录大纲:
0. 前言
1. 区块链原理机制与背景
2. 区块链基本结构
3. 加解密算法实现
4. 区块数据结构从定义到初步实现
5. 区块节点读取与验证
6. 节点和应用程序之间协议
7. 节点之间沟通
8. 侧链设计原理
9. 侧链开发
10. 智能合约设计原理
11. 智能合约开发
12. 计算机基础
13. Linux相关说明
14. 程序开发语言相关说明
15. 密码学相关说明
16. 资料链接

若有更正请联系: 李君
邮件: junlicn@foxmail.com
2017.10.31

实际自动导航目录:

目录不可见时访问: https://www.zybuluo.com/zhongdao/note/933849

0.前言

0.1 内容来源

区块链技术开发公开课:
授课老师: 辕询, 李涛涛
直播地址: http://www.itdks.com/dakashuo/playback/1428

0.2 笔记缘起

根据老师公开课上讲的内容, 构造一个完整笔记,便于学习和掌握. 随着课程的进展, 不断添加和整理.
此文档的完整内容来自:公开的课程内容、源代码，资料、搜索引擎搜到的资料、相关技术书籍上的资料等, 我对内容做了整理,使得易于阅读和条理化，对于部分代码添加了注释和自己的理解, 若有错误请沟通纠正。
其中引用到一些同学的笔记内容或者截图，其他笔记内容来源者包括: 程书芝, 袁丁逸涵, 郜晶, liuhongshuo, 谭东雷, 潘杰 ...
笔记编写过程中有张博成,pz100等对错误之处给出了的修订建议.
要特别感谢老师依据开源传统所教授的内容.

0.3 内容概要

创造一个易于理解说明的区块链.从理论到程序实现.
为了便于对编程不熟悉的同学学习和备查,也增加了所需要的相关的内容.

具体内容参考本文目录,

1.     区块链的基本结构；
2.     为什么私钥最重要，以及随机数 –> 私钥 -> 公钥 -> 地址的生成过程；
3.     每个区块链程序都由三种基本协议组成
  a)     A协议：节点内部的规则，数据格式、交易规则、加密/解密算法等；
  b)     B协议：应用程序与节点沟通的协议；
  c)     C协议：节点之间沟通的协议；
4.     区块间隔和冲突处理机制；
5.     计算机的数据存储及区块链数据结构。

0.4 第三期每次课程摘要

• 第1节:

主要内容：
1.     区块链的基本结构；
2.     为什么私钥最重要，以及随机数 –> 私钥 -> 公钥 -> 地址的生成过程；
3.     文件系统的结构；
4.     每个区块链程序都由三种基本协议组成
a)     A协议：节点内部的规则，数据格式、交易规则、加密/解密算法等；
b)     B协议：应用程序与节点沟通的协议；
c)     C协议：节点之间沟通的协议；
5.     区块间隔和冲突处理机制；
6.     计算机的数据存储及区块链数据结构。

• 第2,3节:
  本周的两次课程当中，辕询老师深入拆解比特币的结构，从代码层面向同学们展示了比特币的设计。并通过代码演示，详细的展示了私钥、公钥、地址和区块的生成过程。通过课后的作业练习，让同学们动手生产私钥、公钥和区块，从代码层面理解比特币的原理。
• 第4节
  周三第4次课，网络编程。辕询老师讲解C语言中套接字函数的用法，并在稍后带同学们使用C语言套接字实现了客户端之间的简单通讯程序。
• 第5节
  周六第5次课，使用C语言重构代码。辕询老师带同学们回顾区块结构，说明PHP加密函数的兼容性问题，并带领大家使用C语言重新实现区块结构的生产过程。
• 第6节
  周日第6次课，由密码学主讲李涛涛老师，为同学们讲解区块链中使用的加密算法，并带领同学们深入探讨什么是HASH，为什么要使用HASH等问题。
• 第7课
  使用C语言重写区块链生成过程。复习区块结构，Transaction的数据结构，Head的数据结构，使用C语言实现Transaction、Head的生成过程。
• 第8课
  密码学第2次课，讲解了ECDSA（elliptical curve digital signaturealgorithm）椭圆曲线数字签名算法。
  一. 什么是椭圆曲线数字签名算法ECDSA(EllipticalCurve digital Signature Algorithm)
  二. ECC (elliptical curve cryptography)和ECDSA的关系
  三. 为什么使用ECDSA
  四. ECDSA在区块链中的应用
  五. ECDSA的编程实现
• 第9课，区块数据解析，如何将一个区块的数据读取出来。
  一. 使用scan方法读取transaction的片段长度
  二. 使用build方法构造一个length + data的数据结构
  三. 将build方法生成的指针存储到无类型（void）链表
  四. 使用循环读取链表内容
  课程调整
  本周确定了新增8次课时的上课时间，每周五、周日增加一次授课。调整后每周授课4次，分别为周三、周五、周六及周日。
• 第10课 -第13课 验证及通过有限状态机和Sockets来接收区块数据.
  区块的接收及验证过程
  通过TCP接收区块数据
  验证格式
  记录valence（区块交易数量）
  验证内容
  验证input，transaction， index参数格式
  验证output格式
  验证签名，使用publc，signature，address进行ECC验证
  验证总输入 大于等于 总输出
  验证剩余输入 大于等于 矿工费
  验证头部
  检查时间：大于上7个区块的平均时间, 保持区块链的时间是不断增加的
  检查工作量证明：TARGET是否少于或者等于协议规定的TARGET。
  检查交易的merkle tree

通过有限状态机(Finite State Machine)对接收的区块数据进行验证。

• 第14课
  更换了助教. ? 讲解了挖矿难度, One Chain 观点.
• 第15课
  如何用指针链表来存储区块便于遍历, 同时演示挖矿的概念和代码实现过程
• 第16课
  通过网络监听并存到storage结构里. 也讲述了节点网络构造和收发钱原理.
  代码实现: cnn.c

以后的规划:
- 测试验证函数
- 每一个C协议的操作落实
- 支持超过一个私钥
- 生成一个文件来保存别的节点的IP和端口为下次连接做准备
- 扔掉我们造的storage,改用SQL
最大的2个目标:
- 智能合约 smart contracts
- 侧链 sidechains.

• 第17课
  我们创造的链与BTC的对比, BTC的最全文档在 https://en.bitcoin.it/wiki/Main_Page
  根据文档讲解协议.讲解了BTC的智能合约script, 介绍了各种钱包.
  讲解了实现虚拟机的php代码.

• 第18课
  阅读了以太坊的技术规范的黄皮书, 修改了php设计的虚拟机.

• 第19课
  讲解了区块链的安全性问题. 几种安全方面的攻击原理与特点. 讲解了php的语言实现., 对比我们实现的virtual machine 同 php7的虚拟机实现. 如果区块链的存储要更改,可以改为类似实现, 用hashtable.
  (组成: 256个bucket, 指针列表, 元数据.)

• 第20课
  基于php开发的wiki, 目前的操作系统界面,浏览器等背景.
  侧链的原理, blockstream公司的开源侧链模板项目element.

• 第21课
  讲解了基于php的wiki如何嵌入插件, 例如从 https://developers.coinbase.com/docs/wallet/guides/price-data 获取json的BTC价格,显示在wiki里. 和区块链结合的原理. 讲解了侧链的原理,钱如何转移.SPV的细节说明.

• 第22课

• 第23课

• 第24课
  讲解了虚拟机中的script representation of integer. C语言实现
  重温了如何编写基于stack machine的script, 简洁的实现fibbonacci 等.

1. 区块链原理机制与背景

1.1 解释比特币

2008年,署名中本聪的作者在讨论加密的邮件列表中,发表论文:A Peer to Peer Electronic Cash System. 2009年1月,Bitcoin网络诞生,代码开源.

比特币（bitcoin），一种去中心化的点对点的网上货币，在没有任何资产担保、内在价值或者中心发行者的情况下维持着价值。
传统互联网解决了信息的传递,而基于区块链的比特币解决了价值的传递.

1.2 区块链与比特币机制图示

区块链起源于bitcoin,
通过分布式账本,去中心化的存储,去第三方中介,解决了信任问题.

以区块链技术为核心的系统会形成如下的效果:
1. 全球化的, 没有中心节点, 数据分布式地存储在系统的各个节点上, 即使绝大部分节点毁灭了,只要还有1个节点存在,就可以重建并还原区块链数据.
2. 自治的交易体系,所有节点都是对等的,每个节点都可以自由加入和离开,按照相同的规则达成共识,自行产生区块并且同步数据,无需人工参与.
3. 按照合约执行,各个节点按照既定的运行规则执行,一旦出现违背规则的行为,就会被其他节点抛弃;智能合约包括在每个交易中,交易验证必须先运行智能合约,只有通过验证交易才能被接受.
4. 数据公开透明,不能被篡改,交易之间有一定的关联性,容易追溯.

下图是比特币的交易的运行机制解释:

1.2.1 区块链应用

Below is a quick description of each of the use cases:

App development: Proof of ownership of modules in app development

Digital content: Proof of ownership for digital content storage and delivery

Ride-sharing: Points-based value transfer for ride-sharing

Digital security trading: Ownership and transfer

Digitization of documents/contracts: Digitization of documents/contracts and proof of ownership for transfers

Decentralized storage: Decentralized storage using a network of computers on blockchain

Company incorporations: Digitizing company incorporations, transfer of equity/ownership and governance

Decentralized Internet and computing resources: Decentralized Internet and computing resources to cover every home and business

Home automation: Platform to link the home network and electrical devices to the cloud

Digital identity: Provides digital identity that protects consumer privacy

Escrow/custodian service: Escrow/custodian service for the gaming industry; loan servicing and e-commerce

IT portal: A smart contract IT portal executing order fulfillment in ecommerce/manufacturing

Patient records: Decentralized patient records management

Digitizing assets: Improves anti-counterfeit measures

Reputation management: Helps users engage, share reputation and collect feedback

Prediction platform: Decentralized prediction platform for the share markets, elections, etc.

Enables authenticity of a review: Enables authenticity of a review through trustworthy endorsements for employee peer reviews

Marketplace for sales and purchases of digital assets: Proof of ownership and a marketplace for sales and purchases of digital assets

1.3 区块链数据结构图示

在比特币社区里，Transaction 被简称为 TX

https://en.bitcoin.it/wiki/Protocol_documentation

区块链概要图示

交易图示

交易与基本节点结构

没有余额的概念, 一个人的资产来自以往的所有交易.

1.4 知识点

UTXO

UTXO 代表 Unspent Transaction Output。

要理解UTXO，最简单的办法就是把一枚比特币从诞生到在商海中沉浮的经历描述一下。我们假设一个这样的场景：张三挖到12.5 枚比特币。过了几天，他把其中 2.5 枚支付给李四。又过了几天，他和李四各出资 2.5 比特币凑成 5 比特币付给王五。

如果是基于账户的设计，张、李、王三人在数据库中各有一个账户，则他们三人的账户变化如下图所示：

在比特币中，这个过程是通过 UTXO 实现的，图示如下：

上图来自: http://8btc.com/article-4381-1.html
当我们说张三拥有 10枚比特币的时候，我实际上是说，当前区块链账本中，有若干笔交易的 UTXO 项收款人写的是张三的地址，而这些 UTXO 项的数额总和是 10。因为在比特币系统里，一个人可以拥有的地址资源，可谓取之不尽用之不竭。要知道自己的一大堆地址里一共收了多少UTXO，人是算不过来的，需要由比特币钱包代为跟踪计算。

SPV

钱包不用下载所有的交易记录就能验证.

钱包

2012 发明了思维钱包的概念, 容易猜, 钱被偷盗的可能性增加了.

冷钱包:
所有的私钥都是从数字来的, 从随机生产器来的. 自己指定的

不联网的计算机, 把数字存在上面.
联网的计算机把不签名的交易 放在u盘上, 然后

理论上, 病毒影响 U盘.
更安全的是, 造一个地址, 从来不发钱. 只用来收钱.
发一次, 冷地址就变热地址了.

1.5 安全性

50% Attack 百分之五十攻击
控制超过51%算力的时候, 可以修改节点程序, 忽略某种交易.
也可以从一个旧节点开始,建立一条新的节点链,超过旧节点后的节点长度后, 原来就节点上的所有交易就被废弃了, 因为所有节点都开始挖最长的节点.

Transaction Malleability Attack 交易挠曲攻击

Double Spending Attack 重叠耗资攻击

Replay Attack 重放攻击
分叉时

DDoS Attack 分布服务扣缴攻击

Delay Attack 延迟攻击

Partition Attack 割据攻击

1.6 比特币特性

Signing-Only Wallets
两台电脑, 一个台连接网络,运行节点钱包,但没有私钥. 另外一台没网络的把私钥放上去.
这样能防止任何网络上的攻击者来偷钥匙钥匙.
很多企业都是这么做的. 对于复杂的usb病毒, windows之间用过的u盘, 放到linux下格式化.

这个的严格程度,还不如cold Wallets, 创造私钥,打印出来,毁灭计算机. 用时再输入到计算机.

2.区块链基本结构

2.1 区块图示

结构示意:

或者如下图示意:

Merkle root 存的hash是为了确保身部所有的交易无法被修改.
Previous Hash是对前一个区块的头header的hash.

4个连续区块及相应交易的例子展示

设计理念

During system design, the major data structure for the software are identified; without these, the system modules cannot be mean
software cannot be meaningfully repaired only rewritten.

从2008年末中本聪的白皮书发出到2009年初中本聪的程序完成,有4个月时间。
开始设计好了，后期的维护成本会很小。
一如Unix的设计理念。

2.2 区块定义

出于教学的目的，为了便于理解，CCN设计得非常简洁，保留了核心的部分，去掉了不必要的部分。

ConciseCoin（CCN）是一个数码货币系统。

BLOCK := HEAD, TRANSACTION*
HEAD := current(32), nonce(4), previous(32), target(32), time(4), valence(4)
TRANSACTION := A, B, C, INPUT*, OUTPUT*
INPUT := A, index(4), B, public(B), C, signature(C), transaction(32)
OUTPUT := A, B, address(B), amount(8)

HEAD - 5 attribute   108BYTE
BODY - 1 or more TRANSACTION
TRANSACTION  - 1 or more  INPUT and OUTPUT
            COINBASE  (创始, 挖矿奖励)

HEAD
   CURRENT: 32
   NONCE: 4
   PREVIOUS: 32 -> completely zero if genesis block
   TARGET: 32
   TIME: 4
BODY
   TRANSACTION #1
      INPUTS: 1个
         INDEX: 4 -> completely zero
         PUBLIC: 0
         SIGNATURE: 0
         TRANSACTION: 32 -> completely zero
      OUTPUTS: 1个
         ADDRESS: 灵活 -> miner's address
         AMOUNT: 8 -> 50 或者 100 (挖矿奖励)
   TRANSACTION #2
   TRANSACTION #3
      INPUTS: 1个或者多个
         INDEX: 4
         PUBLIC: 灵活
         SIGNATURE: 灵活
         TRANSACTION: 32
      OUTPUTS: 1个或者多个
         ADDRESS: 灵活
         AMOUNT: 8

2.3 密码学算法实现步骤简要说明

随机数字 -> 私钥 -> 公钥 -> 地址

加密和解密最大的危险就是是否产生真正的随机数.

a = open ("/dev/arandom")  打开文件
b = read (a 128)       随机数包括[0 - 256)
c = get.private (b)    私钥
d = get.public (c)     公钥
e = get.address (d)    地址

2.4 交易过程说明

2.4.1 交易过程图示

2.4.2 区块中第1个交易用于矿工

第1个交易是矿工奖励, Transaction中的output要设为矿工的地址, 这里的实现用公钥代替.
所以构建时,要取得矿工的地址.

3. 加解密算法实现

3.1 安全库说明

不是操作系统或者标准化的函数库叫做第三方库.
libtomcrypt是个第三方库.
1. Libtomcrypt
2. OpenSSL

3.2 代码实现说明

3.2.1 md5

md5 输出 128bit, 每8bit为1个字节, 也就是16个字节, 1个字节2^8 [0,256)用2个字母表示(00-ff), 共计32个字母
换成sha256时, 需要把16字节out数组改为32字节out

// MD5输出128bit  SHA1输出160bit SHA256输出256bit .    
// c语言里 %x表示16进制, 会输出2个字母.  
// SHA256 输出 256bit, 32个字节, 64个字符.  
#include "tomcrypt.h"
int main(int count, char **arguments)
{
  hash_state md;
  unsigned char *in = "lijun", out[16];
  /* setup the hash */
  md5_init(&md);
  /* add the message */
  md5_process(&md, in, strlen(in));
  /* get the hash in out[0..15] */
  md5_done(&md, out);
  for(int i = 0; i < 16; i++)
  {
     printf("%02x", out[i]);    // %02x 表示输出2个字符的16进制,否则0时会省略掉.
  }
  printf("\n");
  return 0;
}
}

3.2.2 sha256

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "tomcrypt.h"   //密码库
char *get_file(char *path){             //读取文件
        FILE *file;
        int length;
        char *contents;
        //获取文件长度
        file = fopen(path , "r+");
        fseek(file , 0 , SEEK_END);     //跳到文件结尾
        length = ftell(file);           //给出文件长度
        fseek(file , 0 ,SEEK_SET);      //再跳回文件开头
        //分配内存，读取文件 
        //! 最初的代码是length+1, 改为length
        contents = malloc(length);  //给文件分配内存
        fread(contents , 1 , length , file);
        //关闭文件, 系统同时打开的文件个数是有限的,约4900+
        fclose(file);
        return contents ;               //返回文件内容
}
void main(){                            //对文本进行Hash加密
        char *input , *output;
        int length;
        output = malloc(1000);          //分配1000字节的内存
        length = 1000;
        input = get_file("essay.txt");  //读取文件
        register_hash(&sha256_desc);    //激活哈希函数，必须！！
        hash_memory(find_hash("sha256") , input , strlen(input) , output , &leng)
        printf("%s" , output);
        //printf("%d%c" , length , 10); //打印长度
        //printf("%02x%c" , output[0] , 10);    //打印第一个字符，%02x：十六进制
}

3.2.3 获取私钥

unsigned char *get_private(unsigned int *length)
{
   prng_state random;  // 随机生产器的状态.
   ecc_key key;      //保存私钥和公钥的数据结构
   unsigned char *buffer;
   buffer = malloc(*length = 1000);
   // 随机生成器状态, 系统随机生成器, ?, 保存位置 
   ecc_make_key(&random, find_prng("sprng"), 32, &key);  //创建一个私钥
   // 把其私钥转换成可打印的字符串.
   ecc_export(buffer, length, PK_PRIVATE, &key);
   return buffer;
}

3.2.4 获取公钥

unsigned char *get_public(unsigned int *length, unsigned char *private)
{
   ecc_key key;
   unsigned char *buffer;
    //导入私钥
   ecc_import(private, *length, &key);
   buffer = malloc(*length = 1000);
   // 输出公钥
   ecc_export(buffer, length, PK_PUBLIC, &key);
   return buffer;
}

3.2.5 编码输出

Extra libraries: TomsFastMath library
每次使用tomcryp函数库时, 必须要有如下一行,这是它的固定规则:
ltc_mp = tfm_desc;

将private, public输出的生字节, 用base64转换成ASCII. 便于和其他人共享.

void main()
{
   unsigned char *private, *public, *buffer;
   unsigned int length_private, length_public, length_buffer;
   ltc_mp = tfm_desc;
   register_prng(&sprng_desc);   //激活函数
   register_hash(&sha256_desc);
   private = get_private(&length_private);
   length_public = length_private;
   public = get_public(&length_public, private);
   buffer = malloc(1000);
   // tomcrypt库函数_ecc_xxx 生产出自己的私钥,  生成的是生字节.
   memset(buffer, 0, 1000);
   base64_encode(private, length_private, buffer, &length_buffer);
   printf("%s%c%c", buffer, 10, 10);
   memset(buffer, 0, 1000);
   base64_encode(public, length_public, buffer, &length_buffer);
   printf("%s%c", buffer, 10);
}

4. 区块数据结构从定义到初步实现

4.1 Head

4.1.1 结构说明

HEAD
   CURRENT: 32
   NONCE: 4
   PREVIOUS: 32 -> completely zero if genesis block
   TARGET: 32
   TIME: 4
   VALENCE: 4

4.1.2 程序数据结构

Head的长度固定是108字节, 所以不需要保存长度.

nounce , target 用于pow, 在链的最初不需要pow, 当有很多个节点创造block时才用到pow,

4.1.3 程序代码

unsigned char *get_head(unsigned char *root)
{
   unsigned char *complete, *y;
   unsigned int *x;
   complete = malloc(104);
   y = malloc(32);
   memcpy(y, root, 32);
   memcpy(complete, y, 32);
   x = malloc(4);
   *x = 0;
   memcpy(complete + 32, x, 4);
   y = malloc(32);
   memset(y, 0, 32);
   memcpy(complete + 36, y, 32);
   y = malloc(32);
   memset(y, 255, 32);
   memcpy(complete + 68, y, 32);
   x = malloc(4);
   *x = time(0);
   memcpy(complete + 100, x, 4);
   return complete;
}

4.2 Body

4.2.1 Transaction-Input

4.2.1.1 结构说明

   TRANSACTION #1 // 第一个区块.
      INPUTS: 1
         INDEX: 4 -> completely zero
         PUBLIC: 0
         SIGNATURE: 0
         TRANSACTION: 32 -> completely zero
   TRANSACTION #2,#3,...  // 之后的区块
      INPUTS: 1个或者以上
         INDEX: 4
         PUBLIC: linghuo
         SIGNATURE: linghuo
         TRANSACTION: 32

4.2.1.2 程序数据结构

4.2.1.3 程序代码

unsigned char *get_input(unsigned int *total)
{
   // A index B public C signature transaction
   char *private, *public, *complete;
   int length;
   int *x;
   unsigned char *y;
   private = get_private(&length);
   public = get_public(&length, private);
   complete = malloc(*total = 48 + length);
   x = malloc(4);
   *x = 48 + length;
   memcpy(complete, x, 4); // 放置总长
   x = malloc(4);
   *x = 0;
   memcpy(complete + 4, x, 4);  //放置Index长
   x = malloc(4);
   *x = length;
   memcpy(complete + 8, x, 4); // 放置public的长度 
   y = malloc(length);
   memcpy(y, public, length);
   memcpy(complete + 12, y, length); // 放置公钥public 
    //!! 应该放置signature 的长度, 和 signature, 因为还未讲到signature的用法, 暂时先不放.
   x = malloc(4);
   *x = 0;
   memcpy(complete + 12 + length, x, 4); //放置Signature长度.
   y = malloc(32);
   memset(y, 0, 32);
   memcpy(complete + 16 + length, y, 32); // 放置Transaction ??
   return complete;
}

4.2.2 Transaction-Output

4.2.2.1 结构说明

第1个交易中的Output

      OUTPUTS: 1个
         ADDRESS: 大小不定 -> 矿工地址
         AMOUNT: 8字节 -> 100或者50

第2+个交易中的Output

      OUTPUTS: 1个
         ADDRESS: 大小不定 -> 地址
         AMOUNT: 8字节 

4.2.2.2 程序数据结构

4.2.2.3 代码

unsigned char *get_output(unsigned int *total)
{
   unsigned char *private, *public, *complete, *y;
   unsigned int length, *x, z;
   private = get_private(&length);
   public = get_public(&length, private);
   // len_A len_B address amount
   // 4 + 4 + B + 8
   complete = malloc(*total = 16 + length);
   x = malloc(4);
   *x = 16 + length;
   memcpy(complete, x, 4); // 设置总长 A
   x = malloc(4);
   *x = length;
   memcpy(complete + 4, x, 4); // 设地址长度 B
   y = malloc(length);
   memcpy(y, public, length);
   memcpy(complete + 8, y, length); // 设置地址, 暂时把公钥作为地址
   y = malloc(8);
   z = 1000;
   memcpy(y, &z, 4);
   memset(y + 4, 0, 4);
   memcpy(complete + 8 + length, y, 8); // 设置8字节的交易数量
   return complete;
}

4.2.3 Transaction

4.2.3.1 结构说明

   TRANSACTION #1
      INPUTS: 1
         INDEX: 4 -> completely zero
         PUBLIC: 0
         SIGNATURE: 0
         TRANSACTION: 32 -> completely zero
      OUTPUTS: 1
         ADDRESS: linghuo -> miner's address
         AMOUNT: 8 -> 50 huozhe 100
   TRANSACTION #2
   TRANSACTION #3
      INPUTS: yige huozhe yishang
         INDEX: 4
         PUBLIC: linghuo
         SIGNATURE: linghuo
         TRANSACTION: 32
      OUTPUTS: yige huozhe yishang
         ADDRESS: linghuo
         AMOUNT: 8

4.2.3.2 程序数据结构

Transaction

结构有变更.

4.2.3.3 程序代码(旧代码,待更改)

unsigned char *get_transaction(unsigned int *total)
{
   unsigned char *input, *output, *complete, *y;
   unsigned int length_input, length_output, *x;
   input = get_input(&length_input);
   output = get_output(&length_output);
   complete = malloc(*total = 12 + length_input + length_output);
   x = malloc(4);    // A
   *x = 12 + length_input + length_output;
   memcpy(complete, x, 4);
   x = malloc(4);
   *x = 1;          // B, 只有1个输入
   memcpy(complete + 4, x, 4);
   x = malloc(4);
   *x = 1;         // C 只有一个输出
   memcpy(complete + 8, x, 4);
   y = malloc(length_input);     // input
   memcpy(y, input, length_input);
   memcpy(complete + 12, y, length_input);
   y = malloc(length_output);    // output
   memcpy(y, output, length_output);
   memcpy(complete + 12 + length_input, y, length_output);
   return complete;
}

4.3 整体结构回顾与区块交易示例

4.3.1 头部和身部(交易)

头部

HEAD - 6 attribute   108BYTE
BODY - 1 or more TRANSACTION
TRANSACTION  - 1 or more  INPUT and OUTPUT
            COINBASE  (创始, 挖矿奖励)

身部

HEAD
   CURRENT: 32
   NONCE: 4
   PREVIOUS: 32 -> completely zero if genesis block
   TARGET: 32
   TIME: 4
   VALENCE: 4
BODY
   TRANSACTION #1
      INPUTS: 1个
         INDEX: 4 -> completely zero
         PUBLIC: 0
         SIGNATURE: 0
         TRANSACTION: 32 -> completely zero
      OUTPUTS: 1个
         ADDRESS: 灵活 -> miner's address
         AMOUNT: 8 -> 50 huozhe 100
   TRANSACTION #2
   TRANSACTION #3
      INPUTS: 1个或者多个
         INDEX: 4
         PUBLIC: 灵活
         SIGNATURE: 灵活
         TRANSACTION: 32
      OUTPUTS: 1个或者多个
         ADDRESS: 灵活
         AMOUNT: 8

4.3.2 各部分具体定义

HEAD:

Transaction

INPUT:

OUTPUT:

4.3.3 区块交易实例

#1: 3930
   [8629] -> YUANXUN(100)
#2: 4479
   [4140] -> YUANXUN(100)
   [7159] YUANXUN/8629/1 -> YUANXUN(99) PANPENG(1)
A index B public C signature transaction

4.4 程序开发实现

4.4.1 常用函数设计

为了方便处理区块字段, 设计了相关函数. 简化常见的操作.

char *string_create(char *old, int length)
char *string_create_improper(char *old)
char *string_create_progression(int a)
int string_measure(char *buffer)
void string_update(char *object, char *buffer, int length)
void string_update_4(char *object, int quantity)
void string_update_8(char *object, uint64_t quantity)
void string_update_initial(char *object, char *initial)
char *string_eject(char *object)
int scan(char *source)

4.4.2 区块及示例区块数据生成

需要说明的是, 因为老师对随机数字比字母单词更敏感,所以实例程序中的变量很多采用了数字来表示. 并无其他深意.

#define TFM_DESC
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "tfm.h"
#include "tomcrypt.h"
char *string_create(char *old, int length)
{
   char *new;
   int *_6157;
   new = malloc(length + 4) + 4;
   memcpy(new, old, length);
   _6157 = (int *) (new - 4);
   *_6157 = length;
   return new;
}
char *string_create_improper(char *old)
{
   char *new;
   int *_7193;
   new = malloc(strlen(old) + 4) + 4;
   memcpy(new, old, strlen(old));
   _7193 = (int *) (new - 4);
   *_7193 = strlen(old);
   return new;
}
char *string_create_progression(int a)
{
   char *c;
   int *_3919;
   c = malloc(a + 4) + 4;
   _3919 = (int *) (c - 4);
   *_3919 = 0;
   return c;
}
int string_measure(char *buffer)
{
   int *_4721;
   _4721 = (int *) (buffer - 4);
   return *_4721;
}
void string_update(char *object, char *buffer, int length)
{
   int *_9492;
   _9492 = (int *) (object - 4);
   memcpy(object + *_9492, buffer, length);
   *_9492 += length;
}
void string_update_4(char *object, int quantity)
{
   int *_7751, *_2888;
   _7751 = (int *) (object - 4);
   _2888 = (int *) (object + *_7751);
   *_2888 = quantity;
   *_7751 += 4;
}
void string_update_8(char *object, uint64_t quantity)
{
   int *_7751;
   uint64_t *_2888;
   _7751 = (int *) (object - 4);
   _2888 = (uint64_t *) (object + *_7751);
   *_2888 = quantity;
   *_7751 += 8;
}
void string_update_initial(char *object, char *initial)
{
   int *_8478, *_5970;
   _8478 = (int *) (object - 4);
   _5970 = (int *) initial;
   memcpy(object + *_8478, initial, *_5970);
   *_8478 += *_5970;
}
char *string_eject(char *object)
{
   char *new;
   int *_6558;
   _6558 = (int *) (object - 4);
   new = malloc(*_6558);
   memcpy(new, object, *_6558);
   return new;
}
char *get_maximal()
{
   char *digest;
   digest = malloc(32);
   memset(digest, 255, 32);
   return digest;
}
char *get_minimal()
{
   char *digest;
   digest = malloc(32);
   memset(digest, 0, 32);
   return digest;
}
int scan(char *source)
{
   int *size;
   size = (int *) source;
   return *size;
}
char *get_file(char *path) {
   FILE *file;
   int length;
   char *contents;
   file = fopen(path, "r+");
   fseek(file, 0, SEEK_END);
   length = ftell(file);
   fseek(file, 0, SEEK_SET);
   contents = malloc(length + 1);
   fread(contents, 1, length, file);
   fclose(file);
   return contents;
}
// same info, after ecc signature, output different sig length because of random number.
char *get_signature(char *object, char *private)
{
   prng_state _1307;
   ecc_key _1317;
   int _1648;
   char *_5497;
   _5497 = malloc(1000);
   _1648 = 1000;
   ecc_import(private, string_measure(private), &_1317);
   ecc_sign_hash(object, string_measure(object), _5497, &_1648, &_1307, find_prng("sprng"), &_1317);
   return string_create(_5497, _1648);
}
unsigned char *get_private(unsigned int *length)
{
   prng_state random;
   ecc_key key;
   unsigned char *buffer;
   buffer = malloc(*length = 1000);
   ecc_make_key(&random, find_prng("sprng"), 32, &key);
   ecc_export(buffer, length, PK_PRIVATE, &key);
   return buffer;
}
unsigned char *get_public(unsigned int *length, unsigned char *private)
{
   ecc_key key;
   unsigned char *buffer;
   ecc_import(private, *length, &key);
   buffer = malloc(*length = 1000);
   ecc_export(buffer, length, PK_PUBLIC, &key);
   return buffer;
}
char *build_input(int _8626, char *_5409, char *_4051, char *_3775)
{
   char *_9016;
   int *_1933;
   _9016 = malloc(48 + string_measure(_5409) + string_measure(_4051));
   _1933 = (int *) _9016;
   *_1933 = 48 + string_measure(_5409) + string_measure(_4051);
   _1933 = (int *) (_9016 + 4);
   *_1933 = _8626;
   _1933 = (int *) (_9016 + 8);
   *_1933 = string_measure(_5409);
   memcpy(_9016 + 12, _5409, string_measure(_5409));
   _1933 = (int *) (_9016 + 12 + string_measure(_5409));
   *_1933 = string_measure(_4051);
   memcpy(_9016 + 16 + string_measure(_5409), _4051, string_measure(_4051));
   memcpy(_9016 + 16 + string_measure(_5409) + string_measure(_4051), _3775, 32);
   return _9016;
}
char *build_output(char *_7095, uint64_t _8432)
{
   char *_3516;
   int *_8347;
   uint64_t *_9910;
   _3516 = malloc(16 + string_measure(_7095));
   _8347 = (int *) _3516;
   *_8347 = 16 + string_measure(_7095);
   _8347 = (int *) (_3516 + 4);
   *_8347 = string_measure(_7095);
   memcpy(_3516 + 8, _7095, string_measure(_7095));
   _9910 = (uint64_t *) (_3516 + 8 + string_measure(_7095));
   *_9910 = _8432;
   return _3516;
}
char *get_sha256(char *buffer, int size)
{
   hash_state resource;
   char *digest;
   digest = malloc(32);
   sha256_init(&resource);
   sha256_process(&resource, buffer, size);
   sha256_done(&resource, digest);
   return digest;
}
char *get_md5(char *buffer, int size)
{
   hash_state resource;
   char *digest;
   digest = malloc(16);
   md5_init(&resource);
   md5_process(&resource, buffer, size);
   md5_done(&resource, digest);
   return digest;
}
char *get_merkle_root(char *old, int size)
{
   char *new, output[32], input[64];
   int index;
   if (size == 1) {
      return old;
   }
   if (size % 2) {
      new = malloc(32 * (size + 1));
      memcpy(new, old, size * 32);
      memcpy(new + size * 32, old + (size - 1) * 32, 32);
      return get_merkle_root(new, size + 1);
   }
   new = malloc(32 * size / 2);
   for (index = 0; index < size; index += 2) {
      memcpy(input, old + index * 32, 64);
      memcpy(new + (index / 2) * 32, get_sha256(input, 64), 32);
   }
   return get_merkle_root(new, size / 2);
}
void print_digest(char *digest)
{
   int index;
   for (index = 0; index < 32; index++)
      printf("%02hhx", digest[index]);
   printf("%c", 10);
}
// ------------------
char *transaction_7159(int A, char *B, char *C, char *D, char *lichangli, char *panpeng)
{
   char *input_0, *output_0, *output_1, *transaction;
   input_0 = build_input(A, B, C, D);
   output_0 = build_output(lichangli, 99);
   output_1 = build_output(panpeng, 1);
   transaction = string_create_progression(12 + scan(input_0) + scan(output_0) + scan(output_1));
   string_update_4(transaction, 12 + scan(input_0) + scan(output_0) + scan(output_1));
   string_update_4(transaction, 1);
   string_update_4(transaction, 2);
   string_update(transaction, input_0, scan(input_0));
   string_update(transaction, output_0, scan(output_0));
   string_update(transaction, output_1, scan(output_1));
   return transaction;
}
char *block_3930(char *A)
{
   char *block;
   block = string_create_progression(108 + string_measure(A)); 
   string_update(block, get_sha256(A, string_measure(A)), 32);
   string_update_4(block, 0);
   string_update(block, get_minimal(), 32);
   string_update(block, get_maximal(), 32);
   string_update_4(block, time(0));
   string_update_4(block, 1);
   string_update(block, A, string_measure(A));
   return block;
}
char *block_4479(char *previous, char *A, char *B)
{
   char *block, *tree;
   tree = string_create_progression(64);
   string_update(tree, get_sha256(A, string_measure(A)), 32);
   string_update(tree, get_sha256(B, string_measure(B)), 32);
   block = string_create_progression(108 + string_measure(A) + string_measure(B));
   string_update(block, get_merkle_root(tree, 2), 32);
   string_update_4(block, 0);
   string_update(block, previous, 32);
   string_update(block, get_maximal(), 32);
   string_update_4(block, time(0));
   string_update_4(block, 2);
   string_update(block, A, string_measure(A));
   string_update(block, B, string_measure(B));
   return block;
}
char *transaction_8629(char *lichangli)
{
   char *input_0, *output_0, *progression;
   input_0 = build_input(0, string_create_improper(""), string_create_improper(""), get_minimal());
   output_0 = build_output(lichangli, 100);
   progression = string_create_progression(12 + scan(input_0) + scan(output_0));
   string_update_4(progression, 12 + scan(input_0) + scan(output_0));
   string_update_4(progression, 1);
   string_update_4(progression, 1);
   string_update(progression, input_0, scan(input_0));
   string_update(progression, output_0, scan(output_0));
   return progression;
}
char *transaction_4140(char *lichangli)
{
   char *input_0, *output_0, *progression;
   input_0 = build_input(0, string_create_improper(""), string_create_improper(""), get_minimal());
   output_0 = build_output(lichangli, 100);
   progression = string_create_progression(12 + scan(input_0) + scan(output_0));
   string_update_4(progression, 12 + scan(input_0) + scan(output_0));
   string_update_4(progression, 1);
   string_update_4(progression, 1);
   string_update(progression, input_0, scan(input_0));
   string_update(progression, output_0, scan(output_0));
   return progression;
}

4.4.3 示例数据写入调用

完成了示例数据的写入, 就方便后面开发读取和验证的部分的代码的测试了.

int main(int count, char **arguments)
{
   ltc_mp = tfm_desc;
   register_prng(&sprng_desc);
   register_hash(&sha256_desc);
   char *A, *B, *C, *BLOCK_A, *BLOCK_B;
   char *_6301, *_1604, *_1215;
   char *buffer;
   int length;
   char *panpeng_address, *panpeng_public, *lichangli_address, *lichangli_public, *lichangli_private;
   _6301 = "MEwDAgcAAgEgAiEAy4Dqak+QdoTjLOneFcw45XLVvRo1pxlurO7CdnSiEmkCIEHKqUkf236XXyybfJWX8dhvHKJXHwJ2TKJ6f2J78OIiMEwDAgcAAgEgAiEAy
4Dqak+QdoTjLOneFcw45XLVvRo1pxlurO7CdnSiEmkCIEHKqUkf236XXyybfJWX8dhvHKJXHwJ2TKJ6f2J78OIi";   
   _1604 = "MEwDAgcAAgEgAiB/XlZGVRCrgg1QoZpLXP25dBxfE+l53GcrQT+rnOyMtQIhAPjOmLLKCkZeuk378KlQCLXGYcx3ZZNpYt2xqPTS6BC/";
   _1215 = "MG8DAgeAAgEgAiB/XlZGVRCrgg1QoZpLXP25dBxfE+l53GcrQT+rnOyMtQIhAPjOmLLKCkZeuk378KlQCLXGYcx3ZZNpYt2xqPTS6BC/AiEAuUgmCNAsw2ElO
5hxpvAzJpKcdSuyiHV84R2jTPFVu7o=";
   buffer = malloc(1000);
   length = 1000;
   base64_decode(_6301, strlen(_6301), buffer, &length);
   panpeng_public = string_create(buffer, length);
   length = 1000;
   base64_decode(_1604, strlen(_1604), buffer, &length);
   lichangli_public = string_create(buffer, length);
   length = 1000;
   base64_decode(_1215, strlen(_1215), buffer, &length);
   lichangli_private = string_create(buffer, length);
   panpeng_address = string_create(get_md5(panpeng_public, 32), 16);
   lichangli_address = string_create(get_md5(lichangli_public, 32), 16);
   A = transaction_8629(lichangli_address);
   B = transaction_4140(lichangli_address);
   C = transaction_7159(1, lichangli_public, get_signature(A, lichangli_private), get_sha256(A, string_measure(A)), lichangli_address
, panpeng_address);
   BLOCK_A = block_3930(A);
   BLOCK_B = block_4479(get_sha256(BLOCK_A, string_measure(BLOCK_A)), B, C);
   write(1, BLOCK_B, string_measure(BLOCK_B));
}

5. 区块节点读取验证与挖矿

5.1 merkle tree 说明

Hash的计算简要示意

交易的hash计算与区块简要示意

5.1.1 递归函数定义

递归计算merkle root
先计算单个.
然后计算奇数的hash,
计算偶数的hash

  pseudo code, author by Lijun
  merkle_root(arr[])
  if(count(arr[]) ==1 ) return arr[0];
  if(count(arr[]) %2 ) 
      return sha256(merkle_root(arr[0,n-2]), arr[n-1])
  else
      return  shar256(merkle_root(arr[0,n/2-1]), merkle_root(arr[n/2, n-1]);

只有一个交易,merkle root就是对这个交易的hash.

• get_merkle_root(X) = X
• get_merkle_root(X0 , X1 ， …… ， X2n ) = get_merkle_root(X0 ,X1 ,…… ，X2n,X2n)
• get_merkle_root(X0 , X1 ， …… ， X2n-1 ) = get_merkle_root(SHA256(X0+X1), SHA256(X2+X3) ……)

 function(x) {
    if (count(x) == 1 ) return x;
    if (count(x) %2) x.push[x, (
 }

5.1.2 php递归实现代码

<?php
function get_lines_file($file)
{
   $result = array();
   $contents = file_get_contents($file);
   $contents = explode(chr(10), $contents); //用换行符分割
   // linux 放10, windows会放13,10作为换行,所以删掉13
   foreach ($contents as $item) {
      $item = str_replace(chr(13), '', $item); // 去掉char13
      if (strlen($item) > 0)
         array_push($result, $item);
   }
   return $result;
}
/*  生成hash. 可以输出存到 文件里.
    $digests = array();
    foreach(range(1,100) as $number)
        $digests[] = hash('sha256', rand());
*/
$x = get_lines_file('digests.txt');   
var_dump(get_Merkle_root($x));
function get_Merkle_root($digests)
{
   if (count($digests) == 1) {
      echo sprintf('Case #1: %d%c', count($digests), 10);
      return $digests[0];
   }
   if (count($digests) % 2) {  // 奇数
      echo sprintf('Case #2: %d%c', count($digests), 10);
      $item = $digests[count($digests) - 1];
      array_push($digests, $item);   // push, 把最后1个item复制
      return get_Merkle_root($digests);
   }
   echo sprintf('Case #3: %d%c', count($digests), 10);
   for ($i = 0, $s = count($digests) / 2; $i < $s; $i++) {
      $a = array_shift($digests);   // 从左侧移出
      $b = array_shift($digests);   // 组成一对计算hash.
      array_push($digests, hash('sha256', $a . $b));  //从右侧插入
   }
   return get_Merkle_root($digests);
   /* 另外一种方法, 新建一个数组reduced存放
   $i = 0;
   while($i < count($digests)){
     $merged= sprintf('%s%s',$digests[i[,$digests[i+1]);
     array_push($reduced, hash('sha256',$merged));
     $i += 2;
   }
   return get_Merkle_root($reduced);
   */
}