数字签名(digital signature)

论坛 › 期权论坛 › 期权     
枭一   2020-3-28 02:15   1251   0
在数学和密码学中，有一个数字签名（digital signature）的概念，算法可以保证：
  • 当数据从发送方传送到接收方时，数据不会被修改；
  • 数据由某一确定的发送方创建；
  • 发送方无法否认发送过数据这一事实。
通过在数据上应用签名算法（也就是对数据进行签名），你就可以得到一个签名，这个签名晚些时候会被验证。生成数字签名需要一个私钥，而验证签名需要一个公钥。签名有点类似于印章，比方说我做了一幅画，完了用印章一盖，就说明了这幅画是我的作品。给数据生成签名，就是给数据盖了章。
[h1]1. 课程目标[/h1]
  • 知道什么是数字签名
  • 知道为什么要进行签名和验签
  • 学会如何进行签名
  • 学会在何处使用签名
[h1]2. 项目代码及效果展示[/h1][h2]2.1 项目代码结构[/h2]

[h2]2.2 项目运行结果[/h2][iframe]https://mp.weixin.qq.com/mp/readtemplate?t=pages/video_player_tmpl&action=mpvideo&auto=0&vid=wxv_847121304712101888[/iframe]
其实运行效果和之前的没有区别，因为我们并没有增加新的功能，只是在创建交易的时候，添加了数字签名，在创建新区块的时候，进行签名验证。
[h1]3. 创建项目[/h1][h2]3.1 创建工程[/h2]打开IntelliJ IDEA的工作空间，将上一个项目代码目录
  1. part6_Wallet
复制代码
，复制为
  1. part7_Signature
复制代码
。
然后打开IntelliJ IDEA开发工具。
打开工程：
  1. part7_Signature
复制代码
，并删除target目录。然后进行以下修改：
  1. step1：先将项目重新命名为：part7_Signature。
  2. step2：修改pom.xml配置文件。
  3. 改为：part7_Signature标签
  4. 改为：part7_Signature Maven Webapp
  6. 说明：我们每一章节的项目代码，都是在上一个章节上进行添加。
  7. 所以拷贝上一次的项目代码，然后进行新内容的添加或修改。
复制代码
[h2]3.2 代码实现[/h2][h3]3.2.1 修改
  1. TXOutput.java
复制代码
文件[/h3]打开
  1. cldy.hanru.blockchain.transaction
复制代码
包，修改
  1. TXOutput.java
复制代码
文件。
修改步骤：
  1. 修改步骤：
  2. step1：修改字段pubKeyHash
  3. step2：添加方法isLockedWithKey()
  4. step3：添加方法newTXOutput()
复制代码
修改完后代码如下：
  1. package cldy.hanru.blockchain.transaction;
  4. import cldy.hanru.blockchain.util.Base58Check;
  5. import lombok.AllArgsConstructor;
  6. import lombok.Data;
  7. import lombok.NoArgsConstructor;
  9. import java.util.Arrays;
  11. /**
  12. * @author hanru
  13. */
  14. @Data
  15. @AllArgsConstructor
  16. @NoArgsConstructor
  17. public class TXOutput {
  19. /**
  20. * 数值金额
  21. */
  22. private int value;
  23. /**
  24. * 锁定脚本
  25. */
  26. // private String scriptPubKey;
  29. /**
  30. * 公钥Hash
  31. */
  32. private byte[] pubKeyHash;
  33. /**
  34. * 判断解锁数据是否能够解锁交易输出
  35. *
  36. * @param unlockingData
  37. * @return
  38. */
  39. // public boolean canBeUnlockedWith(String unlockingData) {
  40. //
  41. // return this.getScriptPubKey().endsWith(unlockingData);
  42. // }
  45. /**
  46. * 检查交易输出是否能够使用指定的公钥
  47. *
  48. * @param pubKeyHash
  49. * @return
  50. */
  51. public boolean isLockedWithKey(byte[] pubKeyHash) {
  52. return Arrays.equals(this.getPubKeyHash(), pubKeyHash);
  53. }
  55. /**
  56. * 创建交易输出
  57. *
  58. * @param value
  59. * @param address
  60. * @return
  61. */
  62. public static TXOutput newTXOutput(int value, String address) {
  63. // 反向转化为 byte 数组
  64. byte[] versionedPayload = Base58Check.base58ToBytes(address);
  65. byte[] pubKeyHash = Arrays.copyOfRange(versionedPayload, 1, versionedPayload.length);
  66. return new TXOutput(value, pubKeyHash);
  67. }
  68. }
复制代码
[h3]3.2.2 修改
  1. TXInput.java
复制代码
文件[/h3]打开
  1. cldy.hanru.blockchain.transaction
复制代码
包，修改
  1. TXInput.java
复制代码
文件。
修改步骤：
  1. 修改步骤：
  2. step1：修改字段signature和pubKey
  3. step2：添加方法usesKey()
复制代码
修改完后代码如下：
  1. package cldy.hanru.blockchain.transaction;
  3. import cldy.hanru.blockchain.util.AddressUtils;
  4. import lombok.AllArgsConstructor;
  5. import lombok.Data;
  6. import lombok.NoArgsConstructor;
  8. import java.util.Arrays;
  10. /**
  11. * @author hanru
  12. */
  13. @AllArgsConstructor
  14. @NoArgsConstructor
  15. @Data
  16. public class TXInput {
  19. /**
  20. * 交易Id的hash值
  21. */
  22. private byte[] txId;
  23. /**
  24. * 交易输出索引
  25. */
  26. private int txOutputIndex;
  27. /**
  28. * 解锁脚本
  29. */
  30. // private String scriptSig;
  33. /**
  34. * 签名
  35. */
  36. private byte[] signature;
  37. /**
  38. * 公钥
  39. */
  40. private byte[] pubKey;
  43. /**
  44. * 判断解锁数据是否能够解锁交易输出
  45. *
  46. * @param unlockingData
  47. * @return
  48. */
  49. // public boolean canUnlockOutputWith(String unlockingData) {
  50. // return this.getScriptSig().endsWith(unlockingData);
  51. // }
  54. /**
  55. * 检查公钥hash是否用于交易输入
  56. *
  57. * @param pubKeyHash
  58. * @return
  59. */
  60. public boolean usesKey(byte[] pubKeyHash) {
  61. byte[] lockingHash = AddressUtils.ripeMD160Hash(this.getPubKey());
  62. return Arrays.equals(lockingHash, pubKeyHash);
  63. }
  64. }
复制代码
[h3]3.2.3 修改
  1. Transaction.java
复制代码
文件[/h3]打开
  1. cldy.hanru.blockchain.transaction
复制代码
包，修改
  1. Transaction.java
复制代码
文件。
修改步骤：
  1. 修改步骤：
  2. step1：修改newCoinbaseTX()方法
  3. step2：添加getData()
  4. step3：添加TrimmedCopy()方法，用于备份签名和验证时交易的副本。
  5. step4：添加Sign()方法，用于进行交易签名
  6. step5：添加Verify()方法，用于签名验证
