摘要：通過入門區塊鏈本文翻譯自的文章原文地址區塊鏈可能是繼互聯網之后最重大和最具突破性的技術。先不管對比特幣和其他加密貨幣價格的瘋狂行情，本文旨在幫助讀者入門區塊鏈技術。

本文翻譯自 Adil Moujahid 的文章 A Practical Introduction to Blockchain with Python
原文地址：http://adilmoujahid.com/posts/2018/03/intro-blockchain-bitcoin-python/

區塊鏈可能是繼互聯網之后最重大和最具突破性的技術。它是比特幣和其他加密貨幣背后的核心技術，在近幾年可謂賺足了人們的眼球。

本質上講，區塊鏈是一種不需第三方權威機構，直接在兩者之間點對點交易的分布式數據庫。這種簡單卻強大的理念對銀行、政府和市場等各種各樣的機構產生了巨大的影響。任何以中央數據庫作為技術壁壘的公司和組織都可能被區塊鏈技術顛覆。

先不管對比特幣和其他加密貨幣價格的瘋狂行情，本文旨在幫助讀者入門區塊鏈技術。第一、二節講解了一些區塊鏈的核心概念，第三節展示了如何通過Python實現區塊鏈。我們也將實現兩個web網站方便用戶與我們的區塊鏈交互。

本文通過比特幣作為例子來解釋主流的區塊鏈技術，大部分概念在其他區塊鏈應用場景和加密貨幣中同樣適用。

下圖使我們將在第三節實現的web應用：

所有的一切開始于2008年，一個自稱中本聰的匿名的人或者團體發表了一篇白皮書。這篇名為『比特幣：一種點對點的電子現金系統』的白皮書為后來成為區塊鏈的技術打下了基礎。在白皮書中，重本從描述了如何建立一個點對點的電子貨幣系統，可以直接從個體支付給另一個個體，而不需要中央權威機構的介入。該系統解決了電子貨幣的一個重要問題——雙重支付。

假設Alice想要付1美元給Bob。如果Alice和Bob使用物理貨幣，那么Alice在支付給Bob1美元之后，將不再擁有那1美元貨幣。如果Alice和Bob使用數字貨幣，那么問題就變復雜了。數字貨幣很容易被復制，比如說，如果Alice通過電子郵件發給Bob一個價值1美元的數字文件，Bob并不知道Alien是否已經刪掉她自己的文件。如果Alice沒有刪掉，并且又用同樣的方式發給了Carol。這就是雙重支付問題。

一種雙重支付的解決方案是通過一個獨立于Aliec，Bob和其他網絡中的參與者的可信第三方機構（比如說銀行）。主要職責是維護一個用于記錄和驗證網絡中所有的交易的中央賬本。這個解決方案的缺點是需要一個可信的中心化第三方機構。

為了解決雙重支付問題，中本聰提出了一種公開賬本，換言之，比特幣中的區塊鏈技術用于記錄網絡中所有的交易，有如下幾個特征：

分布性：賬本復制存儲在大量的計算機中，而不是一個中央數據庫。任何聯網的且運行比特幣軟件的計算機都會下載一份區塊鏈的完整拷貝。

加密性：密碼學用來保證付款方擁有他發送的比特幣，并且決定交易如何添加到區塊鏈上。

不可篡改性：區塊鏈僅僅能在添加元素的時候被修改，也就是說，交易只能添加到區塊鏈，而不能刪除或篡改。

工作量證明機制：網絡中一種特殊的參與者叫做礦工，他們通過計算尋找密碼學難題，解開難題的礦工可以將新的交易塊添加到區塊鏈中。

發送比特幣需要如下幾步操作：

第一步（只需一次）：創建比特幣錢包。對于發送和接受比特幣的人來說，他們都需要創建一個比特幣錢包。比特幣錢包保存了兩部分信息：私鑰和公鑰。私鑰是一個密碼，允許擁有者發送比特幣給另一位用戶，或者把比特幣作為支付手段來使用。 公鑰是一串用來接受比特幣的字符串，同時也被稱作比特幣錢包地址（不完全正確，但一般來說我們認為公鑰和錢包地址是相同的）。請注意錢包不存儲比特幣本身，比特幣余額的信息被存儲在區塊鏈上。

