NodeJS实现简易区块链
r8kao8k8
发表于 2023-1-2 20:25:20
115
0
0
之前由于课程要求,基于Nodejs做了一个实现简易区块链。要求非常简单,结构体记录区块结构,顺便能向链中插入新的区块即可。
但是如果要支持多用户使用,就需要考虑“可信度”的问题。那么按照区块链要求,链上的数据不能被篡改,除非算力超过除了攻击者本身之外其余所以机器的算力。' T% M# }; J+ [% f4 d% ?# N' G: ~
想了想,就动手做试试咯。. \5 d7 n+ l5 R& H
?查看全部教程 / 阅读原文?/ z, }' J3 h9 o) g; K9 d% K0 n% P
技术调研
在google上搜了搜,发现有个项目不错: https://github.com/lhartikk/naivechain 。大概只有200行,但是其中几十行都是关于搭建ws和http服务器,美中不足的是没有实现批量插入区块链和计算可信度。# R8 ?7 R, d: M
结合这个项目,基本上可以确定每个区块会封装成一个class(结构化表示),区块链也封装成一个class,再对外暴露接口。
区块定义( S2 b3 d' R/ \2 ?# B2 o ~1 t5 L
为了方便表示区块,将其封装为一个class,它没有任何方法:1 Z# D( W* t: B
/**
* 区块信息的结构化定义 C& }$ h$ V2 Y W5 R. Y
*/6 Q$ | a# Z M' Y( L4 j7 Z
class Block {4 M4 w7 [' B* P. J. ]
/**
* 构造函数' y U: G/ b. f5 k" L6 \/ H
* @param {Number} index
* @param {String} previousHash 0 w7 u/ d. X; J: Y$ P7 w
* @param {Number} timestamp " P6 G4 B1 J) l
* @param {*} data 9 d# l+ b, O9 i8 G8 R. ]
* @param {String} hash
*/# t* J4 f2 k, u) ?
constructor(index, previousHash, timestamp, data, hash) {! u* G# F% s v/ s. z
this.index = index // 区块的位置0 b. G: J! [. U+ j
this.previousHash = previousHash + '' // 前一个区块的hash7 E0 P8 \& m# b1 H7 Z/ T( K% p
this.timestamp = timestamp // 生成区块时候的时间戳/ G( J" S" b! \" c- F
this.data = data // 区块本身携带的数据; W5 x9 o( F3 |4 h
this.hash = hash + '' // 区块根据自身信息和规则生成的hash
}
}. i- Z* h, ?2 M |
至于怎么生成hash,这里采用的规则比较简单:
拼接index、previouHash、timestamp和data,将其字符串化利用sha256算法,计算出的记过就是hash' f' O. k4 \# D0 R; H" d
为了方便,会引入一个加密库:
const CryptoJS = require('crypto-js') |3 z8 a; T+ o: H
链结构定义
很多区块链接在一起,就组成了一条链。这条链,也用class来表示。并且其中实现了很多方法:+ F" {; V/ l( H* F
按照加密规则生成hash插入新块和检查操作批量插入块和检查操作以及可信度计算) Y2 U) A) E# q2 L% Y% X. ?* v
8 i/ n$ a$ m% \9 x& s
1. 起源块# v: X8 s* O8 R6 W7 u% m
起源块是“硬编码”,因为它前面没数据呀。并且规定它不能被篡改,即不能强制覆盖。我们在构造函数中,直接将生成的起源块放入链中。( V7 O; d' w& ]2 Y
class BlockChain {
constructor() {! q7 W# z; [+ u+ g t) F
this.blocks = [this.getGenesisBlock()]
}7 F& X# T4 R+ X t' h( T
/**
* 创建区块链起源块, 此块是硬编码
*/9 b2 y6 }; T* q3 b( P N0 u
getGenesisBlock() {, {& ^$ U; P8 c m- S. ~$ V; s) l
return new Block(0, '0', 1552801194452, 'genesis block', '810f9e854ade9bb8730d776ea02622b65c02b82ffa163ecfe4cb151a14412ed4')
}
}0 E6 O, a2 N6 ?2 M& }
2. 计算下一个区块
BlockChain对象可以根据当前链,自动计算下一个区块。并且与用户传来的区块信息比较,如果一样,说明合法,可以插入;否则,用户的区块就是非法的,不允许插入。
// 方法都是BlockChain对象方法) N7 e" v9 ^ U7 I8 B* [- ~6 G
/**
* 根据信息计算hash值5 D$ s- }6 Y9 f: A, x
*/
calcuteHash(index, previousHash, timestamp, data) {
return CryptoJS.SHA256(index + previousHash + timestamp + data) + ''
}) y, u8 E* B( G2 L4 p7 u
/**
* 得到区块链中最后一个块节点# N5 `$ g( o8 G- M" J7 s/ o
*/
getLatestBlock() {! H# \8 p! J$ V% B0 G4 |- w7 _
return this.blocks[this.blocks.length - 1]% F- B* C3 g7 n6 Q
}( C w" x5 i; k! t' [
/**, t' f2 @; X( C* ~7 ]4 s) F
* 计算当前链表的下一个区块) e7 W5 _) J* J
* @param {*} blockData
*/
generateNextBlock(blockData) {! ]$ ~/ `% \8 O5 X3 ^
const previousBlock = this.getLatestBlock()
const nextIndex = previousBlock.index + 16 G& F2 L' ~6 w
const nextTimeStamp = new Date().getTime()' d/ r$ a) w S/ u1 R* m G
const nextHash = this.calcuteHash(nextIndex, previousBlock.hash, nextTimeStamp, blockData)3 ]# H9 v2 L( ^3 i9 d' y8 q
return new Block(nextIndex, previousBlock.hash, nextTimeStamp, blockData, nextHash)
}7 ~$ H" a, z8 Y9 x) O
3. 插入区块, I. {' j/ ]& Y( O3 ]! G) T
插入区块的时候,需要检查当前块是否合法,如果合法,那么插入并且返回true;否则返回false。
/**
* 向区块链添加新节点/ n J) H3 p1 |
* @param {Block} newBlock
*/: g3 _, Q2 _* H L* Z7 c$ ]
addBlock(newBlock) {1 _: m: O/ z8 U7 l
// 合法区块7 Y0 x- ^: p2 {: l1 P3 a
if(this.isValidNewBlock(newBlock, this.getLatestBlock())) {
this.blocks.push(newBlock)
return true
}
return false
}$ W0 Q5 g% m, B
检查的逻辑就就放在了 isValidNewBlock 方法中, 它主要完成3件事情:
判断新区块的index是否是递增的判断previousHash是否和前一个区块的hash相等判断新区块的hash是否按约束好的规则生成
/**4 N9 {+ E/ L" c
* 判断新加入的块是否合法
* @param {Block} newBlock + @' p/ Q& I( V9 b' q& K8 {6 N: M
* @param {Block} previousBlock
*/" l* m. z9 z0 P8 q$ P L7 n
isValidNewBlock(newBlock, previousBlock) {
if(
!(newBlock instanceof Block) ||8 z( s' p: k9 y- c5 u
!(previousBlock instanceof Block): W* B+ v4 g' Y. k8 X
) {
return false
}
// 判断index& u( h4 L. S0 E' i `# y2 y# E7 l
if(newBlock.index !== previousBlock.index + 1) {
return false8 y5 x5 j8 T2 o" x& |4 i
}" m& V$ q- q5 {% T9 A) I
// 判断hash值: l9 d! G5 D0 u2 |" e, s9 C) _
if(newBlock.previousHash !== previousBlock.hash) {
return false
}
// 计算新块的hash值是否符合规则
if(this.calcuteHash(newBlock.index, newBlock.previousHash, newBlock.timestamp, newBlock.data) !== newBlock.hash) { # i3 I) b9 c/ F$ U& a5 I
return false6 W( ~% D3 ]: u
}8 E: j* g) q) p6 g: o- \! G) P
return true, x5 M/ [9 j! b0 U
}
4. 批量插入# x1 e0 m: ]( ~6 x: S4 m- u
批量插入的逻辑比较复杂,比如当前链上有4个区块的下标是:0->1->2->3。除了起源块0不能被覆盖,当插入一条新的下标为“1->2->3->4”的链时候,就可以替换原来的区块。最终结果是:0->1->2->3->4。
在下标index的处理上,假设还是上面的情况,如果传入的链的下标是从大于4的整数开始,显然无法拼接原来的区块链的下标,直接扔掉。
但是如何保证可信度呢?就是当新链(B链)替换原来的链(A链)后,生成新的链(C链)。如果 length© > length(A),那么即可覆盖要替换的部分。 这就保证了,只有在算力超过所有算力50%的时候,才能篡改这条链 。9 A, \3 b) ~ R* t3 c
插入新链的方法如下:- b- m* s# Q5 m. T7 [: D; }# z
/**
* 插入新链表
* @param {Array} newChain , x9 e- q3 e, P% X5 f
*/4 S% H4 `( I6 Y" Y' C
addChain(newChain) {
if(this.isValidNewChain(newChain)) {
const index = newChain[0].index# A/ a) S' y9 @1 u8 m6 o8 f
this.blocks.splice(index)
this.blocks = this.blocks.concat(newChain)
return true
}
return false1 a, Y2 n- u( x9 F
}
实现上面所述逻辑的方法如下:
/**; X7 V9 k& S7 ]5 V$ z
* 判断新插入的区块链是否合法而且可以覆盖原来的节点
* @param {Array} newChain
*/
isValidNewChain(newChain) {) |* b% `8 |$ P, M( M7 p
if(Array.isArray(newChain) === false || newChain.length === 0) {
return false9 ]2 R+ j% ]1 P5 s
}
let newChainLength = newChain.length,
firstBlock = newChain[0] Y1 ?( T% S9 v! K r4 `
// 硬编码的起源块不能改变 o9 a- [; c i- @! m4 S
if(firstBlock.index === 0) {: W" Z$ p' h1 P, R; ^4 Q
return false
}
// 移植新的链的长度
5. 为什么需要批量插入?
我当时很奇怪,为什么需要“批量插入”这个方法。后来想明白了(希望没想错)。假设服务器S,以及两个用户A与B。- h2 v; d! F) o- c& }) e4 V$ A6 v
A与B同时拉取到已知链的数据,然后各自生成。A网速较快,但是算力低,就生成了1个区块,放入了S上。注意:此时S上的区块已经更新。
而B比较惨了,它在本地生成了2个区块,但是受限于网速,只能等网速恢复了传入区块。这时候,按照规则,它是可以覆盖的(算力高嘛)。所以这种情况下,服务器S接受到B的2个区块,更新后的链长度是3(算上起源块),并且A的那个区块已经被覆盖了。
效果测试6 N0 K3 f3 G0 ?
虽然没有写服务器,但是还是模拟了上面讲述的第5种情况。代码在 test.js 文件中,直接run即可。看下效果截图吧:
红线上面就是先算出来的,红线下面就是被算力更高的客户端篡改后的区块链。具体模拟过程可以看代码,这里不再冗赘了。
全部代码在都放在: https://github.com/dongyuanxin/node-blockchain
成为第一个吐槽的人