复制代码
修改完后代码如下：
  1. package cldy.hanru.blockchain.transaction;
  4. import cldy.hanru.blockchain.block.Blockchain;
  5. import cldy.hanru.blockchain.util.AddressUtils;
  6. import cldy.hanru.blockchain.util.SerializeUtils;
  7. import cldy.hanru.blockchain.wallet.Wallet;
  8. import cldy.hanru.blockchain.wallet.WalletUtils;
  9. import lombok.AllArgsConstructor;
  10. import lombok.Data;
  11. import lombok.NoArgsConstructor;
  12. import org.apache.commons.codec.binary.Hex;
  13. import org.apache.commons.codec.digest.DigestUtils;
  14. import org.apache.commons.lang3.ArrayUtils;
  15. import org.apache.commons.lang3.StringUtils;
  16. import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
  17. import org.bouncycastle.jce.ECNamedCurveTable;
  18. import org.bouncycastle.jce.provider.BouncyCastleProvider;
  19. import org.bouncycastle.jce.spec.ECParameterSpec;
  20. import org.bouncycastle.jce.spec.ECPublicKeySpec;
  21. import org.bouncycastle.math.ec.ECPoint;
  23. import java.math.BigInteger;
  24. import java.security.KeyFactory;
  25. import java.security.PublicKey;
  26. import java.security.Security;
  27. import java.security.Signature;
  28. import java.util.Arrays;
  29. import java.util.Iterator;
  30. import java.util.Map;
  32. /**
  33. * @author hanru
  34. */
  35. @Data
  36. @AllArgsConstructor
  37. @NoArgsConstructor
  38. public class Transaction {
  39. private static final int SUBSIDY = 10;
  41. /**
  42. * 交易的Hash
  43. */
  44. private byte[] txId;
  45. /**
  46. * 交易输入
  47. */
  48. private TXInput[] inputs;
  49. /**
  50. * 交易输出
  51. */
  52. private TXOutput[] outputs;
  54. /**
  55. * 设置交易ID
  56. */
  57. private void setTxId() {
  58. this.setTxId(DigestUtils.sha256(SerializeUtils.serialize(this)));
  59. }
  64. /**
  65. * 要签名的数据
  66. * @return
  67. */
  68. public byte[] getData() {
  69. // 使用序列化的方式对Transaction对象进行深度复制
  70. byte[] serializeBytes = SerializeUtils.serialize(this);
  71. Transaction copyTx = (Transaction) SerializeUtils.deserialize(serializeBytes);
  72. copyTx.setTxId(new byte[]{});
  73. return DigestUtils.sha256(SerializeUtils.serialize(copyTx));
  74. }
  79. /**
  80. * 创建CoinBase交易
  81. *
  82. * @param to 收账的钱包地址
  83. * @param data 解锁脚本数据
  84. * @return
  85. */
  86. public static Transaction newCoinbaseTX(String to, String data) {
  87. if (StringUtils.isBlank(data)) {
  88. data = String.format("Reward to '%s'", to);
  89. }
  90. // 创建交易输入
  91. // TXInput txInput = new TXInput(new byte[]{}, -1, data);
  92. TXInput txInput = new TXInput(new byte[]{}, -1, null, data.getBytes());
  93. // 创建交易输出
  94. // TXOutput txOutput = new TXOutput(SUBSIDY, to);
  95. TXOutput txOutput = TXOutput.newTXOutput(SUBSIDY, to);
  96. // 创建交易
  97. Transaction tx = new Transaction(null, new TXInput[]{txInput}, new TXOutput[]{txOutput});
  98. // 设置交易ID
  99. tx.setTxId();
  101. // tx.setTxId(tx.hash());
  102. return tx;
  103. }
  105. /**
  106. * 从 from 向 to 支付一定的 amount 的金额
  107. *
  108. * @param from 支付钱包地址
  109. * @param to 收款钱包地址
  110. * @param amount 交易金额
  111. * @param blockchain 区块链
  112. * @return
  113. */
  114. public static Transaction newUTXOTransaction(String from, String to, int amount, Blockchain blockchain) throws Exception {
  116. // 获取钱包
  117. Wallet senderWallet = WalletUtils.getInstance().getWallet(from);
  118. byte[] pubKey = senderWallet.getPublicKey();
  119. byte[] pubKeyHash = AddressUtils.ripeMD160Hash(pubKey);
  121. // SpendableOutputResult result = blockchain.findSpendableOutputs(from, amount);
  122. SpendableOutputResult result = blockchain.findSpendableOutputs(pubKeyHash, amount);
  123. int accumulated = result.getAccumulated();
  124. Map unspentOuts = result.getUnspentOuts();
  126. if (accumulated < amount) {
  127. throw new Exception("ERROR: Not enough funds");
  128. }
  129. Iterator iterator = unspentOuts.entrySet().iterator();
  131. TXInput[] txInputs = {};
  132. while (iterator.hasNext()) {
  133. Map.Entry entry = iterator.next();
  134. String txIdStr = entry.getKey();
  135. int[] outIdxs = entry.getValue();
  136. byte[] txId = Hex.decodeHex(txIdStr);
  137. for (int outIndex : outIdxs) {
  138. // txInputs = ArrayUtils.add(txInputs, new TXInput(txId, outIndex, from));
  139. txInputs = ArrayUtils.add(txInputs, new TXInput(txId, outIndex, null, pubKey));
  140. }
  141. }
  143. TXOutput[] txOutput = {};
  144. // txOutput = ArrayUtils.add(txOutput, new TXOutput(amount, to));
  145. txOutput = ArrayUtils.add(txOutput, TXOutput.newTXOutput(amount, to));
  146. if (accumulated > amount) {
  147. // txOutput = ArrayUtils.add(txOutput, new TXOutput((accumulated - amount), from));
  148. txOutput = ArrayUtils.add(txOutput, TXOutput.newTXOutput((accumulated - amount), from));
  150. }
  152. Transaction newTx = new Transaction(null, txInputs, txOutput);
  153. newTx.setTxId();
  155. // newTx.setTxId(newTx.hash());
  157. // 进行交易签名
  158. blockchain.signTransaction(newTx, senderWallet.getPrivateKey());
  160. return newTx;
  161. }
  163. /**
  164. * 是否为 Coinbase 交易
  165. *
  166. * @return
  167. */
  168. public boolean isCoinbase() {
  169. return this.getInputs().length == 1
  170. && this.getInputs()[0].getTxId().length == 0
  171. && this.getInputs()[0].getTxOutputIndex() == -1;
  172. }
  174. /**
  175. * 创建用于签名的交易数据副本，交易输入的 signature 和 pubKey 需要设置为null
  176. *
  177. * @return
  178. */
  179. public Transaction trimmedCopy() {
  180. TXInput[] tmpTXInputs = new TXInput[this.getInputs().length];
  181. for (int i = 0; i < this.getInputs().length; i++) {
  182. TXInput txInput = this.getInputs()[i];
  183. tmpTXInputs[i] = new TXInput(txInput.getTxId(), txInput.getTxOutputIndex(), null, null);
  184. }
  186. TXOutput[] tmpTXOutputs = new TXOutput[this.getOutputs().length];
  187. for (int i = 0; i < this.getOutputs().length; i++) {
  188. TXOutput txOutput = this.getOutputs()[i];
  189. tmpTXOutputs[i] = new TXOutput(txOutput.getValue(), txOutput.getPubKeyHash());
  190. }
  192. return new Transaction(this.getTxId(), tmpTXInputs, tmpTXOutputs);
  193. }
  195. /**
  196. * 签名
  197. *
  198. * @param privateKey 私钥
  199. * @param prevTxMap 前面多笔交易集合
  200. */
  201. public void sign(BCECPrivateKey privateKey, Map prevTxMap) throws Exception {
  202. // coinbase 交易信息不需要签名，因为它不存在交易输入信息
  203. if (this.isCoinbase()) {
  204. return;
  205. }
  206. // 再次验证一下交易信息中的交易输入是否正确，也就是能否查找对应的交易数据
  207. for (TXInput txInput : this.getInputs()) {
  208. if (prevTxMap.get(Hex.encodeHexString(txInput.getTxId())) == null) {
  209. throw new Exception("ERROR: Previous transaction is not correct");
  210. }
  211. }
  213. // 创建用于签名的交易信息的副本
  214. Transaction txCopy = this.trimmedCopy();
  216. Security.addProvider(new BouncyCastleProvider());
  217. Signature ecdsaSign = Signature.getInstance("SHA256withECDSA", BouncyCastleProvider.PROVIDER_NAME);
  218. ecdsaSign.initSign(privateKey);
  220. for (int i = 0; i < txCopy.getInputs().length; i++) {
  221. TXInput txInputCopy = txCopy.getInputs()[i];
  222. // 获取交易输入TxID对应的交易数据
  223. Transaction prevTx = prevTxMap.get(Hex.encodeHexString(txInputCopy.getTxId()));
  224. // 获取交易输入所对应的上一笔交易中的交易输出
  225. TXOutput prevTxOutput = prevTx.getOutputs()[txInputCopy.getTxOutputIndex()];
  226. txInputCopy.setPubKey(prevTxOutput.getPubKeyHash());
  227. txInputCopy.setSignature(null);
  228. // 得到要签名的数据
  229. byte[] signData = txCopy.getData();
  230. txInputCopy.setPubKey(null);
  232. // 对整个交易信息仅进行签名
  233. ecdsaSign.update(signData);
  235. byte[] signature = ecdsaSign.sign();
  237. // 将整个交易数据的签名赋值给交易输入，因为交易输入需要包含整个交易信息的签名
  238. // 注意是将得到的签名赋值给原交易信息中的交易输入
  239. this.getInputs()[i].setSignature(signature);
  240. }
  241. }
  243. /**
  244. * 验证交易信息
  245. *
  246. * @param prevTxMap 前面多笔交易集合
  247. * @return
  248. */
  249. public boolean verify(Map prevTxMap) throws Exception {
  250. // coinbase 交易信息不需要签名，也就无需验证
  251. if (this.isCoinbase()) {
  252. return true;
  253. }
  255. // 再次验证一下交易信息中的交易输入是否正确，也就是能否查找对应的交易数据
  256. for (TXInput txInput : this.getInputs()) {
  257. if (prevTxMap.get(Hex.encodeHexString(txInput.getTxId())) == null) {
  258. throw new Exception("ERROR: Previous transaction is not correct");
  259. }
  260. }
  262. // 创建用于签名验证的交易信息的副本
  263. Transaction txCopy = this.trimmedCopy();
  265. Security.addProvider(new BouncyCastleProvider());
  266. ECParameterSpec ecParameters = ECNamedCurveTable.getParameterSpec("secp256k1");
  267. KeyFactory keyFactory = KeyFactory.getInstance("ECDSA", BouncyCastleProvider.PROVIDER_NAME);
  268. Signature ecdsaVerify = Signature.getInstance("SHA256withECDSA", BouncyCastleProvider.PROVIDER_NAME);
  270. for (int i = 0; i < this.getInputs().length; i++) {
  271. TXInput txInput = this.getInputs()[i];
  272. // 获取交易输入TxID对应的交易数据
  273. Transaction prevTx = prevTxMap.get(Hex.encodeHexString(txInput.getTxId()));
  274. // 获取交易输入所对应的上一笔交易中的交易输出
  275. TXOutput prevTxOutput = prevTx.getOutputs()[txInput.getTxOutputIndex()];
  277. TXInput txInputCopy = txCopy.getInputs()[i];
  278. txInputCopy.setSignature(null);
  279. txInputCopy.setPubKey(prevTxOutput.getPubKeyHash());
  280. // 得到要签名的数据
  281. byte[] signData = txCopy.getData();
  282. txInputCopy.setPubKey(null);
  284. // 使用椭圆曲线 x,y 点去生成公钥Key
  285. BigInteger x = new BigInteger(1, Arrays.copyOfRange(txInput.getPubKey(), 1, 33));
  286. BigInteger y = new BigInteger(1, Arrays.copyOfRange(txInput.getPubKey(), 33, 65));
  287. ECPoint ecPoint = ecParameters.getCurve().createPoint(x, y);
  289. ECPublicKeySpec keySpec = new ECPublicKeySpec(ecPoint, ecParameters);
  290. PublicKey publicKey = keyFactory.generatePublic(keySpec);
  291. ecdsaVerify.initVerify(publicKey);
  292. ecdsaVerify.update(signData);
  293. if (!ecdsaVerify.verify(txInput.getSignature())) {
  294. return false;
  295. }
  296. }
  297. return true;
  298. }
  300. }