第二步：創建比特幣交易。如果Alice想發送1美元給Bob，Alice需要使用私鑰打開她的比特幣錢包，創建一個包含金額的交易（該場景中，使用Bob的公鑰地址）

第三步：向比特幣網絡廣播該交易事件。一旦Alice創建了比特幣交易，他需要向整個比特幣網絡廣播這個交易。

第四步：確認交易。監聽比特幣網絡的某個礦工使用Alice的公鑰對交易進行驗證，確認她的錢包中有足夠的比特幣（該場景中，最少1個比特幣），并且向區塊鏈中添加包含交易詳情的新紀錄。

第五步：向所有礦工廣播區塊鏈的修改。一旦交易被確認，該礦工應該向所有的礦工廣播區塊鏈的修改，以保證其他礦工的區塊鏈內容及時同步。

本節旨在深入探討驅動區塊鏈的核心步驟——新建區塊的技術細節，將從公開密鑰加密，哈希函數，挖礦和區塊鏈安全幾個方便展開。

公開密鑰加密，或者說非對稱加密，是指一種使用一對鑰匙的加密系統，公鑰可能被廣泛的三波，私鑰只有擁有者本人知道。它實現了兩個功能：認證，公鑰可以驗證持有者通過私鑰加密的信息；加密，只有私鑰擁有者可以解開通過公鑰加密的信息。

RSA和橢圓曲線數字簽名算法（ECDSA）是最廣泛應用的兩種公開密鑰加密算法。

對比特幣來說，ECDSA算法被用于生成比特幣錢包。比特幣通常使用多個鑰匙和地址，但簡單起見，本文中假設每個比特幣錢包只使用一堆公鑰和私鑰，并且比特幣錢包地址就是公鑰。如果你對比特幣錢包的完整技術感興趣，我推薦這篇文章。

發送和接受比特幣時，用戶首先創建一個包含公鑰和私鑰的錢包。如果Alice想要給Bob發送一些比特幣，她在創建交易的時候需要將她和Bob雙方的公鑰，以及比特幣金額輸入進去。然后使用自己的私鑰簽署這筆交易。區塊鏈上的某臺計算機可以通過Alice的公鑰去驗證這筆交易是不是Alice本人發出的，然后將交易添加到區塊上，之后該區塊會被添加到區塊鏈當中。

所有比特幣交易被存放在成為區塊的文件中。比特幣每十分鐘向區塊鏈中添加一個包含新增交易記錄的新區塊。一旦新區快被添加進區塊鏈，它將不可修改和刪除。在區塊鏈網絡中，一種被稱為礦工（他們的計算機連接著區塊鏈）的特殊群體負責創建新的交易區塊。礦工必須使用發送者的公鑰驗證每一筆交易，確認發送者擁有足夠的余額支付完成該交易，并且將交易添加到區塊中。礦工可以完全自主選擇將哪些交易添加到區塊中，因此發送者需要提交一些交易費來激勵礦工將它們的交易添加到區塊中。

對于每一個被區塊鏈接受的區塊，都需要被挖礦。挖一個區塊的時候，礦工需要尋找一個極難的加密難題的答案。如果一個被挖礦的區塊被區塊鏈接受，礦工將獲得一定的比特幣作為除了交易費的額外獎勵。挖礦程序也被稱為工作量證明機制，它是保障區塊鏈可靠和安全的主要機制（稍后再討論區塊鏈的安全性）。

為了理解區塊鏈加密難題，需要先理解哈希函數。哈希函數可以將任意范圍的數據映射到指定的數據范圍。哈希函數返回的結果成為哈希值。哈希函數通常被用于通過重復檢查來加速數據庫查找，并且在密碼學中也有廣泛的應用。加密哈希函數幫助人們輕松地驗證某些輸入數據是否映射到了給定的哈希值，但如果不知道輸入數據，那么通過哈希值來構造輸入數據是極其困難的。[2]