复制代码
[h3]3.2.4 修改
  1. BlockChain.java
复制代码
文件[/h3]打开
  1. cldy.hanru.blockchain.block
复制代码
包，修改
  1. BlockChain.java
复制代码
文件。
修改步骤：
  1. 修改步骤：
  2. step1：修改getAllSpentTXOs()
  3. step2：修改findUTXO()
  4. step3：修改findSpendableOutputs()
  5. step4：添加方法findTransaction()
  6. step5：添加signTransaction()
  7. step6：添加verifyTransactions()
  8. step7：修改mineBlock()，添加验证
复制代码
修改完后代码如下：
  1. package cldy.hanru.blockchain.block;
  4. import cldy.hanru.blockchain.store.RocksDBUtils;
  5. import cldy.hanru.blockchain.transaction.SpendableOutputResult;
  6. import cldy.hanru.blockchain.transaction.TXInput;
  7. import cldy.hanru.blockchain.transaction.TXOutput;
  8. import cldy.hanru.blockchain.transaction.Transaction;
  9. import cldy.hanru.blockchain.util.ByteUtils;
  10. import lombok.AllArgsConstructor;
  11. import lombok.Data;
  12. import org.apache.commons.codec.binary.Hex;
  13. import org.apache.commons.lang3.ArrayUtils;
  14. import org.apache.commons.lang3.StringUtils;
  15. import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
  17. import java.util.Arrays;
  18. import java.util.HashMap;
  19. import java.util.List;
  20. import java.util.Map;
  22. /**
  23. * 区块链
  24. *
  25. * @author hanru
  26. */
  27. @Data
  28. @AllArgsConstructor
  29. public class Blockchain {
  32. /**
  33. * 最后一个区块的hash
  34. */
  35. private String lastBlockHash;
  38. /**
  39. * 创建区块链，createBlockchain
  40. *
  41. * @param address
  42. * @return
  43. */
  44. public static Blockchain createBlockchain(String address) {
  46. String lastBlockHash = RocksDBUtils.getInstance().getLastBlockHash();
  47. if (StringUtils.isBlank(lastBlockHash)) {
  48. //对应的bucket不存在，说明是第一次获取区块链实例
  49. // 创建 coinBase 交易
  50. Transaction coinbaseTX = Transaction.newCoinbaseTX(address, "");
  51. Block genesisBlock = Block.newGenesisBlock(coinbaseTX);
  52. // Block genesisBlock = Block.newGenesisBlock();
  53. lastBlockHash = genesisBlock.getHash();
  54. RocksDBUtils.getInstance().putBlock(genesisBlock);
  55. RocksDBUtils.getInstance().putLastBlockHash(lastBlockHash);
  57. }
  58. return new Blockchain(lastBlockHash);
  59. }
  61. /**
  62. * 根据block，添加区块
  63. *
  64. * @param block
  65. */
  66. public void addBlock(Block block) {
  68. RocksDBUtils.getInstance().putLastBlockHash(block.getHash());
  69. RocksDBUtils.getInstance().putBlock(block);
  70. this.lastBlockHash = block.getHash();
  72. }
  74. /**
  75. * 根据data添加区块
  76. * @param data
  77. */
  78. // public void addBlock(String data) throws Exception{
  79. //
  80. // String lastBlockHash = RocksDBUtils.getInstance().getLastBlockHash();
  81. // if (StringUtils.isBlank(lastBlockHash)){
  82. // throw new Exception("还没有数据库，无法直接添加区块。。");
  83. // }
  84. // this.addBlock(Block.newBlock(lastBlockHash,data));
  85. // }
  88. /**
  89. * 区块链迭代器：内部类
  90. */
  91. public class BlockchainIterator {
  93. /**
  94. * 当前区块的hash
  95. */
  96. private String currentBlockHash;
  98. /**
  99. * 构造函数
  100. *
  101. * @param currentBlockHash
  102. */
  103. public BlockchainIterator(String currentBlockHash) {
  104. this.currentBlockHash = currentBlockHash;
  105. }
  107. /**
  108. * 判断是否有下一个区块
  109. *
  110. * @return
  111. */
  112. public boolean hashNext() {
  113. if (ByteUtils.ZERO_HASH.equals(currentBlockHash)) {
  114. return false;
  115. }
  116. Block lastBlock = RocksDBUtils.getInstance().getBlock(currentBlockHash);
  117. if (lastBlock == null) {
  118. return false;
  119. }
  120. // 如果是创世区块
  121. if (ByteUtils.ZERO_HASH.equals(lastBlock.getPrevBlockHash())) {
  122. return true;
  123. }
  124. return RocksDBUtils.getInstance().getBlock(lastBlock.getPrevBlockHash()) != null;
  125. }
  128. /**
  129. * 迭代获取区块
  130. *
  131. * @return
  132. */
  133. public Block next() {
  134. Block currentBlock = RocksDBUtils.getInstance().getBlock(currentBlockHash);
  135. if (currentBlock != null) {
  136. this.currentBlockHash = currentBlock.getPrevBlockHash();
  137. return currentBlock;
  138. }
  139. return null;
  140. }
  141. }
  143. /**
  144. * 添加方法，用于获取迭代器实例
  145. *
  146. * @return
  147. */
  148. public BlockchainIterator getBlockchainIterator() {
  149. return new BlockchainIterator(lastBlockHash);
  150. }
  153. /**
  154. * 打包交易，进行挖矿
  155. *
  156. * @param transactions
  157. */
  158. public void mineBlock(List transactions) throws Exception {
  159. // 挖矿前，先验证交易记录
  160. for (Transaction tx : transactions) {
  161. if (!this.verifyTransactions(tx)) {
  162. throw new Exception("ERROR: Fail to mine block ! Invalid transaction ! ");
  163. }
  164. }
  165. String lastBlockHash = RocksDBUtils.getInstance().getLastBlockHash();
  166. Block lastBlock = RocksDBUtils.getInstance().getBlock(lastBlockHash);
  167. if (lastBlockHash == null) {
  168. throw new Exception("ERROR: Fail to get last block hash ! ");
  169. }
  170. Block block = Block.newBlock(lastBlockHash, transactions,lastBlock.getHeight()+1);
  171. this.addBlock(block);
  172. }
  175. /**
  176. * 从交易输入中查询区块链中所有已被花费了的交易输出
  177. *
  178. * @param pubKeyHash 钱包公钥Hash
  179. * @return 交易ID以及对应的交易输出下标地址
  180. * @throws Exception
  181. */
  182. private Map getAllSpentTXOs(byte[] pubKeyHash) {
  183. // 定义TxId ——> spentOutIndex[]，存储交易ID与已被花费的交易输出数组索引值
  184. Map spentTXOs = new HashMap();
  185. for (BlockchainIterator blockchainIterator = this.getBlockchainIterator(); blockchainIterator.hashNext(); ) {
  186. Block block = blockchainIterator.next();
  188. for (Transaction transaction : block.getTransactions()) {
  189. // 如果是 coinbase 交易，直接跳过，因为它不存在引用前一个区块的交易输出
  190. if (transaction.isCoinbase()) {
  191. continue;
  192. }
  193. for (TXInput txInput : transaction.getInputs()) {
  194. // if (txInput.canUnlockOutputWith(address)) {
  195. if (txInput.usesKey(pubKeyHash)) {
  196. String inTxId = Hex.encodeHexString(txInput.getTxId());
  197. int[] spentOutIndexArray = spentTXOs.get(inTxId);
  198. if (spentOutIndexArray == null) {
  199. spentTXOs.put(inTxId, new int[]{txInput.getTxOutputIndex()});
  200. } else {
  201. spentOutIndexArray = ArrayUtils.add(spentOutIndexArray, txInput.getTxOutputIndex());
  202. spentTXOs.put(inTxId, spentOutIndexArray);
  203. }
  204. }
  205. }
  206. }
  207. }
  208. return spentTXOs;
  209. }
  211. /**
  212. * 查找钱包地址对应的所有未花费的交易
  213. *
  214. * @param pubKeyHash 钱包公钥Hash
  215. * @return
  216. */
  217. private Transaction[] findUnspentTransactions(byte[] pubKeyHash) throws Exception {
  218. Map allSpentTXOs = this.getAllSpentTXOs(pubKeyHash);
  219. Transaction[] unspentTxs = {};
  221. // 再次遍历所有区块中的交易输出
  222. for (BlockchainIterator blockchainIterator = this.getBlockchainIterator(); blockchainIterator.hashNext(); ) {
  223. Block block = blockchainIterator.next();
  224. for (Transaction transaction : block.getTransactions()) {
  226. String txId = Hex.encodeHexString(transaction.getTxId());
  228. int[] spentOutIndexArray = allSpentTXOs.get(txId);
  230. for (int outIndex = 0; outIndex < transaction.getOutputs().length; outIndex++) {
  231. if (spentOutIndexArray != null && ArrayUtils.contains(spentOutIndexArray, outIndex)) {
  232. continue;
  233. }
  235. // 保存不存在 allSpentTXOs 中的交易
  236. // if (transaction.getOutputs()[outIndex].canBeUnlockedWith(address)) {
  237. if (transaction.getOutputs()[outIndex].isLockedWithKey(pubKeyHash)) {
  238. unspentTxs = ArrayUtils.add(unspentTxs, transaction);
  239. }
  240. }
  241. }
  242. }
  243. return unspentTxs;
  244. }
  246. /**
  247. * 查找钱包地址对应的所有UTXO
  248. *
  249. * @param pubKeyHash 钱包公钥Hash
  250. * @return
  251. */
  252. public TXOutput[] findUTXO(byte[] pubKeyHash) throws Exception {
  253. Transaction[] unspentTxs = this.findUnspentTransactions(pubKeyHash);
  254. TXOutput[] utxos = {};
  255. if (unspentTxs == null || unspentTxs.length == 0) {
  256. return utxos;
  257. }
  258. for (Transaction tx : unspentTxs) {
  259. for (TXOutput txOutput : tx.getOutputs()) {
  260. // if (txOutput.canBeUnlockedWith(address)) {
  261. if (txOutput.isLockedWithKey(pubKeyHash)) {
  262. utxos = ArrayUtils.add(utxos, txOutput);
  263. }
  264. }
  265. }
  266. return utxos;
  267. }
  269. /**
  270. * 寻找能够花费的交易
  271. *
  272. * @param pubKeyHash 钱包公钥Hash
  273. * @param amount 花费金额
  274. */
  275. public SpendableOutputResult findSpendableOutputs(byte[] pubKeyHash, int amount) throws Exception {
  276. Transaction[] unspentTXs = this.findUnspentTransactions(pubKeyHash);
  277. int accumulated = 0;
  278. Map unspentOuts = new HashMap();
  279. for (Transaction tx : unspentTXs) {
  281. String txId = Hex.encodeHexString(tx.getTxId());
  283. for (int outId = 0; outId < tx.getOutputs().length; outId++) {
  285. TXOutput txOutput = tx.getOutputs()[outId];
  287. // if (txOutput.canBeUnlockedWith(address) && accumulated < amount) {
  288. if (txOutput.isLockedWithKey(pubKeyHash) && accumulated < amount) {
  289. accumulated += txOutput.getValue();
  291. int[] outIds = unspentOuts.get(txId);
  292. if (outIds == null) {
  293. outIds = new int[]{outId};
  294. } else {
  295. outIds = ArrayUtils.add(outIds, outId);
  296. }
  297. unspentOuts.put(txId, outIds);
  298. if (accumulated >= amount) {
  299. break;
  300. }
  301. }
  302. }
  303. }
  304. return new SpendableOutputResult(accumulated, unspentOuts);
  305. }
  307. /**
  308. * 依据交易ID查询交易信息
  309. *
  310. * @param txId 交易ID
  311. * @return
  312. */
  313. private Transaction findTransaction(byte[] txId) throws Exception {
  314. for (BlockchainIterator iterator = this.getBlockchainIterator(); iterator.hashNext(); ) {
  315. Block block = iterator.next();
  316. for (Transaction tx : block.getTransactions()) {
  317. if (Arrays.equals(tx.getTxId(), txId)) {
  318. return tx;
  319. }
  320. }
  321. }
  322. throw new Exception("ERROR: Can not found tx by txId ! ");
  323. }
  324. /**
  325. * 从 DB 从恢复区块链数据
  326. *
  327. * @return
  328. * @throws Exception
  329. */
  330. public static Blockchain initBlockchainFromDB() throws Exception {
  331. String lastBlockHash = RocksDBUtils.getInstance().getLastBlockHash();
  332. if (lastBlockHash == null) {
  333. throw new Exception("ERROR: Fail to init blockchain from db. ");
  334. }
  335. return new Blockchain(lastBlockHash);
  336. }
  339. /**
  340. * 进行交易签名
  341. *
  342. * @param tx 交易数据
  343. * @param privateKey 私钥
  344. */
  345. public void signTransaction(Transaction tx, BCECPrivateKey privateKey) throws Exception {
  346. // 先来找到这笔新的交易中，交易输入所引用的前面的多笔交易的数据
  347. Map prevTxMap = new HashMap();
  348. for (TXInput txInput : tx.getInputs()) {
  349. Transaction prevTx = this.findTransaction(txInput.getTxId());
  350. prevTxMap.put(Hex.encodeHexString(txInput.getTxId()), prevTx);
  351. }
  352. tx.sign(privateKey, prevTxMap);
  353. }
  355. /**
  356. * 交易签名验证
  357. *
  358. * @param tx
  359. */
  360. private boolean verifyTransactions(Transaction tx) throws Exception {
  361. if (tx.isCoinbase()) {
  362. return true;
  363. }
  364. Map prevTx = new HashMap();
  365. for (TXInput txInput : tx.getInputs()) {
  366. Transaction transaction = this.findTransaction(txInput.getTxId());
  367. prevTx.put(Hex.encodeHexString(txInput.getTxId()), transaction);
  368. }
  369. try {
  370. return tx.verify(prevTx);
  371. } catch (Exception e) {
  372. throw new Exception("Fail to verify transaction ! transaction invalid ! ");
  373. }
  374. }
  376. }