比特幣使用SHA-256作為加密哈希函數。SHA-256應用于區塊數據（比特幣交易）與一種名為nonce（譯者注：實際上是一個隨機數）的數字的組合。通過改變區塊數據和nonce，可以得到完全不同的哈希值。對于一個被認為是有效或者說是被挖礦的區塊，區塊和nonce的哈希值需要滿足一個特定的條件。比如說，哈希值前面的四位數等于"0000"。我們可以通過規定更加復雜的條件來提高挖礦的難度，比如說我們可以要求哈希值的開頭包含更多個0。

礦工面臨的加密難題需要尋找一個nonce值，使得哈希值滿足挖礦成功條件。我們可以通過下面的應用來模擬區塊挖礦。當在Data欄輸入內容或者改變nonce值時，哈希值會隨之改變。當點擊"挖礦"按鈕，應用從0開始枚舉nonce的值，并檢查哈希值的前四位數是否等于"0000"。如果前四位數不等于"0000"，那么nonce值加一并重復相同的操作直到nonce值滿足條件。如果區塊完成挖礦，那么背景色會變成綠色。

為了保證體驗，請到原文鏈接中相應位置進行模擬。

如前一節所述，交易被分組存放在區塊中，區塊被附加在區塊鏈中。為了把區塊串成鏈，每個新區塊都存儲著它前一個區塊的哈希值。創建新區塊時，礦工選擇一些交易，添加前一個區塊的哈希值，并且對區塊進行挖礦。

任何區塊中任何數據上的改變都會影響該區塊的哈希值，進而導致該區塊失效。這賦予了區塊鏈不可篡改的特性。

你可以通過如下軟件模擬包含三個區塊的區塊鏈。當你在Data欄輸入內容或者概念nonce值時，可以發現該區塊的哈希值和下一個區塊的前導值（前導哈希值）隨之改變。可以通過點擊每個獨立區塊的"挖礦"按鈕模擬挖礦過程。三個區塊挖礦完成后，嘗試改變區塊1或區塊2的內容，會發現該操作導致該區塊之后的區塊失效。

為了保證體驗，請到原文鏈接中相應位置進行模擬。

上面的兩個挖礦模擬器都是由Anders Brownworth的BlockChain Demo改編而來的。

比特幣網絡中的所有礦工互相競爭，率先找到可以添加到區塊鏈的合法區塊的礦工將獲得獎勵。找到可以驗證區塊的nonce值是極其困難的，但由于比特幣網絡中有大量的礦工，尋找到該值并驗證區塊的可能性是非常高的。第一個礦工提交一個有效區塊到區塊鏈，會得到一定的比特幣作為獎勵。但如果兩個或更多礦工同時提交了他們的區塊該如何處理呢？

如果兩個礦工幾乎在同一時間驗證了區塊，那么區塊鏈便產生了分叉，需要等待下一個區塊去解決沖突。一些礦工會選擇在第一條分叉上挖礦，另一些礦工選擇在第二條分叉上挖礦。第一個找到新區塊的礦工將解決該沖突。如果新區塊在第一條分叉上，那么第二條分叉便失效了，前一個區塊的獎勵由將區塊提交到第一個分叉上的礦工獲得，第二個分叉上的交易沒有被提交到區塊鏈中，將回到交易池等待被提交到之后的區塊中。簡言之，如果區塊鏈中產生分叉，最長的分叉將被保留下來。

本節將探討區塊鏈雙重支付攻擊的最常見方法，和用戶需要采取的一些使自己免于傷害的措施。

攻擊者在極短的時間內使用同一個貨幣發送給兩個不同的地址。為了防范這種攻擊，推薦等待至少1個區塊確認后，再接受對方的支付。

攻擊者預先挖好一個包含某條交易的區塊，釋放該區塊之前，在第二次交易中使用相同的貨幣。在該場景中，第二次交易將不會生效。為了防范這種攻擊，推薦等待至少6個區塊確認后，再接受對方的支付。

在該攻擊中，攻擊者掌握了比特幣網絡中51%的算力。攻擊者首先把構造好的交易廣播到整個網絡，然后對包含雙重支付貨幣交易的私有區塊鏈進行挖礦。由于掌握了多數的算力，他可以保證在某個點上比正確的區塊鏈擁有更長的鏈，這將取代正確的區塊鏈，并取消原來的交易。這種攻擊極其不可能發生，因為成本很高。