复制代码
[h3]3.2.5 修改
  1. blockchain.sh
复制代码
脚本文件[/h3]最后修改
  1. blockchain.sh
复制代码
脚本文件，修改后内容如下：
  1. #!/bin/bash
  3. set -e
  5. # Check if the jar has been built.
  6. if [ ! -e target/part7_Signature-jar-with-dependencies.jar ]; then
  7. echo "Compiling blockchain project to a JAR"
  8. mvn package -DskipTests
  9. fi
  11. java -jar target/part7_Signature-jar-with-dependencies.jar "$@"
复制代码
[h1]4. 数字签名讲解[/h1][h2]4.1 交易过程[/h2]一笔交易就是一个地址的比特币，转移到另一个地址。由于比特币的交易记录全部都是公开的，哪个地址拥有多少比特币，都是可以查到的。因此，支付方是否拥有足够的比特币，完成这笔交易，这是可以轻易验证的。
问题出在怎么防止其他人，冒用你的名义申报交易。举例来说，有人申报了一笔交易：地址 A 向地址 B 支付10个比特币。我们怎么知道这个申报是真的，数据是正确的？
比特币协议规定，申报交易的时候，除了交易金额，转出比特币的一方还必须提供以下数据。
  • 上一笔交易的 Hash（你从哪里得到这些比特币）
  • 本次交易双方的地址
  • 支付方的公钥
  • 支付方的私钥生成的数字签名