本節我們講使用Python實現一個簡單的區塊鏈和區塊鏈客戶端。我們的區塊鏈將有如下特征：

支持向區塊鏈網絡中添加多個節點

工作量證明機制（PoW）

節點之間簡單的沖突處理

基于RSA加密的交易

區塊鏈客戶端將有如下特性：

通過公鑰和私鑰生成錢包（基于RSA算法）

基于RSA加密生成交易

我們將實現兩個儀表盤：

礦工使用的"區塊鏈后臺"

用戶用來生成錢包和發送比特幣的"區塊鏈客戶端"

區塊鏈實現主要基于這個Github項目。我對源碼進行了一些修改，添加了RSA加密算法交易。錢包生成和交易加密基于Jupyter notebook.這兩個儀表盤通過HTML/CSS/JS實現。

你可以從https://github.com/adilmoujahid/blockchain-python-tutorial下載完整源碼。

通過終端進入blockchain_client文件夾中的blockchain客戶端，輸入python blockchain_client.py。在瀏覽器中打開http://localhost:8080將看到如下儀表盤。

儀表盤的導航欄中有三個標簽頁：

生成錢包：通過RSA加密算法生成錢包（公鑰私鑰對）

發起交易：生成交易，并且將它們發送給區塊鏈節點

查看交易：查看區塊鏈中的交易

為了發起或查看交易，需要至少運行一個區塊鏈節點（下一節將講解此內容）

接下來將解釋一些blockchain_client.py中的關鍵代碼。

我們定義了含有sender_address, sender_private_key, recipient_address, value這4個屬性的Transaction類。用戶發起一筆交易時需要填寫這4個內容。

to_dict()方法以Python字典格式返回交易信息（無需發送者密鑰）。sign_transaction()方法取出交易信息（無需發送者密鑰），并使用發送者的私鑰簽署該交易信息。

class Transaction:

    def __init__(self, sender_address, sender_private_key, recipient_address, value):
        self.sender_address = sender_address
        self.sender_private_key = sender_private_key
        self.recipient_address = recipient_address
        self.value = value

    def __getattr__(self, attr):
        return self.data[attr]

    def to_dict(self):
        return OrderedDict({"sender_address": self.sender_address,
                            "recipient_address": self.recipient_address,
                            "value": self.value})

    def sign_transaction(self):
        """
        Sign transaction with private key
        """
        private_key = RSA.importKey(binascii.unhexlify(self.sender_private_key))
        signer = PKCS1_v1_5.new(private_key)
        h = SHA.new(str(self.to_dict()).encode("utf8"))
        return binascii.hexlify(signer.sign(h)).decode("ascii")

下面這行代碼會初始化一個Python Flask應用，我們將用它創建API，使客戶端與區塊鏈進行交互。

app = Flask(__name__)

下面我們定義了三個返回html頁面的Flask路由，每個標簽頁都有個一個html頁面與之對應。

@app.route("/")
def index():
  return render_template("./index.html")

@app.route("/make/transaction")
def make_transaction():
    return render_template("./make_transaction.html")

@app.route("/view/transactions")
def view_transaction():
    return render_template("./view_transactions.html")

下面我們定義了一個生成錢包（公鑰私鑰對）的API。

@app.route("/wallet/new", methods=["GET"])
def new_wallet():
  random_gen = Crypto.Random.new().read
  private_key = RSA.generate(1024, random_gen)
  public_key = private_key.publickey()
  response = {
    "private_key": binascii.hexlify(private_key.exportKey(format="DER")).decode("ascii"),
    "public_key": binascii.hexlify(public_key.exportKey(format="DER")).decode("ascii")
  }

  return jsonify(response), 200

下面我們定義了一個入參包括sender_address, sender_private_key, recipient_address, value的API，它會返回交易（無需私鑰）和簽名。

@app.route("/generate/transaction", methods=["POST"])
def generate_transaction():

  sender_address = request.form["sender_address"]
  sender_private_key = request.form["sender_private_key"]
  recipient_address = request.form["recipient_address"]
  value = request.form["amount"]

  transaction = Transaction(sender_address, sender_private_key, recipient_address, value)

  response = {"transaction": transaction.to_dict(), "signature": transaction.sign_transaction()}

  return jsonify(response), 200

通過終端進入blockchain文件夾，輸入python blockchain.py或者python blockchain.py -p 。如果你不想指定端口號，那么默認的端口號是5000。在瀏覽器中打開http://localhost:可以看到區塊鏈后臺儀表盤。

儀表盤的導航欄中有兩個標簽頁：

挖礦：查看交易和區塊鏈數據，對新的交易區塊進行挖礦。

配置：配置不同區塊鏈節點之間的鏈接。

接下來將解釋一些blockchain.py中的關鍵代碼。

我們定義Blockchain類，包含如下屬性：

transactions: 將被添加到下一個區塊的所有交易的集合。

chain: 實際的區塊鏈，以區塊類型數組的形式存放。

nodes: 節點url的集合。區塊鏈通過這些節點檢索區塊鏈數據，更新節點上尚未同步的區塊鏈數據。

node_id: 用于標識區塊鏈節點的隨機字符串。

Blockchain類實現了如下方法：

register_node(node_url): 向節點列表添加新的區塊鏈節點。

verify_transaction_signature(sender_address, signature, transaction): 使用公鑰（發送者地址）驗證提供的簽名。

submit_transaction(sender_address, recipient_address, value, signature): 如果簽名驗證通過，向交易列表中添加交易。

create_block(nonce, previous_hash): 向區塊鏈添加新的區塊。

hash(block): 為區塊創建SHA_256哈希值。

proof_of_work(): 工作量證明算法。尋找滿足挖礦條件的nonce值。

valid_proof(transaction, last_hash, nonce, difficulty=MININGDIFFICULTY): 檢查哈希值是否滿足挖礦條件。這個方法在proof_of_work方法中使用。

valid_chain(chain): 檢查區塊鏈是否合法。

resolve_conflicts(): 通過保留最長分叉解決區塊鏈節點之間的沖突。

class Blockchain:

    def __init__(self):

        self.transactions = []
        self.chain = []
        self.nodes = set()
        #Generate random number to be used as node_id
        self.node_id = str(uuid4()).replace("-", "")
        #Create genesis block
        self.create_block(0, "00")

    def register_node(self, node_url):
        """
        Add a new node to the list of nodes
        """
        ...

    def verify_transaction_signature(self, sender_address, signature, transaction):
        """
        Check that the provided signature corresponds to transaction
        signed by the public key (sender_address)
        """
        ...

    def submit_transaction(self, sender_address, recipient_address, value, signature):
        """
        Add a transaction to transactions array if the signature verified
        """
        ...

    def create_block(self, nonce, previous_hash):
        """
        Add a block of transactions to the blockchain
        """
        ...

    def hash(self, block):
        """
        Create a SHA-256 hash of a block
        """
        ...

    def proof_of_work(self):
        """
        Proof of work algorithm
        """
        ...

    def valid_proof(self, transactions, last_hash, nonce, difficulty=MINING_DIFFICULTY):
        """
        Check if a hash value satisfies the mining conditions. This function is used within the proof_of_work function.
        """
        ...

    def valid_chain(self, chain):
        """
        check if a bockchain is valid
        """
        ...

    def resolve_conflicts(self):
        """
        Resolve conflicts between blockchain"s nodes
        by replacing our chain with the longest one in the network.
        """
        ...

下面這行代碼初始化一個Python Flask應用，我們將用它創建API，使客戶端與區塊鏈進行交互。

app = Flask(__name__)
CORS(app)

接下來，初始化一個Blockchain實例。

blockchain = Blockchain()

下面我們為區塊鏈后臺儀表盤定義了兩個返回html頁面的Flask路由。

@app.route("/")
def index():
    return render_template("./index.html")

@app.route("/configure")
def configure():
    return render_template("./configure.html")

下面我們定義了一些Flask API來管理交易和挖礦。