验证这笔交易是否属实，需要三步。
  • 第一步，找到上一笔交易，确认支付方的比特币来源。
  • 第二步，算出支付方公钥的指纹，确认与支付方的地址一致，从而保证公钥属实。
  • 第三步，使用公钥去解开数字签名，保证签名属实、私钥属实。
  • 经过上面三步，就可以认定这笔交易是真实的。


[h2]4.1 数字签名[/h2]好了，现在我们已经知道了在比特币中证明用户身份的是私钥。而为了保证交易有效性，需要使用数字签名。接下来我们详细谈一下数字签名。
[h3]4.1.1 数字签名的概念[/h3]所谓数字签名(Digital Signature)（又称公开密钥数字签名、电子签章）。是一种类似写在纸上的普通的物理签名，但是使用了公钥加密领域的技术实现，用于鉴别数字信息的方法。一套数字签名通常定义两种互补的运算，一个用于签名，另一个用于验证。
[h3]4.1.2 数字签名如何工作[/h3]数字签名由两部分组成：第一部分是使用私钥（签名密钥）从消息（交易）创建签名的算法； 第二部分是允许任何人验证签名的算法。


[h3]4.1.3 数字签名的特性[/h3]1、签名不可伪造性；
2、签名不可抵赖的（简直通俗易懂~）；
3、签名可信性，签名的识别和应用相对容易，任何人都可以验证签名的有效性；
4、签名是不可复制的，签名与原文是不可分割的整体；
5、签名消息不可篡改，因为任意比特数据被篡改，其签名便被随之改变，那么任何人可以验证而拒绝接受此签名。
[h3]4.1.4 设计数字签名[/h3]为了对数据进行签名，我们需要下面两样东西：
  • 要签名的数据
  • 私钥
应用签名算法可以生成一个签名，并且这个签名会被存储在交易输入中。为了对一个签名进行验证，我们需要以下三样东西：
  • 被签名的数据
  • 签名
  • 公钥
简单来说，验证过程可以被描述为：检查签名是由被签名数据加上私钥得来，并且公钥恰好是由该私钥生成。
  1. 数据签名并不是加密，你无法从一个签名重新构造出数据。这有点像哈希：
  2. 你在数据上运行一个哈希算法，然后得到一个该数据的唯一表示。签名与哈
  3. 希的区别在于密钥对：有了密钥对，才有签名验证。但是密钥对也可以被用
  4. 于加密数据：私钥用于加密，公钥用于解密数据。不过比特币并不使用加密算法。
复制代码
在比特币中，每一笔交易输入都会由创建交易的人签名。在被放入到一个块之前，必须要对每一笔交易进行验证。除了一些其他步骤，验证意味着：
  • 检查交易输入有权使用来自之前交易的输出
  • 检查交易签名是正确的
如图，对数据进行签名和对签名进行验证的过程大致如下：


现在来回顾一个交易完整的生命周期：
  • 起初，创世块里面包含了一个 coinbase 交易。在 coinbase 交易中，没有输入，所以也就不需要签名。coinbase 交易的输出包含了一个哈希过的公钥（使用的是 RIPEMD16(SHA256(PubKey)) 算法）
  • 当一个人发送币时，就会创建一笔交易。这笔交易的输入会引用之前交易的输出。每个输入会存储一个公钥（没有被哈希）和整个交易的一个签名。
  • 比特币网络中接收到交易的其他节点会对该交易进行验证。除了一些其他事情，他们还会检查：在一个输入中，公钥哈希与所引用的输出哈希相匹配（这保证了发送方只能花费属于自己的币）；签名是正确的（这保证了交易是由币的实际拥有者所创建）。
  • 当一个矿工准备挖一个新块时，他会将交易放到块中，然后开始挖矿。
  • 当新块被挖出来以后，网络中的所有其他节点会接收到一条消息，告诉其他人这个块已经被挖出并被加入到区块链。
  • 当一个块被加入到区块链以后，交易就算完成，它的输出就可以在新的交易中被引用。
[h2]4.2 实现签名[/h2]交易必须被签名，因为这是比特币里面保证发送方不会花费属于其他人的币的唯一方式。如果一个签名是无效的，那么这笔交易就会被认为是无效的，因此，这笔交易也就无法被加到区块链中。
我们现在离实现交易签名还差一件事情：用于签名的数据。一笔交易的哪些部分需要签名？又或者说，要对完整的交易进行签名？选择签名的数据相当重要。因为用于签名的这个数据，必须要包含能够唯一识别数据的信息。比如，如果仅仅对输出值进行签名并没有什么意义，因为签名不会考虑发送方和接收方。
考虑到交易解锁的是之前的输出，然后重新分配里面的价值，并锁定新的输出，那么必须要签名以下数据：
  • 存储在已解锁输出的公钥哈希。它识别了一笔交易的“发送方”。
  • 存储在新的锁定输出里面的公钥哈希。它识别了一笔交易的“接收方”。
  • 新的输出值。
  1. 在比特币中，锁定/解锁逻辑被存储在脚本中，它们被分别存储在输入和输
  2. 出的 ScriptSig 和 ScriptPubKey 字段。由于比特币允许这样不同类型
  3. 的脚本，它对 ScriptPubKey 的整个内容进行了签名。
复制代码
可以看到，我们不需要对存储在输入里面的公钥签名。因此，在比特币里， 所签名的并不是一个交易，而是一个去除部分内容的输入副本，输入里面存储了被引用输出的
  1. ScriptPubKey
复制代码
。
看着有点复杂，来开始写代码吧。先从修改
  1. TXInput
复制代码
和
  1. TXOutput
复制代码
的结构开始：
在
  1. transaction
复制代码
包下，修改
  1. TXInput.go
复制代码
文件，修改后代码如下：
  1. public class TXInput {
  2. /**
  3. * 交易Id的hash值
  4. */
  5. private byte[] txId;
  6. /**
  7. * 交易输出索引
  8. */
  9. private int txOutputIndex;
  10. /**
  11. * 签名
  12. */
  13. private byte[] signature;
  14. /**
  15. * 公钥
  16. */
  17. private byte[] pubKey;
  19. /**
  20. * 检查公钥hash是否用于交易输入
  21. *
  22. * @param pubKeyHash
  23. * @return
  24. */
  25. public boolean usesKey(byte[] pubKeyHash) {
  26. byte[] lockingHash = AddressUtils.ripeMD160Hash(this.getPubKey());
  27. return Arrays.equals(lockingHash, pubKeyHash);
  28. }
  29. }
复制代码
在这里，我们需要重新设置两个字段，
  1. signature
复制代码
表示数字签名，
  1. pubKey
复制代码
表示原始公钥(就是钱包里面的公钥)。
接下来，我们修改
  1. TXOutput.java
复制代码
文件，修改后代码如下：
  1. public class TXOutput {
  2. /**
  3. * 数值金额
  4. */
  5. private int value
  6. /**
  7. * 公钥Hash
  8. */
  9. private byte[] pubKeyHash;
  11. /**
  12. * 检查交易输出是否能够使用指定的公钥
  13. *
  14. * @param pubKeyHash
  15. * @return
  16. */
  17. public boolean isLockedWithKey(byte[] pubKeyHash) {
  18. return Arrays.equals(this.getPubKeyHash(), pubKeyHash);
  19. }
  20. }
复制代码
因为在给
  1. TXInput
复制代码
设置签名需要用到该
  1. TXInput
复制代码
对应的
  1. TXOutput
复制代码
的数据，所以要找到这个
  1. TXOutput
复制代码
所在的
  1. Transaction
复制代码
。现在我们修改
  1. Blockchain.java
复制代码
文件，添加一个方法
  1. FindTransactionByTxID()
复制代码
：
  1. /**
  2. * 依据交易ID查询交易信息
  3. *
  4. * @param txId 交易ID
  5. * @return
  6. */
  7. private Transaction findTransaction(byte[] txId) throws Exception {
  8. for (BlockchainIterator iterator = this.getBlockchainIterator(); iterator.hashNext(); ) {
  9. Block block = iterator.next();
  10. for (Transaction tx : block.getTransactions()) {
  11. if (Arrays.equals(tx.getTxId(), txId)) {
  12. return tx;
  13. }
  14. }
  15. }
  16. throw new Exception("ERROR: Can not found tx by txId ! ");
  17. }
复制代码
在查找的时候，需要遍历每个区块查找里面的
  1. Transaction
复制代码
，根据
  1. txId
复制代码
判断该
  1. Transaction
复制代码
是否是我们要找的
  1. Transaction
复制代码
。
接下来在
  1. Blockchain.java
复制代码
文件中，继续添加方法，表示签名一笔交易：
  1. /**
  2. * 进行交易签名
  3. *
  4. * @param tx 交易数据
  5. * @param privateKey 私钥
  6. */
  7. public void signTransaction(Transaction tx, BCECPrivateKey privateKey) throws Exception {
  8. // 先来找到这笔新的交易中，交易输入所引用的前面的多笔交易的数据
  9. Map prevTxMap = new HashMap();
  10. for (TXInput txInput : tx.getInputs()) {
  11. Transaction prevTx = this.findTransaction(txInput.getTxId());
  12. prevTxMap.put(Hex.encodeHexString(txInput.getTxId()), prevTx);
  13. }
  14. tx.sign(privateKey, prevTxMap);
  15. }
复制代码
其实签名交易，就是给交易中的每个
  1. TXInput
复制代码
，设置
  1. signature
复制代码
字段。所以接下来在
  1. Transaction.java
复制代码
文件中，添加签名方法，代码如下：
  1. /**
  2. * 签名
  3. *
  4. * @param privateKey 私钥
  5. * @param prevTxMap 前面多笔交易集合
  6. */
  7. public void sign(BCECPrivateKey privateKey, Map prevTxMap) throws Exception {
  8. // coinbase 交易信息不需要签名，因为它不存在交易输入信息
  9. if (this.isCoinbase()) {
  10. return;
  11. }
  12. // 再次验证一下交易信息中的交易输入是否正确，也就是能否查找对应的交易数据
  13. for (TXInput txInput : this.getInputs()) {
  14. if (prevTxMap.get(Hex.encodeHexString(txInput.getTxId())) == null) {
  15. throw new Exception("ERROR: Previous transaction is not correct");
  16. }
  17. }
  19. // 创建用于签名的交易信息的副本
  20. Transaction txCopy = this.trimmedCopy();
  22. Security.addProvider(new BouncyCastleProvider());
  23. Signature ecdsaSign = Signature.getInstance("SHA256withECDSA", BouncyCastleProvider.PROVIDER_NAME);
  24. ecdsaSign.initSign(privateKey);
  26. for (int i = 0; i < txCopy.getInputs().length; i++) {
  27. TXInput txInputCopy = txCopy.getInputs()[i];
  28. // 获取交易输入TxID对应的交易数据
  29. Transaction prevTx = prevTxMap.get(Hex.encodeHexString(txInputCopy.getTxId()));
  30. // 获取交易输入所对应的上一笔交易中的交易输出
  31. TXOutput prevTxOutput = prevTx.getOutputs()[txInputCopy.getTxOutputIndex()];
  32. txInputCopy.setPubKey(prevTxOutput.getPubKeyHash());
  33. txInputCopy.setSignature(null);
  34. // 得到要签名的数据
  35. byte[] signData = txCopy.getData();
  36. txInputCopy.setPubKey(null);
  38. // 对整个交易信息仅进行签名
  39. ecdsaSign.update(signData);
  41. byte[] signature = ecdsaSign.sign();
  43. // 将整个交易数据的签名赋值给交易输入，因为交易输入需要包含整个交易信息的签名
  44. // 注意是将得到的签名赋值给原交易信息中的交易输入
  45. this.getInputs()[i].setSignature(signature);
  46. }
  47. }