"/transactions/new": 這個API對應在簽名驗證正確后，添加包含sender_address，"recipient_address", amount 和 signature參數的交易到新的區塊中。

/transaction/get: 這個API返回所有將被添加到下一個區塊的交易。

/chain: 這個API返回所有的區塊鏈數據。

/mine: 這個API運行工作量證明算法，并且添加新的交易區塊到區塊鏈上。

@app.route("/transactions/new", methods=["POST"])
def new_transaction():
    values = request.form

    # Check that the required fields are in the POST"ed data
    required = ["sender_address", "recipient_address", "amount", "signature"]
    if not all(k in values for k in required):
        return "Missing values", 400
    # Create a new Transaction
    transaction_result = blockchain.submit_transaction(values["sender_address"], values["recipient_address"], values["amount"], values["signature"])

    if transaction_result == False:
        response = {"message": "Invalid Transaction!"}
        return jsonify(response), 406
    else:
        response = {"message": "Transaction will be added to Block "+ str(transaction_result)}
        return jsonify(response), 201

@app.route("/transactions/get", methods=["GET"])
def get_transactions():
    #Get transactions from transactions pool
    transactions = blockchain.transactions

    response = {"transactions": transactions}
    return jsonify(response), 200

@app.route("/chain", methods=["GET"])
def full_chain():
    response = {
        "chain": blockchain.chain,
        "length": len(blockchain.chain),
    }
    return jsonify(response), 200

@app.route("/mine", methods=["GET"])
def mine():
    # We run the proof of work algorithm to get the next proof...
    last_block = blockchain.chain[-1]
    nonce = blockchain.proof_of_work()

    # We must receive a reward for finding the proof.
    blockchain.submit_transaction(sender_address=MINING_SENDER, recipient_address=blockchain.node_id, value=MINING_REWARD, signature="")

    # Forge the new Block by adding it to the chain
    previous_hash = blockchain.hash(last_block)
    block = blockchain.create_block(nonce, previous_hash)

    response = {
        "message": "New Block Forged",
        "block_number": block["block_number"],
        "transactions": block["transactions"],
        "nonce": block["nonce"],
        "previous_hash": block["previous_hash"],
    }
    return jsonify(response), 200

下面我們定義Flash API來管理區塊鏈節點：

"/nodes/register": 這個API的入參是節點url列表，然后將它們更新到列表中每一個節點中。

"/nodes/resolve": 這個API通過保留最長分叉解決區塊鏈節點之間的沖突。

"/nodes/get": 這個API返回所有的節點列表。

@app.route("/nodes/register", methods=["POST"])
def register_nodes():
    values = request.form
    nodes = values.get("nodes").replace(" ", "").split(",")

    if nodes is None:
        return "Error: Please supply a valid list of nodes", 400

    for node in nodes:
        blockchain.register_node(node)

    response = {
        "message": "New nodes have been added",
        "total_nodes": [node for node in blockchain.nodes],
    }
    return jsonify(response), 201


@app.route("/nodes/resolve", methods=["GET"])
def consensus():
    replaced = blockchain.resolve_conflicts()

    if replaced:
        response = {
            "message": "Our chain was replaced",
            "new_chain": blockchain.chain
        }
    else:
        response = {
            "message": "Our chain is authoritative",
            "chain": blockchain.chain
        }
    return jsonify(response), 200


@app.route("/nodes/get", methods=["GET"])
def get_nodes():

    nodes = list(blockchain.nodes)
    response = {"nodes": nodes}
    return jsonify(response), 200

本文探討了區塊鏈底層的核心概念和如何通過Python實現一個區塊鏈系統。簡單起見，本文并沒有覆蓋一些技術細節，比如說：錢包地址和默克爾樹。如果你想深入了解這些細節，我推薦閱讀比特幣白皮書原文，和bitcoin wiki，以及Andreas Antonopoulos的精彩著作: Mastering Bitcoin: Programming the Open Blockchain

Wikipedia - Public-key cryptography

Wikipedia - Hash function

Bitcoin Stackexchange - What happens to a transaction once generated?

Bitcoin Wiki - Majority attack