复制代码
这个方法接受一个私钥和一个之前交易的
  1. map
复制代码
。正如上面提到的，为了对一笔交易进行签名，我们需要获取交易输入所引用的输出，因为我们需要存储这些输出的交易。
这个方法，是签名的核心方法，我们来一步一步地分析该方法：
  1. // coinbase 交易信息不需要签名，因为它不存在交易输入信息
  2. if (this.isCoinbase()) {
  3. return;
  4. }
复制代码
  1. coinbase
复制代码
交易因为没有实际输入，所以没有被签名。
  1. // 创建用于签名的交易信息的副本
  2. Transaction txCopy = this.trimmedCopy();
复制代码
将会被签署的是修剪后的交易副本，而不是一个完整交易，接下来添加一个方法，用于拷贝一个交易，代码如下：
  1. /**
  2. * 创建用于签名的交易数据副本，交易输入的 signature 和 pubKey 需要设置为null
  3. *
  4. * @return
  5. */
  6. public Transaction trimmedCopy() {
  7. TXInput[] tmpTXInputs = new TXInput[this.getInputs().length];
  8. for (int i = 0; i < this.getInputs().length; i++) {
  9. TXInput txInput = this.getInputs()[i];
  10. tmpTXInputs[i] = new TXInput(txInput.getTxId(), txInput.getTxOutputIndex(), null, null);
  11. }
  13. TXOutput[] tmpTXOutputs = new TXOutput[this.getOutputs().length];
  14. for (int i = 0; i < this.getOutputs().length; i++) {
  15. TXOutput txOutput = this.getOutputs()[i];
  16. tmpTXOutputs[i] = new TXOutput(txOutput.getValue(), txOutput.getPubKeyHash());
  17. }
  19. return new Transaction(this.getTxId(), tmpTXInputs, tmpTXOutputs);
  20. }
复制代码
这个副本包含了所有的输入和输出，但是
  1. TXInput.signature
复制代码
和
  1. TXIput.pubKey
复制代码
被设置为
  1. null
复制代码
。
然后我们需要根据私钥设置签名对象：
  1. Security.addProvider(new BouncyCastleProvider());
  2. Signature ecdsaSign = Signature.getInstance("SHA256withECDSA", BouncyCastleProvider.PROVIDER_NAME);
  3. ecdsaSign.initSign(privateKey);
复制代码
接下来，我们会迭代副本中每一个输入：
  1. for (int i = 0; i < txCopy.getInputs().length; i++) {
  2. TXInput txInputCopy = txCopy.getInputs()[i];
  3. // 获取交易输入TxID对应的交易数据
  4. Transaction prevTx = prevTxMap.get(Hex.encodeHexString(txInputCopy.getTxId()));
  5. // 获取交易输入所对应的上一笔交易中的交易输出
  6. TXOutput prevTxOutput = prevTx.getOutputs()[txInputCopy.getTxOutputIndex()];
  7. txInputCopy.setPubKey(prevTxOutput.getPubKeyHash());
  8. txInputCopy.setSignature(null);
  9. ...
  10. }
复制代码
在每个输入中，
  1. signature
复制代码
被设置为
  1. null
复制代码
(仅仅是一个双重检验)，
  1. pubcKey
复制代码
被设置为所引用输出的
  1. PubKeyHash
复制代码
。现在，除了当前交易，其他所有交易都是“空的”，也就是说他们的
  1. signature
复制代码
和
  1. pubKey
复制代码
字段被设置为
  1. null
复制代码
。因此，输入是被分开签名的，尽管这对于我们的应用并不十分紧要，但是比特币允许交易包含引用了不同地址的输入。
  1. // 得到要签名的数据
  2. byte[] signData = txCopy.getData();
  3. txInputCopy.setPubKey(null);
复制代码
  1. getData()
复制代码
方法对交易进行序列化，并使用 SHA-256 算法进行哈希。哈希后的结果就是我们要签名的数据。在获取完哈希，我们应该重置
  1. PublicKey
复制代码
字段，以便于它不会影响后面的迭代。
现在，关键点：
  1. // 对整个交易信息仅进行签名
  2. ecdsaSign.update(signData);
  3. byte[] signature = ecdsaSign.sign();
  5. // 将整个交易数据的签名赋值给交易输入，因为交易输入需要包含整个交易信息的签名
  6. // 注意是将得到的签名赋值给原交易信息中的交易输入
  7. this.getInputs()[i].setSignature(signature);
复制代码
我们对 data 进行签名。一个 ECDSA 签名就是一对数字，我们对这对数字连接起来，并存储在输入的
  1. Signature
复制代码
字段。
[h2]4.3 签名验证[/h2]现在，验证函数：
在
  1. Transaction.java
复制代码
文件中，添加验证签名方法，代码如下:
  1. /**
  2. * 验证交易信息
  3. *
  4. * @param prevTxMap 前面多笔交易集合
  5. * @return
  6. */
  7. public boolean verify(Map prevTxMap) throws Exception {
  8. // coinbase 交易信息不需要签名，也就无需验证
  9. if (this.isCoinbase()) {
  10. return true;
  11. }
  13. // 再次验证一下交易信息中的交易输入是否正确，也就是能否查找对应的交易数据
  14. for (TXInput txInput : this.getInputs()) {
  15. if (prevTxMap.get(Hex.encodeHexString(txInput.getTxId())) == null) {
  16. throw new Exception("ERROR: Previous transaction is not correct");
  17. }
  18. }
  20. // 创建用于签名验证的交易信息的副本
  21. Transaction txCopy = this.trimmedCopy();
  23. Security.addProvider(new BouncyCastleProvider());
  24. ECParameterSpec ecParameters = ECNamedCurveTable.getParameterSpec("secp256k1");
  25. KeyFactory keyFactory = KeyFactory.getInstance("ECDSA", BouncyCastleProvider.PROVIDER_NAME);
  26. Signature ecdsaVerify = Signature.getInstance("SHA256withECDSA", BouncyCastleProvider.PROVIDER_NAME);
  28. for (int i = 0; i < this.getInputs().length; i++) {
  29. TXInput txInput = this.getInputs()[i];
  30. // 获取交易输入TxID对应的交易数据
  31. Transaction prevTx = prevTxMap.get(Hex.encodeHexString(txInput.getTxId()));
  32. // 获取交易输入所对应的上一笔交易中的交易输出
  33. TXOutput prevTxOutput = prevTx.getOutputs()[txInput.getTxOutputIndex()];
  35. TXInput txInputCopy = txCopy.getInputs()[i];
  36. txInputCopy.setSignature(null);
  37. txInputCopy.setPubKey(prevTxOutput.getPubKeyHash());
  38. // 得到要签名的数据
  39. byte[] signData = txCopy.getData();
  40. txInputCopy.setPubKey(null);
  42. // 使用椭圆曲线 x,y 点去生成公钥Key
  43. BigInteger x = new BigInteger(1, Arrays.copyOfRange(txInput.getPubKey(), 1, 33));
  44. BigInteger y = new BigInteger(1, Arrays.copyOfRange(txInput.getPubKey(), 33, 65));
  45. ECPoint ecPoint = ecParameters.getCurve().createPoint(x, y);
  47. ECPublicKeySpec keySpec = new ECPublicKeySpec(ecPoint, ecParameters);
  48. PublicKey publicKey = keyFactory.generatePublic(keySpec);
  49. ecdsaVerify.initVerify(publicKey);
  50. ecdsaVerify.update(signData);
  51. if (!ecdsaVerify.verify(txInput.getSignature())) {
  52. return false;
  53. }
  54. }
  55. return true;
  56. }
复制代码
这个方法十分直观。首先，我们需要同一笔交易的副本：
  1. // 创建用于签名验证的交易信息的副本
  2. Transaction txCopy = this.trimmedCopy();
复制代码
然后，我们需要相同的签名对象：
  1. Security.addProvider(new BouncyCastleProvider());
  2. ECParameterSpec ecParameters = ECNamedCurveTable.getParameterSpec("secp256k1");
  3. KeyFactory keyFactory = KeyFactory.getInstance("ECDSA", BouncyCastleProvider.PROVIDER_NAME);
  4. Signature ecdsaVerify = Signature.getInstance("SHA256withECDSA", BouncyCastleProvider.PROVIDER_NAME);
复制代码
接下来，我们检查每个输入中的签名：
  1. for (int i = 0; i < this.getInputs().length; i++) {
  2. TXInput txInput = this.getInputs()[i];
  3. // 获取交易输入TxID对应的交易数据
  4. Transaction prevTx = prevTxMap.get(Hex.encodeHexString(txInput.getTxId()));
  5. // 获取交易输入所对应的上一笔交易中的交易输出
  6. TXOutput prevTxOutput = prevTx.getOutputs()[txInput.getTxOutputIndex()];
  8. TXInput txInputCopy = txCopy.getInputs()[i];
  9. txInputCopy.setSignature(null);
  10. txInputCopy.setPubKey(prevTxOutput.getPubKeyHash());
  11. // 得到要签名的数据
  12. byte[] signData = txCopy.getData();
  13. txInputCopy.setPubKey(null);
复制代码
这个部分跟
  1. sign()
复制代码
方法一模一样，因为在验证阶段，我们需要的是与签名相同的数据。
  1. // 使用椭圆曲线 x,y 点去生成公钥Key
  2. BigInteger x = new BigInteger(1, Arrays.copyOfRange(txInput.getPubKey(), 1, 33));
  3. BigInteger y = new BigInteger(1, Arrays.copyOfRange(txInput.getPubKey(), 33, 65));
  4. ECPoint ecPoint = ecParameters.getCurve().createPoint(x, y);
复制代码
这里我们解包存储在
  1. TXInput.publicKey
复制代码
中的值，因为一个公钥就是一对坐标。我们之前为了存储将它们连接在一起，现在我们需要对它们进行解包在
  1. initVerify()
复制代码
函数中使用。
  1. ...
  2. ECPublicKeySpec keySpec = new ECPublicKeySpec(ecPoint, ecParameters);
  3. PublicKey publicKey = keyFactory.generatePublic(keySpec);
  4. ecdsaVerify.initVerify(publicKey);
  5. ecdsaVerify.update(signData);
  6. if (!ecdsaVerify.verify(txInput.getSignature())) {
  7. return false;
  8. }
  9. return true;
  10. }
复制代码
在这里：我们使用从输入提取的公钥用于设置
  1. ecdsaVerify
复制代码
的初始化信息，并且设置了要验证的签名的数据。然后来验证签名。如果所有的输入都被验证，返回
  1. true
复制代码
；如果有任何一个验证失败，返回
  1. false
复制代码
.
接下来，我们在
  1. Blockchain.java
复制代码
中添加验证方法
  1. verifyTransactions()
复制代码
：
  1. /**
  2. * 交易签名验证
  3. *
  4. * @param tx
  5. */
  6. private boolean verifyTransactions(Transaction tx) throws Exception {
  7. Map prevTx = new HashMap();
  8. for (TXInput txInput : tx.getInputs()) {
  9. Transaction transaction = this.findTransaction(txInput.getTxId());
  10. prevTx.put(Hex.encodeHexString(txInput.getTxId()), transaction);
  11. }
  12. try {
  13. return tx.verify(prevTx);
  14. } catch (Exception e) {
  15. throw new Exception("Fail to verify transaction ! transaction invalid ! ");
  16. }
  17. }
复制代码
在一笔交易被放入一个块之前进行验证，所以接下来我们需要修改
  1. BlockChain.java
复制代码
文件中的
  1. MineNewBlock()
复制代码
方法，
  1. /**
  2. * 打包交易，进行挖矿
  3. *
  4. * @param transactions
  5. */
  6. public void mineBlock(Transaction[] transactions) throws Exception {
  7. // 挖矿前，先验证交易记录
  8. for (Transaction tx : transactions) {
  9. if (!this.verifyTransactions(tx)) {
  10. throw new Exception("ERROR: Fail to mine block ! Invalid transaction ! ");
  11. }
  12. }
  13. String lastBlockHash = RocksDBUtils.getInstance().getLastBlockHash();
  14. if (lastBlockHash == null) {
  15. throw new Exception("ERROR: Fail to get last block hash ! ");
  16. }
  17. Block block = Block.newBlock(lastBlockHash, transactions);
  18. this.addBlock(block);
  19. }
复制代码
至此，我们已经在项目中，添加了交易的签名和签名验证。
  1. main.go
复制代码
文件无需修改，接下来我们测试一下代码：还是进行创建钱包地址，创建创世区块，然后转账交易等。
在终端中输入以下命令:
  1. hanru:part7_Signature ruby$ ./blockchain.sh h
  2. hanru:part7_Signature ruby$ ./blockchain.sh createaddress
  3. hanru:part7_Signature ruby$ ./blockchain.sh createaddress
  4. hanru:part7_Signature ruby$ ./blockchain.sh printaddresses
  5. hanru:part7_Signature ruby$ ./blockchain.sh createblockchain -address 17aAQuo5A8xk9hV7NRp6Mc3ambV54gjMKX
  6. hanru:part7_Signature ruby$ ./blockchain.sh getbalance -address 17aAQuo5A8xk9hV7NRp6Mc3ambV54gjMKX
复制代码
运行结果如下：


继续输入以下命令：
  1. hanru:part7_Signature ruby$ ./blockchain.sh send -from 17aAQuo5A8xk9hV7NRp6Mc3ambV54gjMKX -to 1EGUjAdhqWTHLxDsKrMUJyNv2KMM4zxxL2 -amount 4
  2. hanru:part7_Signature ruby$ ./blockchain.sh getbalance -address 17aAQuo5A8xk9hV7NRp6Mc3ambV54gjMKX
  3. hanru:part7_Signature ruby$ ./blockchain.sh getbalance -address 1EGUjAdhqWTHLxDsKrMUJyNv2KMM4zxxL2
  4. hanru:part7_Signature ruby$ ./blockchain.sh printchain
复制代码
运行结果如下:

[h1]5. 总结[/h1]通过本章节的学习，我们知道了什么是签名，为何签名，以及如何签名。只有转账人才能生成的一段防伪造的字符串。通过验证该字符串，一方面证明该交易是转出方本人发起的，另一方面证明交易信息在传输过程中没有被更改。数字签名由：数字摘要和非对称加密技术组成。数字摘要把交易信息hash成固定长度的字符串，再用私钥对hash后的交易信息进行加密形成数字签名。交易中，需要将完整的交易信息和数字签名一起广播给矿工。矿工节点用转账人公钥对签名验证，验证成功说明该交易确实是转账人发起的；矿工节点将交易信息进行hash后与签名中的交易信息摘要进行比对，如果一致，则说明交易信息在传输过程中没有被篡改。


回复
分享到 :
0 人收藏
返回列表
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

1级新秀
枭一

积分:2
帖子:2
精华:0
+ 关注 私信
期权论坛 期权论坛
期权网络科技版权所有
关于我们
联系我们
加入我们
反馈问题
免责声明
积分充值
统一社会信用代码
积分规则
网站地图
爱文库
下属网站
官方
新浪微博
微信公众号
◆
下载
表情包
App下载
期权论坛 期权论坛

QQ咨询|关于我们|Archiver|手机版|小黑屋|( 辽ICP备15012455号-4 ) Powered by 期权论坛 X3.2 © 2001-2016 期权工具网&期权论坛 Inc.

发布
内容

下载期权论坛手机APP