Browse Source
script.py is modified from the code in python-bitcoinlib, and provides tools for manipulating and creating CScript objects. bignum.py is a dependency for script.py script_test.py is an example test that uses the script tools for running a test that compares the behavior of two nodes, in a comptool- style test, for each of the test cases in the bitcoin unit test script files, script_valid.json and script_invalid.json. (This test is very slow to run, but is a proof of concept for how we can write tests to compare consensus-critical behavior between different versions of bitcoind.) bipdersig-p2p.py is another example test in the comptool framework, which tests deployment of BIP DERSIG for a single node. It uses the script.py tools for manipulating signatures to be non-DER compliant.0.13
Suhas Daftuar
10 years ago
4 changed files with 1434 additions and 0 deletions
@ -0,0 +1,102 @@
@@ -0,0 +1,102 @@
|
||||
# |
||||
# |
||||
# bignum.py |
||||
# |
||||
# This file is copied from python-bitcoinlib. |
||||
# |
||||
# Distributed under the MIT/X11 software license, see the accompanying |
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php. |
||||
# |
||||
|
||||
"""Bignum routines""" |
||||
|
||||
from __future__ import absolute_import, division, print_function, unicode_literals |
||||
|
||||
import struct |
||||
|
||||
|
||||
# generic big endian MPI format |
||||
|
||||
def bn_bytes(v, have_ext=False): |
||||
ext = 0 |
||||
if have_ext: |
||||
ext = 1 |
||||
return ((v.bit_length()+7)//8) + ext |
||||
|
||||
def bn2bin(v): |
||||
s = bytearray() |
||||
i = bn_bytes(v) |
||||
while i > 0: |
||||
s.append((v >> ((i-1) * 8)) & 0xff) |
||||
i -= 1 |
||||
return s |
||||
|
||||
def bin2bn(s): |
||||
l = 0 |
||||
for ch in s: |
||||
l = (l << 8) | ch |
||||
return l |
||||
|
||||
def bn2mpi(v): |
||||
have_ext = False |
||||
if v.bit_length() > 0: |
||||
have_ext = (v.bit_length() & 0x07) == 0 |
||||
|
||||
neg = False |
||||
if v < 0: |
||||
neg = True |
||||
v = -v |
||||
|
||||
s = struct.pack(b">I", bn_bytes(v, have_ext)) |
||||
ext = bytearray() |
||||
if have_ext: |
||||
ext.append(0) |
||||
v_bin = bn2bin(v) |
||||
if neg: |
||||
if have_ext: |
||||
ext[0] |= 0x80 |
||||
else: |
||||
v_bin[0] |= 0x80 |
||||
return s + ext + v_bin |
||||
|
||||
def mpi2bn(s): |
||||
if len(s) < 4: |
||||
return None |
||||
s_size = bytes(s[:4]) |
||||
v_len = struct.unpack(b">I", s_size)[0] |
||||
if len(s) != (v_len + 4): |
||||
return None |
||||
if v_len == 0: |
||||
return 0 |
||||
|
||||
v_str = bytearray(s[4:]) |
||||
neg = False |
||||
i = v_str[0] |
||||
if i & 0x80: |
||||
neg = True |
||||
i &= ~0x80 |
||||
v_str[0] = i |
||||
|
||||
v = bin2bn(v_str) |
||||
|
||||
if neg: |
||||
return -v |
||||
return v |
||||
|
||||
# bitcoin-specific little endian format, with implicit size |
||||
def mpi2vch(s): |
||||
r = s[4:] # strip size |
||||
r = r[::-1] # reverse string, converting BE->LE |
||||
return r |
||||
|
||||
def bn2vch(v): |
||||
return bytes(mpi2vch(bn2mpi(v))) |
||||
|
||||
def vch2mpi(s): |
||||
r = struct.pack(b">I", len(s)) # size |
||||
r += s[::-1] # reverse string, converting LE->BE |
||||
return r |
||||
|
||||
def vch2bn(s): |
||||
return mpi2bn(vch2mpi(s)) |
||||
|
@ -0,0 +1,183 @@
@@ -0,0 +1,183 @@
|
||||
#!/usr/bin/env python2 |
||||
# |
||||
# Distributed under the MIT/X11 software license, see the accompanying |
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php. |
||||
# |
||||
|
||||
from test_framework import ComparisonTestFramework |
||||
from util import * |
||||
from mininode import CTransaction, NetworkThread |
||||
from blocktools import create_coinbase, create_block |
||||
from binascii import hexlify, unhexlify |
||||
import cStringIO |
||||
from comptool import TestInstance, TestManager |
||||
from script import CScript |
||||
import time |
||||
|
||||
# A canonical signature consists of: |
||||
# <30> <total len> <02> <len R> <R> <02> <len S> <S> <hashtype> |
||||
def unDERify(tx): |
||||
''' |
||||
Make the signature in vin 0 of a tx non-DER-compliant, |
||||
by adding padding after the S-value. |
||||
''' |
||||
scriptSig = CScript(tx.vin[0].scriptSig) |
||||
newscript = [] |
||||
for i in scriptSig: |
||||
if (len(newscript) == 0): |
||||
newscript.append(i[0:-1] + '\0' + i[-1]) |
||||
else: |
||||
newscript.append(i) |
||||
tx.vin[0].scriptSig = CScript(newscript) |
||||
|
||||
''' |
||||
This test is meant to exercise BIP66 (DER SIG). |
||||
Connect to a single node. |
||||
Mine 2 (version 2) blocks (save the coinbases for later). |
||||
Generate 98 more version 2 blocks, verify the node accepts. |
||||
Mine 749 version 3 blocks, verify the node accepts. |
||||
Check that the new DERSIG rules are not enforced on the 750th version 3 block. |
||||
Check that the new DERSIG rules are enforced on the 751st version 3 block. |
||||
Mine 199 new version blocks. |
||||
Mine 1 old-version block. |
||||
Mine 1 new version block. |
||||
Mine 1 old version block, see that the node rejects. |
||||
''' |
||||
|
||||
class BIP66Test(ComparisonTestFramework): |
||||
|
||||
def __init__(self): |
||||
self.num_nodes = 1 |
||||
|
||||
def setup_network(self): |
||||
# Must set the blockversion for this test |
||||
self.nodes = start_nodes(1, self.options.tmpdir, |
||||
extra_args=[['-debug', '-whitelist=127.0.0.1', '-blockversion=2']], |
||||
binary=[self.options.testbinary]) |
||||
|
||||
def run_test(self): |
||||
test = TestManager(self, self.options.tmpdir) |
||||
test.add_all_connections(self.nodes) |
||||
NetworkThread().start() # Start up network handling in another thread |
||||
test.run() |
||||
|
||||
def create_transaction(self, node, coinbase, to_address, amount): |
||||
from_txid = node.getblock(coinbase)['tx'][0] |
||||
inputs = [{ "txid" : from_txid, "vout" : 0}] |
||||
outputs = { to_address : amount } |
||||
rawtx = node.createrawtransaction(inputs, outputs) |
||||
signresult = node.signrawtransaction(rawtx) |
||||
tx = CTransaction() |
||||
f = cStringIO.StringIO(unhexlify(signresult['hex'])) |
||||
tx.deserialize(f) |
||||
return tx |
||||
|
||||
def get_tests(self): |
||||
|
||||
self.coinbase_blocks = self.nodes[0].generate(2) |
||||
self.tip = int ("0x" + self.nodes[0].getbestblockhash() + "L", 0) |
||||
self.nodeaddress = self.nodes[0].getnewaddress() |
||||
self.last_block_time = time.time() |
||||
|
||||
''' 98 more version 2 blocks ''' |
||||
test_blocks = [] |
||||
for i in xrange(98): |
||||
block = create_block(self.tip, create_coinbase(2), self.last_block_time + 1) |
||||
block.nVersion = 2 |
||||
block.rehash() |
||||
block.solve() |
||||
test_blocks.append([block, True]) |
||||
self.last_block_time += 1 |
||||
self.tip = block.sha256 |
||||
yield TestInstance(test_blocks, sync_every_block=False) |
||||
|
||||
''' Mine 749 version 3 blocks ''' |
||||
test_blocks = [] |
||||
for i in xrange(749): |
||||
block = create_block(self.tip, create_coinbase(2), self.last_block_time + 1) |
||||
block.nVersion = 3 |
||||
block.rehash() |
||||
block.solve() |
||||
test_blocks.append([block, True]) |
||||
self.last_block_time += 1 |
||||
self.tip = block.sha256 |
||||
yield TestInstance(test_blocks, sync_every_block=False) |
||||
|
||||
''' |
||||
Check that the new DERSIG rules are not enforced in the 750th |
||||
version 3 block. |
||||
''' |
||||
spendtx = self.create_transaction(self.nodes[0], |
||||
self.coinbase_blocks[0], self.nodeaddress, 1.0) |
||||
unDERify(spendtx) |
||||
spendtx.rehash() |
||||
|
||||
block = create_block(self.tip, create_coinbase(2), self.last_block_time + 1) |
||||
block.nVersion = 3 |
||||
block.vtx.append(spendtx) |
||||
block.hashMerkleRoot = block.calc_merkle_root() |
||||
block.rehash() |
||||
block.solve() |
||||
|
||||
self.last_block_time += 1 |
||||
self.tip = block.sha256 |
||||
yield TestInstance([[block, True]]) |
||||
|
||||
''' |
||||
Check that the new DERSIG rules are enforced in the 751st version 3 |
||||
block. |
||||
''' |
||||
spendtx = self.create_transaction(self.nodes[0], |
||||
self.coinbase_blocks[1], self.nodeaddress, 1.0) |
||||
unDERify(spendtx) |
||||
spendtx.rehash() |
||||
|
||||
block = create_block(self.tip, create_coinbase(1), self.last_block_time + 1) |
||||
block.nVersion = 3 |
||||
block.vtx.append(spendtx) |
||||
block.hashMerkleRoot = block.calc_merkle_root() |
||||
block.rehash() |
||||
block.solve() |
||||
self.last_block_time += 1 |
||||
yield TestInstance([[block, False]]) |
||||
|
||||
''' Mine 199 new version blocks on last valid tip ''' |
||||
test_blocks = [] |
||||
for i in xrange(199): |
||||
block = create_block(self.tip, create_coinbase(1), self.last_block_time + 1) |
||||
block.nVersion = 3 |
||||
block.rehash() |
||||
block.solve() |
||||
test_blocks.append([block, True]) |
||||
self.last_block_time += 1 |
||||
self.tip = block.sha256 |
||||
yield TestInstance(test_blocks, sync_every_block=False) |
||||
|
||||
''' Mine 1 old version block ''' |
||||
block = create_block(self.tip, create_coinbase(1), self.last_block_time + 1) |
||||
block.nVersion = 2 |
||||
block.rehash() |
||||
block.solve() |
||||
self.last_block_time += 1 |
||||
self.tip = block.sha256 |
||||
yield TestInstance([[block, True]]) |
||||
|
||||
''' Mine 1 new version block ''' |
||||
block = create_block(self.tip, create_coinbase(1), self.last_block_time + 1) |
||||
block.nVersion = 3 |
||||
block.rehash() |
||||
block.solve() |
||||
self.last_block_time += 1 |
||||
self.tip = block.sha256 |
||||
yield TestInstance([[block, True]]) |
||||
|
||||
''' Mine 1 old version block, should be invalid ''' |
||||
block = create_block(self.tip, create_coinbase(1), self.last_block_time + 1) |
||||
block.nVersion = 2 |
||||
block.rehash() |
||||
block.solve() |
||||
self.last_block_time += 1 |
||||
yield TestInstance([[block, False]]) |
||||
|
||||
if __name__ == '__main__': |
||||
BIP66Test().main() |
@ -0,0 +1,896 @@
@@ -0,0 +1,896 @@
|
||||
# |
||||
# script.py |
||||
# |
||||
# This file is modified from python-bitcoinlib. |
||||
# |
||||
# Distributed under the MIT/X11 software license, see the accompanying |
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php. |
||||
# |
||||
|
||||
"""Scripts |
||||
|
||||
Functionality to build scripts, as well as SignatureHash(). |
||||
""" |
||||
|
||||
from __future__ import absolute_import, division, print_function, unicode_literals |
||||
|
||||
from mininode import CTransaction, CTxOut, hash256 |
||||
|
||||
import sys |
||||
bchr = chr |
||||
bord = ord |
||||
if sys.version > '3': |
||||
long = int |
||||
bchr = lambda x: bytes([x]) |
||||
bord = lambda x: x |
||||
|
||||
import copy |
||||
import struct |
||||
|
||||
import bignum |
||||
|
||||
MAX_SCRIPT_SIZE = 10000 |
||||
MAX_SCRIPT_ELEMENT_SIZE = 520 |
||||
MAX_SCRIPT_OPCODES = 201 |
||||
|
||||
OPCODE_NAMES = {} |
||||
|
||||
_opcode_instances = [] |
||||
class CScriptOp(int): |
||||
"""A single script opcode""" |
||||
__slots__ = [] |
||||
|
||||
@staticmethod |
||||
def encode_op_pushdata(d): |
||||
"""Encode a PUSHDATA op, returning bytes""" |
||||
if len(d) < 0x4c: |
||||
return b'' + bchr(len(d)) + d # OP_PUSHDATA |
||||
elif len(d) <= 0xff: |
||||
return b'\x4c' + bchr(len(d)) + d # OP_PUSHDATA1 |
||||
elif len(d) <= 0xffff: |
||||
return b'\x4d' + struct.pack(b'<H', len(d)) + d # OP_PUSHDATA2 |
||||
elif len(d) <= 0xffffffff: |
||||
return b'\x4e' + struct.pack(b'<I', len(d)) + d # OP_PUSHDATA4 |
||||
else: |
||||
raise ValueError("Data too long to encode in a PUSHDATA op") |
||||
|
||||
@staticmethod |
||||
def encode_op_n(n): |
||||
"""Encode a small integer op, returning an opcode""" |
||||
if not (0 <= n <= 16): |
||||
raise ValueError('Integer must be in range 0 <= n <= 16, got %d' % n) |
||||
|
||||
if n == 0: |
||||
return OP_0 |
||||
else: |
||||
return CScriptOp(OP_1 + n-1) |
||||
|
||||
def decode_op_n(self): |
||||
"""Decode a small integer opcode, returning an integer""" |
||||
if self == OP_0: |
||||
return 0 |
||||
|
||||
if not (self == OP_0 or OP_1 <= self <= OP_16): |
||||
raise ValueError('op %r is not an OP_N' % self) |
||||
|
||||
return int(self - OP_1+1) |
||||
|
||||
def is_small_int(self): |
||||
"""Return true if the op pushes a small integer to the stack""" |
||||
if 0x51 <= self <= 0x60 or self == 0: |
||||
return True |
||||
else: |
||||
return False |
||||
|
||||
def __str__(self): |
||||
return repr(self) |
||||
|
||||
def __repr__(self): |
||||
if self in OPCODE_NAMES: |
||||
return OPCODE_NAMES[self] |
||||
else: |
||||
return 'CScriptOp(0x%x)' % self |
||||
|
||||
def __new__(cls, n): |
||||
try: |
||||
return _opcode_instances[n] |
||||
except IndexError: |
||||
assert len(_opcode_instances) == n |
||||
_opcode_instances.append(super(CScriptOp, cls).__new__(cls, n)) |
||||
return _opcode_instances[n] |
||||
|
||||
# Populate opcode instance table |
||||
for n in range(0xff+1): |
||||
CScriptOp(n) |
||||
|
||||
|
||||
# push value |
||||
OP_0 = CScriptOp(0x00) |
||||
OP_FALSE = OP_0 |
||||
OP_PUSHDATA1 = CScriptOp(0x4c) |
||||
OP_PUSHDATA2 = CScriptOp(0x4d) |
||||
OP_PUSHDATA4 = CScriptOp(0x4e) |
||||
OP_1NEGATE = CScriptOp(0x4f) |
||||
OP_RESERVED = CScriptOp(0x50) |
||||
OP_1 = CScriptOp(0x51) |
||||
OP_TRUE=OP_1 |
||||
OP_2 = CScriptOp(0x52) |
||||
OP_3 = CScriptOp(0x53) |
||||
OP_4 = CScriptOp(0x54) |
||||
OP_5 = CScriptOp(0x55) |
||||
OP_6 = CScriptOp(0x56) |
||||
OP_7 = CScriptOp(0x57) |
||||
OP_8 = CScriptOp(0x58) |
||||
OP_9 = CScriptOp(0x59) |
||||
OP_10 = CScriptOp(0x5a) |
||||
OP_11 = CScriptOp(0x5b) |
||||
OP_12 = CScriptOp(0x5c) |
||||
OP_13 = CScriptOp(0x5d) |
||||
OP_14 = CScriptOp(0x5e) |
||||
OP_15 = CScriptOp(0x5f) |
||||
OP_16 = CScriptOp(0x60) |
||||
|
||||
# control |
||||
OP_NOP = CScriptOp(0x61) |
||||
OP_VER = CScriptOp(0x62) |
||||
OP_IF = CScriptOp(0x63) |
||||
OP_NOTIF = CScriptOp(0x64) |
||||
OP_VERIF = CScriptOp(0x65) |
||||
OP_VERNOTIF = CScriptOp(0x66) |
||||
OP_ELSE = CScriptOp(0x67) |
||||
OP_ENDIF = CScriptOp(0x68) |
||||
OP_VERIFY = CScriptOp(0x69) |
||||
OP_RETURN = CScriptOp(0x6a) |
||||
|
||||
# stack ops |
||||
OP_TOALTSTACK = CScriptOp(0x6b) |
||||
OP_FROMALTSTACK = CScriptOp(0x6c) |
||||
OP_2DROP = CScriptOp(0x6d) |
||||
OP_2DUP = CScriptOp(0x6e) |
||||
OP_3DUP = CScriptOp(0x6f) |
||||
OP_2OVER = CScriptOp(0x70) |
||||
OP_2ROT = CScriptOp(0x71) |
||||
OP_2SWAP = CScriptOp(0x72) |
||||
OP_IFDUP = CScriptOp(0x73) |
||||
OP_DEPTH = CScriptOp(0x74) |
||||
OP_DROP = CScriptOp(0x75) |
||||
OP_DUP = CScriptOp(0x76) |
||||
OP_NIP = CScriptOp(0x77) |
||||
OP_OVER = CScriptOp(0x78) |
||||
OP_PICK = CScriptOp(0x79) |
||||
OP_ROLL = CScriptOp(0x7a) |
||||
OP_ROT = CScriptOp(0x7b) |
||||
OP_SWAP = CScriptOp(0x7c) |
||||
OP_TUCK = CScriptOp(0x7d) |
||||
|
||||
# splice ops |
||||
OP_CAT = CScriptOp(0x7e) |
||||
OP_SUBSTR = CScriptOp(0x7f) |
||||
OP_LEFT = CScriptOp(0x80) |
||||
OP_RIGHT = CScriptOp(0x81) |
||||
OP_SIZE = CScriptOp(0x82) |
||||
|
||||
# bit logic |
||||
OP_INVERT = CScriptOp(0x83) |
||||
OP_AND = CScriptOp(0x84) |
||||
OP_OR = CScriptOp(0x85) |
||||
OP_XOR = CScriptOp(0x86) |
||||
OP_EQUAL = CScriptOp(0x87) |
||||
OP_EQUALVERIFY = CScriptOp(0x88) |
||||
OP_RESERVED1 = CScriptOp(0x89) |
||||
OP_RESERVED2 = CScriptOp(0x8a) |
||||
|
||||
# numeric |
||||
OP_1ADD = CScriptOp(0x8b) |
||||
OP_1SUB = CScriptOp(0x8c) |
||||
OP_2MUL = CScriptOp(0x8d) |
||||
OP_2DIV = CScriptOp(0x8e) |
||||
OP_NEGATE = CScriptOp(0x8f) |
||||
OP_ABS = CScriptOp(0x90) |
||||
OP_NOT = CScriptOp(0x91) |
||||
OP_0NOTEQUAL = CScriptOp(0x92) |
||||
|
||||
OP_ADD = CScriptOp(0x93) |
||||
OP_SUB = CScriptOp(0x94) |
||||
OP_MUL = CScriptOp(0x95) |
||||
OP_DIV = CScriptOp(0x96) |
||||
OP_MOD = CScriptOp(0x97) |
||||
OP_LSHIFT = CScriptOp(0x98) |
||||
OP_RSHIFT = CScriptOp(0x99) |
||||
|
||||
OP_BOOLAND = CScriptOp(0x9a) |
||||
OP_BOOLOR = CScriptOp(0x9b) |
||||
OP_NUMEQUAL = CScriptOp(0x9c) |
||||
OP_NUMEQUALVERIFY = CScriptOp(0x9d) |
||||
OP_NUMNOTEQUAL = CScriptOp(0x9e) |
||||
OP_LESSTHAN = CScriptOp(0x9f) |
||||
OP_GREATERTHAN = CScriptOp(0xa0) |
||||
OP_LESSTHANOREQUAL = CScriptOp(0xa1) |
||||
OP_GREATERTHANOREQUAL = CScriptOp(0xa2) |
||||
OP_MIN = CScriptOp(0xa3) |
||||
OP_MAX = CScriptOp(0xa4) |
||||
|
||||
OP_WITHIN = CScriptOp(0xa5) |
||||
|
||||
# crypto |
||||
OP_RIPEMD160 = CScriptOp(0xa6) |
||||
OP_SHA1 = CScriptOp(0xa7) |
||||
OP_SHA256 = CScriptOp(0xa8) |
||||
OP_HASH160 = CScriptOp(0xa9) |
||||
OP_HASH256 = CScriptOp(0xaa) |
||||
OP_CODESEPARATOR = CScriptOp(0xab) |
||||
OP_CHECKSIG = CScriptOp(0xac) |
||||
OP_CHECKSIGVERIFY = CScriptOp(0xad) |
||||
OP_CHECKMULTISIG = CScriptOp(0xae) |
||||
OP_CHECKMULTISIGVERIFY = CScriptOp(0xaf) |
||||
|
||||
# expansion |
||||
OP_NOP1 = CScriptOp(0xb0) |
||||
OP_NOP2 = CScriptOp(0xb1) |
||||
OP_NOP3 = CScriptOp(0xb2) |
||||
OP_NOP4 = CScriptOp(0xb3) |
||||
OP_NOP5 = CScriptOp(0xb4) |
||||
OP_NOP6 = CScriptOp(0xb5) |
||||
OP_NOP7 = CScriptOp(0xb6) |
||||
OP_NOP8 = CScriptOp(0xb7) |
||||
OP_NOP9 = CScriptOp(0xb8) |
||||
OP_NOP10 = CScriptOp(0xb9) |
||||
|
||||
# template matching params |
||||
OP_SMALLINTEGER = CScriptOp(0xfa) |
||||
OP_PUBKEYS = CScriptOp(0xfb) |
||||
OP_PUBKEYHASH = CScriptOp(0xfd) |
||||
OP_PUBKEY = CScriptOp(0xfe) |
||||
|
||||
OP_INVALIDOPCODE = CScriptOp(0xff) |
||||
|
||||
VALID_OPCODES = { |
||||
OP_1NEGATE, |
||||
OP_RESERVED, |
||||
OP_1, |
||||
OP_2, |
||||
OP_3, |
||||
OP_4, |
||||
OP_5, |
||||
OP_6, |
||||
OP_7, |
||||
OP_8, |
||||
OP_9, |
||||
OP_10, |
||||
OP_11, |
||||
OP_12, |
||||
OP_13, |
||||
OP_14, |
||||
OP_15, |
||||
OP_16, |
||||
|
||||
OP_NOP, |
||||
OP_VER, |
||||
OP_IF, |
||||
OP_NOTIF, |
||||
OP_VERIF, |
||||
OP_VERNOTIF, |
||||
OP_ELSE, |
||||
OP_ENDIF, |
||||
OP_VERIFY, |
||||
OP_RETURN, |
||||
|
||||
OP_TOALTSTACK, |
||||
OP_FROMALTSTACK, |
||||
OP_2DROP, |
||||
OP_2DUP, |
||||
OP_3DUP, |
||||
OP_2OVER, |
||||
OP_2ROT, |
||||
OP_2SWAP, |
||||
OP_IFDUP, |
||||
OP_DEPTH, |
||||
OP_DROP, |
||||
OP_DUP, |
||||
OP_NIP, |
||||
OP_OVER, |
||||
OP_PICK, |
||||
OP_ROLL, |
||||
OP_ROT, |
||||
OP_SWAP, |
||||
OP_TUCK, |
||||
|
||||
OP_CAT, |
||||
OP_SUBSTR, |
||||
OP_LEFT, |
||||
OP_RIGHT, |
||||
OP_SIZE, |
||||
|
||||
OP_INVERT, |
||||
OP_AND, |
||||
OP_OR, |
||||
OP_XOR, |
||||
OP_EQUAL, |
||||
OP_EQUALVERIFY, |
||||
OP_RESERVED1, |
||||
OP_RESERVED2, |
||||
|
||||
OP_1ADD, |
||||
OP_1SUB, |
||||
OP_2MUL, |
||||
OP_2DIV, |
||||
OP_NEGATE, |
||||
OP_ABS, |
||||
OP_NOT, |
||||
OP_0NOTEQUAL, |
||||
|
||||
OP_ADD, |
||||
OP_SUB, |
||||
OP_MUL, |
||||
OP_DIV, |
||||
OP_MOD, |
||||
OP_LSHIFT, |
||||
OP_RSHIFT, |
||||
|
||||
OP_BOOLAND, |
||||
OP_BOOLOR, |
||||
OP_NUMEQUAL, |
||||
OP_NUMEQUALVERIFY, |
||||
OP_NUMNOTEQUAL, |
||||
OP_LESSTHAN, |
||||
OP_GREATERTHAN, |
||||
OP_LESSTHANOREQUAL, |
||||
OP_GREATERTHANOREQUAL, |
||||
OP_MIN, |
||||
OP_MAX, |
||||
|
||||
OP_WITHIN, |
||||
|
||||
OP_RIPEMD160, |
||||
OP_SHA1, |
||||
OP_SHA256, |
||||
OP_HASH160, |
||||
OP_HASH256, |
||||
OP_CODESEPARATOR, |
||||
OP_CHECKSIG, |
||||
OP_CHECKSIGVERIFY, |
||||
OP_CHECKMULTISIG, |
||||
OP_CHECKMULTISIGVERIFY, |
||||
|
||||
OP_NOP1, |
||||
OP_NOP2, |
||||
OP_NOP3, |
||||
OP_NOP4, |
||||
OP_NOP5, |
||||
OP_NOP6, |
||||
OP_NOP7, |
||||
OP_NOP8, |
||||
OP_NOP9, |
||||
OP_NOP10, |
||||
|
||||
OP_SMALLINTEGER, |
||||
OP_PUBKEYS, |
||||
OP_PUBKEYHASH, |
||||
OP_PUBKEY, |
||||
} |
||||
|
||||
OPCODE_NAMES.update({ |
||||
OP_0 : 'OP_0', |
||||
OP_PUSHDATA1 : 'OP_PUSHDATA1', |
||||
OP_PUSHDATA2 : 'OP_PUSHDATA2', |
||||
OP_PUSHDATA4 : 'OP_PUSHDATA4', |
||||
OP_1NEGATE : 'OP_1NEGATE', |
||||
OP_RESERVED : 'OP_RESERVED', |
||||
OP_1 : 'OP_1', |
||||
OP_2 : 'OP_2', |
||||
OP_3 : 'OP_3', |
||||
OP_4 : 'OP_4', |
||||
OP_5 : 'OP_5', |
||||
OP_6 : 'OP_6', |
||||
OP_7 : 'OP_7', |
||||
OP_8 : 'OP_8', |
||||
OP_9 : 'OP_9', |
||||
OP_10 : 'OP_10', |
||||
OP_11 : 'OP_11', |
||||
OP_12 : 'OP_12', |
||||
OP_13 : 'OP_13', |
||||
OP_14 : 'OP_14', |
||||
OP_15 : 'OP_15', |
||||
OP_16 : 'OP_16', |
||||
OP_NOP : 'OP_NOP', |
||||
OP_VER : 'OP_VER', |
||||
OP_IF : 'OP_IF', |
||||
OP_NOTIF : 'OP_NOTIF', |
||||
OP_VERIF : 'OP_VERIF', |
||||
OP_VERNOTIF : 'OP_VERNOTIF', |
||||
OP_ELSE : 'OP_ELSE', |
||||
OP_ENDIF : 'OP_ENDIF', |
||||
OP_VERIFY : 'OP_VERIFY', |
||||
OP_RETURN : 'OP_RETURN', |
||||
OP_TOALTSTACK : 'OP_TOALTSTACK', |
||||
OP_FROMALTSTACK : 'OP_FROMALTSTACK', |
||||
OP_2DROP : 'OP_2DROP', |
||||
OP_2DUP : 'OP_2DUP', |
||||
OP_3DUP : 'OP_3DUP', |
||||
OP_2OVER : 'OP_2OVER', |
||||
OP_2ROT : 'OP_2ROT', |
||||
OP_2SWAP : 'OP_2SWAP', |
||||
OP_IFDUP : 'OP_IFDUP', |
||||
OP_DEPTH : 'OP_DEPTH', |
||||
OP_DROP : 'OP_DROP', |
||||
OP_DUP : 'OP_DUP', |
||||
OP_NIP : 'OP_NIP', |
||||
OP_OVER : 'OP_OVER', |
||||
OP_PICK : 'OP_PICK', |
||||
OP_ROLL : 'OP_ROLL', |
||||
OP_ROT : 'OP_ROT', |
||||
OP_SWAP : 'OP_SWAP', |
||||
OP_TUCK : 'OP_TUCK', |
||||
OP_CAT : 'OP_CAT', |
||||
OP_SUBSTR : 'OP_SUBSTR', |
||||
OP_LEFT : 'OP_LEFT', |
||||
OP_RIGHT : 'OP_RIGHT', |
||||
OP_SIZE : 'OP_SIZE', |
||||
OP_INVERT : 'OP_INVERT', |
||||
OP_AND : 'OP_AND', |
||||
OP_OR : 'OP_OR', |
||||
OP_XOR : 'OP_XOR', |
||||
OP_EQUAL : 'OP_EQUAL', |
||||
OP_EQUALVERIFY : 'OP_EQUALVERIFY', |
||||
OP_RESERVED1 : 'OP_RESERVED1', |
||||
OP_RESERVED2 : 'OP_RESERVED2', |
||||
OP_1ADD : 'OP_1ADD', |
||||
OP_1SUB : 'OP_1SUB', |
||||
OP_2MUL : 'OP_2MUL', |
||||
OP_2DIV : 'OP_2DIV', |
||||
OP_NEGATE : 'OP_NEGATE', |
||||
OP_ABS : 'OP_ABS', |
||||
OP_NOT : 'OP_NOT', |
||||
OP_0NOTEQUAL : 'OP_0NOTEQUAL', |
||||
OP_ADD : 'OP_ADD', |
||||
OP_SUB : 'OP_SUB', |
||||
OP_MUL : 'OP_MUL', |
||||
OP_DIV : 'OP_DIV', |
||||
OP_MOD : 'OP_MOD', |
||||
OP_LSHIFT : 'OP_LSHIFT', |
||||
OP_RSHIFT : 'OP_RSHIFT', |
||||
OP_BOOLAND : 'OP_BOOLAND', |
||||
OP_BOOLOR : 'OP_BOOLOR', |
||||
OP_NUMEQUAL : 'OP_NUMEQUAL', |
||||
OP_NUMEQUALVERIFY : 'OP_NUMEQUALVERIFY', |
||||
OP_NUMNOTEQUAL : 'OP_NUMNOTEQUAL', |
||||
OP_LESSTHAN : 'OP_LESSTHAN', |
||||
OP_GREATERTHAN : 'OP_GREATERTHAN', |
||||
OP_LESSTHANOREQUAL : 'OP_LESSTHANOREQUAL', |
||||
OP_GREATERTHANOREQUAL : 'OP_GREATERTHANOREQUAL', |
||||
OP_MIN : 'OP_MIN', |
||||
OP_MAX : 'OP_MAX', |
||||
OP_WITHIN : 'OP_WITHIN', |
||||
OP_RIPEMD160 : 'OP_RIPEMD160', |
||||
OP_SHA1 : 'OP_SHA1', |
||||
OP_SHA256 : 'OP_SHA256', |
||||
OP_HASH160 : 'OP_HASH160', |
||||
OP_HASH256 : 'OP_HASH256', |
||||
OP_CODESEPARATOR : 'OP_CODESEPARATOR', |
||||
OP_CHECKSIG : 'OP_CHECKSIG', |
||||
OP_CHECKSIGVERIFY : 'OP_CHECKSIGVERIFY', |
||||
OP_CHECKMULTISIG : 'OP_CHECKMULTISIG', |
||||
OP_CHECKMULTISIGVERIFY : 'OP_CHECKMULTISIGVERIFY', |
||||
OP_NOP1 : 'OP_NOP1', |
||||
OP_NOP2 : 'OP_NOP2', |
||||
OP_NOP3 : 'OP_NOP3', |
||||
OP_NOP4 : 'OP_NOP4', |
||||
OP_NOP5 : 'OP_NOP5', |
||||
OP_NOP6 : 'OP_NOP6', |
||||
OP_NOP7 : 'OP_NOP7', |
||||
OP_NOP8 : 'OP_NOP8', |
||||
OP_NOP9 : 'OP_NOP9', |
||||
OP_NOP10 : 'OP_NOP10', |
||||
OP_SMALLINTEGER : 'OP_SMALLINTEGER', |
||||
OP_PUBKEYS : 'OP_PUBKEYS', |
||||
OP_PUBKEYHASH : 'OP_PUBKEYHASH', |
||||
OP_PUBKEY : 'OP_PUBKEY', |
||||
OP_INVALIDOPCODE : 'OP_INVALIDOPCODE', |
||||
}) |
||||
|
||||
OPCODES_BY_NAME = { |
||||
'OP_0' : OP_0, |
||||
'OP_PUSHDATA1' : OP_PUSHDATA1, |
||||
'OP_PUSHDATA2' : OP_PUSHDATA2, |
||||
'OP_PUSHDATA4' : OP_PUSHDATA4, |
||||
'OP_1NEGATE' : OP_1NEGATE, |
||||
'OP_RESERVED' : OP_RESERVED, |
||||
'OP_1' : OP_1, |
||||
'OP_2' : OP_2, |
||||
'OP_3' : OP_3, |
||||
'OP_4' : OP_4, |
||||
'OP_5' : OP_5, |
||||
'OP_6' : OP_6, |
||||
'OP_7' : OP_7, |
||||
'OP_8' : OP_8, |
||||
'OP_9' : OP_9, |
||||
'OP_10' : OP_10, |
||||
'OP_11' : OP_11, |
||||
'OP_12' : OP_12, |
||||
'OP_13' : OP_13, |
||||
'OP_14' : OP_14, |
||||
'OP_15' : OP_15, |
||||
'OP_16' : OP_16, |
||||
'OP_NOP' : OP_NOP, |
||||
'OP_VER' : OP_VER, |
||||
'OP_IF' : OP_IF, |
||||
'OP_NOTIF' : OP_NOTIF, |
||||
'OP_VERIF' : OP_VERIF, |
||||
'OP_VERNOTIF' : OP_VERNOTIF, |
||||
'OP_ELSE' : OP_ELSE, |
||||
'OP_ENDIF' : OP_ENDIF, |
||||
'OP_VERIFY' : OP_VERIFY, |
||||
'OP_RETURN' : OP_RETURN, |
||||
'OP_TOALTSTACK' : OP_TOALTSTACK, |
||||
'OP_FROMALTSTACK' : OP_FROMALTSTACK, |
||||
'OP_2DROP' : OP_2DROP, |
||||
'OP_2DUP' : OP_2DUP, |
||||
'OP_3DUP' : OP_3DUP, |
||||
'OP_2OVER' : OP_2OVER, |
||||
'OP_2ROT' : OP_2ROT, |
||||
'OP_2SWAP' : OP_2SWAP, |
||||
'OP_IFDUP' : OP_IFDUP, |
||||
'OP_DEPTH' : OP_DEPTH, |
||||
'OP_DROP' : OP_DROP, |
||||
'OP_DUP' : OP_DUP, |
||||
'OP_NIP' : OP_NIP, |
||||
'OP_OVER' : OP_OVER, |
||||
'OP_PICK' : OP_PICK, |
||||
'OP_ROLL' : OP_ROLL, |
||||
'OP_ROT' : OP_ROT, |
||||
'OP_SWAP' : OP_SWAP, |
||||
'OP_TUCK' : OP_TUCK, |
||||
'OP_CAT' : OP_CAT, |
||||
'OP_SUBSTR' : OP_SUBSTR, |
||||
'OP_LEFT' : OP_LEFT, |
||||
'OP_RIGHT' : OP_RIGHT, |
||||
'OP_SIZE' : OP_SIZE, |
||||
'OP_INVERT' : OP_INVERT, |
||||
'OP_AND' : OP_AND, |
||||
'OP_OR' : OP_OR, |
||||
'OP_XOR' : OP_XOR, |
||||
'OP_EQUAL' : OP_EQUAL, |
||||
'OP_EQUALVERIFY' : OP_EQUALVERIFY, |
||||
'OP_RESERVED1' : OP_RESERVED1, |
||||
'OP_RESERVED2' : OP_RESERVED2, |
||||
'OP_1ADD' : OP_1ADD, |
||||
'OP_1SUB' : OP_1SUB, |
||||
'OP_2MUL' : OP_2MUL, |
||||
'OP_2DIV' : OP_2DIV, |
||||
'OP_NEGATE' : OP_NEGATE, |
||||
'OP_ABS' : OP_ABS, |
||||
'OP_NOT' : OP_NOT, |
||||
'OP_0NOTEQUAL' : OP_0NOTEQUAL, |
||||
'OP_ADD' : OP_ADD, |
||||
'OP_SUB' : OP_SUB, |
||||
'OP_MUL' : OP_MUL, |
||||
'OP_DIV' : OP_DIV, |
||||
'OP_MOD' : OP_MOD, |
||||
'OP_LSHIFT' : OP_LSHIFT, |
||||
'OP_RSHIFT' : OP_RSHIFT, |
||||
'OP_BOOLAND' : OP_BOOLAND, |
||||
'OP_BOOLOR' : OP_BOOLOR, |
||||
'OP_NUMEQUAL' : OP_NUMEQUAL, |
||||
'OP_NUMEQUALVERIFY' : OP_NUMEQUALVERIFY, |
||||
'OP_NUMNOTEQUAL' : OP_NUMNOTEQUAL, |
||||
'OP_LESSTHAN' : OP_LESSTHAN, |
||||
'OP_GREATERTHAN' : OP_GREATERTHAN, |
||||
'OP_LESSTHANOREQUAL' : OP_LESSTHANOREQUAL, |
||||
'OP_GREATERTHANOREQUAL' : OP_GREATERTHANOREQUAL, |
||||
'OP_MIN' : OP_MIN, |
||||
'OP_MAX' : OP_MAX, |
||||
'OP_WITHIN' : OP_WITHIN, |
||||
'OP_RIPEMD160' : OP_RIPEMD160, |
||||
'OP_SHA1' : OP_SHA1, |
||||
'OP_SHA256' : OP_SHA256, |
||||
'OP_HASH160' : OP_HASH160, |
||||
'OP_HASH256' : OP_HASH256, |
||||
'OP_CODESEPARATOR' : OP_CODESEPARATOR, |
||||
'OP_CHECKSIG' : OP_CHECKSIG, |
||||
'OP_CHECKSIGVERIFY' : OP_CHECKSIGVERIFY, |
||||
'OP_CHECKMULTISIG' : OP_CHECKMULTISIG, |
||||
'OP_CHECKMULTISIGVERIFY' : OP_CHECKMULTISIGVERIFY, |
||||
'OP_NOP1' : OP_NOP1, |
||||
'OP_NOP2' : OP_NOP2, |
||||
'OP_NOP3' : OP_NOP3, |
||||
'OP_NOP4' : OP_NOP4, |
||||
'OP_NOP5' : OP_NOP5, |
||||
'OP_NOP6' : OP_NOP6, |
||||
'OP_NOP7' : OP_NOP7, |
||||
'OP_NOP8' : OP_NOP8, |
||||
'OP_NOP9' : OP_NOP9, |
||||
'OP_NOP10' : OP_NOP10, |
||||
'OP_SMALLINTEGER' : OP_SMALLINTEGER, |
||||
'OP_PUBKEYS' : OP_PUBKEYS, |
||||
'OP_PUBKEYHASH' : OP_PUBKEYHASH, |
||||
'OP_PUBKEY' : OP_PUBKEY, |
||||
} |
||||
|
||||
class CScriptInvalidError(Exception): |
||||
"""Base class for CScript exceptions""" |
||||
pass |
||||
|
||||
class CScriptTruncatedPushDataError(CScriptInvalidError): |
||||
"""Invalid pushdata due to truncation""" |
||||
def __init__(self, msg, data): |
||||
self.data = data |
||||
super(CScriptTruncatedPushDataError, self).__init__(msg) |
||||
|
||||
# This is used, eg, for blockchain heights in coinbase scripts (bip34) |
||||
class CScriptNum(object): |
||||
def __init__(self, d=0): |
||||
self.value = d |
||||
|
||||
@staticmethod |
||||
def encode(obj): |
||||
r = bytearray(0) |
||||
if obj.value == 0: |
||||
return bytes(r) |
||||
neg = obj.value < 0 |
||||
absvalue = -obj.value if neg else obj.value |
||||
while (absvalue): |
||||
r.append(chr(absvalue & 0xff)) |
||||
absvalue >>= 8 |
||||
if r[-1] & 0x80: |
||||
r.append(0x80 if neg else 0) |
||||
elif neg: |
||||
r[-1] |= 0x80 |
||||
return bytes(bchr(len(r)) + r) |
||||
|
||||
|
||||
class CScript(bytes): |
||||
"""Serialized script |
||||
|
||||
A bytes subclass, so you can use this directly whenever bytes are accepted. |
||||
Note that this means that indexing does *not* work - you'll get an index by |
||||
byte rather than opcode. This format was chosen for efficiency so that the |
||||
general case would not require creating a lot of little CScriptOP objects. |
||||
|
||||
iter(script) however does iterate by opcode. |
||||
""" |
||||
@classmethod |
||||
def __coerce_instance(cls, other): |
||||
# Coerce other into bytes |
||||
if isinstance(other, CScriptOp): |
||||
other = bchr(other) |
||||
elif isinstance(other, CScriptNum): |
||||
if (other.value == 0): |
||||
other = bchr(CScriptOp(OP_0)) |
||||
else: |
||||
other = CScriptNum.encode(other) |
||||
elif isinstance(other, (int, long)): |
||||
if 0 <= other <= 16: |
||||
other = bytes(bchr(CScriptOp.encode_op_n(other))) |
||||
elif other == -1: |
||||
other = bytes(bchr(OP_1NEGATE)) |
||||
else: |
||||
other = CScriptOp.encode_op_pushdata(bignum.bn2vch(other)) |
||||
elif isinstance(other, (bytes, bytearray)): |
||||
other = CScriptOp.encode_op_pushdata(other) |
||||
return other |
||||
|
||||
def __add__(self, other): |
||||
# Do the coercion outside of the try block so that errors in it are |
||||
# noticed. |
||||
other = self.__coerce_instance(other) |
||||
|
||||
try: |
||||
# bytes.__add__ always returns bytes instances unfortunately |
||||
return CScript(super(CScript, self).__add__(other)) |
||||
except TypeError: |
||||
raise TypeError('Can not add a %r instance to a CScript' % other.__class__) |
||||
|
||||
def join(self, iterable): |
||||
# join makes no sense for a CScript() |
||||
raise NotImplementedError |
||||
|
||||
def __new__(cls, value=b''): |
||||
if isinstance(value, bytes) or isinstance(value, bytearray): |
||||
return super(CScript, cls).__new__(cls, value) |
||||
else: |
||||
def coerce_iterable(iterable): |
||||
for instance in iterable: |
||||
yield cls.__coerce_instance(instance) |
||||
# Annoyingly on both python2 and python3 bytes.join() always |
||||
# returns a bytes instance even when subclassed. |
||||
return super(CScript, cls).__new__(cls, b''.join(coerce_iterable(value))) |
||||
|
||||
def raw_iter(self): |
||||
"""Raw iteration |
||||
|
||||
Yields tuples of (opcode, data, sop_idx) so that the different possible |
||||
PUSHDATA encodings can be accurately distinguished, as well as |
||||
determining the exact opcode byte indexes. (sop_idx) |
||||
""" |
||||
i = 0 |
||||
while i < len(self): |
||||
sop_idx = i |
||||
opcode = bord(self[i]) |
||||
i += 1 |
||||
|
||||
if opcode > OP_PUSHDATA4: |
||||
yield (opcode, None, sop_idx) |
||||
else: |
||||
datasize = None |
||||
pushdata_type = None |
||||
if opcode < OP_PUSHDATA1: |
||||
pushdata_type = 'PUSHDATA(%d)' % opcode |
||||
datasize = opcode |
||||
|
||||
elif opcode == OP_PUSHDATA1: |
||||
pushdata_type = 'PUSHDATA1' |
||||
if i >= len(self): |
||||
raise CScriptInvalidError('PUSHDATA1: missing data length') |
||||
datasize = bord(self[i]) |
||||
i += 1 |
||||
|
||||
elif opcode == OP_PUSHDATA2: |
||||
pushdata_type = 'PUSHDATA2' |
||||
if i + 1 >= len(self): |
||||
raise CScriptInvalidError('PUSHDATA2: missing data length') |
||||
datasize = bord(self[i]) + (bord(self[i+1]) << 8) |
||||
i += 2 |
||||
|
||||
elif opcode == OP_PUSHDATA4: |
||||
pushdata_type = 'PUSHDATA4' |
||||
if i + 3 >= len(self): |
||||
raise CScriptInvalidError('PUSHDATA4: missing data length') |
||||
datasize = bord(self[i]) + (bord(self[i+1]) << 8) + (bord(self[i+2]) << 16) + (bord(self[i+3]) << 24) |
||||
i += 4 |
||||
|
||||
else: |
||||
assert False # shouldn't happen |
||||
|
||||
|
||||
data = bytes(self[i:i+datasize]) |
||||
|
||||
# Check for truncation |
||||
if len(data) < datasize: |
||||
raise CScriptTruncatedPushDataError('%s: truncated data' % pushdata_type, data) |
||||
|
||||
i += datasize |
||||
|
||||
yield (opcode, data, sop_idx) |
||||
|
||||
def __iter__(self): |
||||
"""'Cooked' iteration |
||||
|
||||
Returns either a CScriptOP instance, an integer, or bytes, as |
||||
appropriate. |
||||
|
||||
See raw_iter() if you need to distinguish the different possible |
||||
PUSHDATA encodings. |
||||
""" |
||||
for (opcode, data, sop_idx) in self.raw_iter(): |
||||
if data is not None: |
||||
yield data |
||||
else: |
||||
opcode = CScriptOp(opcode) |
||||
|
||||
if opcode.is_small_int(): |
||||
yield opcode.decode_op_n() |
||||
else: |
||||
yield CScriptOp(opcode) |
||||
|
||||
def __repr__(self): |
||||
# For Python3 compatibility add b before strings so testcases don't |
||||
# need to change |
||||
def _repr(o): |
||||
if isinstance(o, bytes): |
||||
return "x('%s')" % binascii.hexlify(o).decode('utf8') |
||||
else: |
||||
return repr(o) |
||||
|
||||
ops = [] |
||||
i = iter(self) |
||||
while True: |
||||
op = None |
||||
try: |
||||
op = _repr(next(i)) |
||||
except CScriptTruncatedPushDataError as err: |
||||
op = '%s...<ERROR: %s>' % (_repr(err.data), err) |
||||
break |
||||
except CScriptInvalidError as err: |
||||
op = '<ERROR: %s>' % err |
||||
break |
||||
except StopIteration: |
||||
break |
||||
finally: |
||||
if op is not None: |
||||
ops.append(op) |
||||
|
||||
return "CScript([%s])" % ', '.join(ops) |
||||
|
||||
def GetSigOpCount(self, fAccurate): |
||||
"""Get the SigOp count. |
||||
|
||||
fAccurate - Accurately count CHECKMULTISIG, see BIP16 for details. |
||||
|
||||
Note that this is consensus-critical. |
||||
""" |
||||
n = 0 |
||||
lastOpcode = OP_INVALIDOPCODE |
||||
for (opcode, data, sop_idx) in self.raw_iter(): |
||||
if opcode in (OP_CHECKSIG, OP_CHECKSIGVERIFY): |
||||
n += 1 |
||||
elif opcode in (OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY): |
||||
if fAccurate and (OP_1 <= lastOpcode <= OP_16): |
||||
n += opcode.decode_op_n() |
||||
else: |
||||
n += 20 |
||||
lastOpcode = opcode |
||||
return n |
||||
|
||||
|
||||
SIGHASH_ALL = 1 |
||||
SIGHASH_NONE = 2 |
||||
SIGHASH_SINGLE = 3 |
||||
SIGHASH_ANYONECANPAY = 0x80 |
||||
|
||||
def FindAndDelete(script, sig): |
||||
"""Consensus critical, see FindAndDelete() in Satoshi codebase""" |
||||
r = b'' |
||||
last_sop_idx = sop_idx = 0 |
||||
skip = True |
||||
for (opcode, data, sop_idx) in script.raw_iter(): |
||||
if not skip: |
||||
r += script[last_sop_idx:sop_idx] |
||||
last_sop_idx = sop_idx |
||||
if script[sop_idx:sop_idx + len(sig)] == sig: |
||||
skip = True |
||||
else: |
||||
skip = False |
||||
if not skip: |
||||
r += script[last_sop_idx:] |
||||
return CScript(r) |
||||
|
||||
|
||||
def SignatureHash(script, txTo, inIdx, hashtype): |
||||
"""Consensus-correct SignatureHash |
||||
|
||||
Returns (hash, err) to precisely match the consensus-critical behavior of |
||||
the SIGHASH_SINGLE bug. (inIdx is *not* checked for validity) |
||||
""" |
||||
HASH_ONE = b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' |
||||
|
||||
if inIdx >= len(txTo.vin): |
||||
return (HASH_ONE, "inIdx %d out of range (%d)" % (inIdx, len(txTo.vin))) |
||||
txtmp = CTransaction(txTo) |
||||
|
||||
for txin in txtmp.vin: |
||||
txin.scriptSig = b'' |
||||
txtmp.vin[inIdx].scriptSig = FindAndDelete(script, CScript([OP_CODESEPARATOR])) |
||||
|
||||
if (hashtype & 0x1f) == SIGHASH_NONE: |
||||
txtmp.vout = [] |
||||
|
||||
for i in range(len(txtmp.vin)): |
||||
if i != inIdx: |
||||
txtmp.vin[i].nSequence = 0 |
||||
|
||||
elif (hashtype & 0x1f) == SIGHASH_SINGLE: |
||||
outIdx = inIdx |
||||
if outIdx >= len(txtmp.vout): |
||||
return (HASH_ONE, "outIdx %d out of range (%d)" % (outIdx, len(txtmp.vout))) |
||||
|
||||
tmp = txtmp.vout[outIdx] |
||||
txtmp.vout = [] |
||||
for i in range(outIdx): |
||||
txtmp.vout.append(CTxOut()) |
||||
txtmp.vout.append(tmp) |
||||
|
||||
for i in range(len(txtmp.vin)): |
||||
if i != inIdx: |
||||
txtmp.vin[i].nSequence = 0 |
||||
|
||||
if hashtype & SIGHASH_ANYONECANPAY: |
||||
tmp = txtmp.vin[inIdx] |
||||
txtmp.vin = [] |
||||
txtmp.vin.append(tmp) |
||||
|
||||
s = txtmp.serialize() |
||||
s += struct.pack(b"<I", hashtype) |
||||
|
||||
hash = hash256(s) |
||||
|
||||
return (hash, None) |
@ -0,0 +1,253 @@
@@ -0,0 +1,253 @@
|
||||
#!/usr/bin/env python2 |
||||
# |
||||
# Distributed under the MIT/X11 software license, see the accompanying |
||||
# file COPYING or http://www.opensource.org/licenses/mit-license.php. |
||||
# |
||||
|
||||
''' |
||||
Test notes: |
||||
This test uses the script_valid and script_invalid tests from the unittest |
||||
framework to do end-to-end testing where we compare that two nodes agree on |
||||
whether blocks containing a given test script are valid. |
||||
|
||||
We generally ignore the script flags associated with each test (since we lack |
||||
the precision to test each script using those flags in this framework), but |
||||
for tests with SCRIPT_VERIFY_P2SH, we can use a block time after the BIP16 |
||||
switchover date to try to test with that flag enabled (and for tests without |
||||
that flag, we use a block time before the switchover date). |
||||
|
||||
NOTE: This test is very slow and may take more than 40 minutes to run. |
||||
''' |
||||
|
||||
from test_framework import ComparisonTestFramework |
||||
from util import * |
||||
from comptool import TestInstance, TestManager |
||||
from mininode import * |
||||
from blocktools import * |
||||
from script import * |
||||
import logging |
||||
import copy |
||||
import json |
||||
|
||||
script_valid_file = "../../src/test/data/script_valid.json" |
||||
script_invalid_file = "../../src/test/data/script_invalid.json" |
||||
|
||||
# Pass in a set of json files to open. |
||||
class ScriptTestFile(object): |
||||
|
||||
def __init__(self, files): |
||||
self.files = files |
||||
self.index = -1 |
||||
self.data = [] |
||||
|
||||
def load_files(self): |
||||
for f in self.files: |
||||
self.data.extend(json.loads(open(f).read())) |
||||
|
||||
# Skip over records that are not long enough to be tests |
||||
def get_records(self): |
||||
while (self.index < len(self.data)): |
||||
if len(self.data[self.index]) >= 3: |
||||
yield self.data[self.index] |
||||
self.index += 1 |
||||
|
||||
|
||||
# Helper for parsing the flags specified in the .json files |
||||
SCRIPT_VERIFY_NONE = 0 |
||||
SCRIPT_VERIFY_P2SH = 1 |
||||
SCRIPT_VERIFY_STRICTENC = 1 << 1 |
||||
SCRIPT_VERIFY_DERSIG = 1 << 2 |
||||
SCRIPT_VERIFY_LOW_S = 1 << 3 |
||||
SCRIPT_VERIFY_NULLDUMMY = 1 << 4 |
||||
SCRIPT_VERIFY_SIGPUSHONLY = 1 << 5 |
||||
SCRIPT_VERIFY_MINIMALDATA = 1 << 6 |
||||
SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS = 1 << 7 |
||||
SCRIPT_VERIFY_CLEANSTACK = 1 << 8 |
||||
|
||||
flag_map = { |
||||
"": SCRIPT_VERIFY_NONE, |
||||
"NONE": SCRIPT_VERIFY_NONE, |
||||
"P2SH": SCRIPT_VERIFY_P2SH, |
||||
"STRICTENC": SCRIPT_VERIFY_STRICTENC, |
||||
"DERSIG": SCRIPT_VERIFY_DERSIG, |
||||
"LOW_S": SCRIPT_VERIFY_LOW_S, |
||||
"NULLDUMMY": SCRIPT_VERIFY_NULLDUMMY, |
||||
"SIGPUSHONLY": SCRIPT_VERIFY_SIGPUSHONLY, |
||||
"MINIMALDATA": SCRIPT_VERIFY_MINIMALDATA, |
||||
"DISCOURAGE_UPGRADABLE_NOPS": SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS, |
||||
"CLEANSTACK": SCRIPT_VERIFY_CLEANSTACK, |
||||
} |
||||
|
||||
def ParseScriptFlags(flag_string): |
||||
flags = 0 |
||||
for x in flag_string.split(","): |
||||
if x in flag_map: |
||||
flags |= flag_map[x] |
||||
else: |
||||
print "Error: unrecognized script flag: ", x |
||||
return flags |
||||
|
||||
''' |
||||
Given a string that is a scriptsig or scriptpubkey from the .json files above, |
||||
convert it to a CScript() |
||||
''' |
||||
# Replicates behavior from core_read.cpp |
||||
def ParseScript(json_script): |
||||
script = json_script.split(" ") |
||||
parsed_script = CScript() |
||||
for x in script: |
||||
if len(x) == 0: |
||||
# Empty string, ignore. |
||||
pass |
||||
elif x.isdigit() or (len(x) >= 1 and x[0] == "-" and x[1:].isdigit()): |
||||
# Number |
||||
n = int(x, 0) |
||||
if (n == -1) or (n >= 1 and n <= 16): |
||||
parsed_script = CScript(bytes(parsed_script) + bytes(CScript([n]))) |
||||
else: |
||||
parsed_script += CScriptNum(int(x, 0)) |
||||
elif x.startswith("0x"): |
||||
# Raw hex data, inserted NOT pushed onto stack: |
||||
for i in xrange(2, len(x), 2): |
||||
parsed_script = CScript(bytes(parsed_script) + bytes(chr(int(x[i:i+2],16)))) |
||||
elif x.startswith("'") and x.endswith("'") and len(x) >= 2: |
||||
# Single-quoted string, pushed as data. |
||||
parsed_script += CScript([x[1:-1]]) |
||||
else: |
||||
# opcode, e.g. OP_ADD or ADD: |
||||
tryopname = "OP_" + x |
||||
if tryopname in OPCODES_BY_NAME: |
||||
parsed_script += CScriptOp(OPCODES_BY_NAME["OP_" + x]) |
||||
else: |
||||
print "ParseScript: error parsing '%s'" % x |
||||
return "" |
||||
return parsed_script |
||||
|
||||
class TestBuilder(object): |
||||
def create_credit_tx(self, scriptPubKey): |
||||
# self.tx1 is a coinbase transaction, modeled after the one created by script_tests.cpp |
||||
# This allows us to reuse signatures created in the unit test framework. |
||||
self.tx1 = create_coinbase() # this has a bip34 scriptsig, |
||||
self.tx1.vin[0].scriptSig = CScript([0, 0]) # but this matches the unit tests |
||||
self.tx1.vout[0].nValue = 0 |
||||
self.tx1.vout[0].scriptPubKey = scriptPubKey |
||||
self.tx1.rehash() |
||||
def create_spend_tx(self, scriptSig): |
||||
self.tx2 = create_transaction(self.tx1, 0, CScript(), 0) |
||||
self.tx2.vin[0].scriptSig = scriptSig |
||||
self.tx2.vout[0].scriptPubKey = CScript() |
||||
self.tx2.rehash() |
||||
def rehash(self): |
||||
self.tx1.rehash() |
||||
self.tx2.rehash() |
||||
|
||||
# This test uses the (default) two nodes provided by ComparisonTestFramework, |
||||
# specified on the command line with --testbinary and --refbinary. |
||||
# See comptool.py |
||||
class ScriptTest(ComparisonTestFramework): |
||||
|
||||
def run_test(self): |
||||
# Set up the comparison tool TestManager |
||||
test = TestManager(self, self.options.tmpdir) |
||||
test.add_all_connections(self.nodes) |
||||
|
||||
# Load scripts |
||||
self.scripts = ScriptTestFile([script_valid_file, script_invalid_file]) |
||||
self.scripts.load_files() |
||||
|
||||
# Some variables we re-use between test instances (to build blocks) |
||||
self.tip = None |
||||
self.block_time = None |
||||
|
||||
NetworkThread().start() # Start up network handling in another thread |
||||
test.run() |
||||
|
||||
def generate_test_instance(self, pubkeystring, scriptsigstring): |
||||
scriptpubkey = ParseScript(pubkeystring) |
||||
scriptsig = ParseScript(scriptsigstring) |
||||
|
||||
test = TestInstance(sync_every_block=False) |
||||
test_build = TestBuilder() |
||||
test_build.create_credit_tx(scriptpubkey) |
||||
test_build.create_spend_tx(scriptsig) |
||||
test_build.rehash() |
||||
|
||||
block = create_block(self.tip, test_build.tx1, self.block_time) |
||||
self.block_time += 1 |
||||
block.solve() |
||||
self.tip = block.sha256 |
||||
test.blocks_and_transactions = [[block, True]] |
||||
|
||||
for i in xrange(100): |
||||
block = create_block(self.tip, create_coinbase(), self.block_time) |
||||
self.block_time += 1 |
||||
block.solve() |
||||
self.tip = block.sha256 |
||||
test.blocks_and_transactions.append([block, True]) |
||||
|
||||
block = create_block(self.tip, create_coinbase(), self.block_time) |
||||
self.block_time += 1 |
||||
block.vtx.append(test_build.tx2) |
||||
block.hashMerkleRoot = block.calc_merkle_root() |
||||
block.rehash() |
||||
block.solve() |
||||
test.blocks_and_transactions.append([block, None]) |
||||
return test |
||||
|
||||
# This generates the tests for TestManager. |
||||
def get_tests(self): |
||||
self.tip = int ("0x" + self.nodes[0].getbestblockhash() + "L", 0) |
||||
self.block_time = 1333230000 # before the BIP16 switchover |
||||
|
||||
''' |
||||
Create a new block with an anyone-can-spend coinbase |
||||
''' |
||||
block = create_block(self.tip, create_coinbase(), self.block_time) |
||||
self.block_time += 1 |
||||
block.solve() |
||||
self.tip = block.sha256 |
||||
yield TestInstance(objects=[[block, True]]) |
||||
|
||||
''' |
||||
Build out to 100 blocks total, maturing the coinbase. |
||||
''' |
||||
test = TestInstance(objects=[], sync_every_block=False, sync_every_tx=False) |
||||
for i in xrange(100): |
||||
b = create_block(self.tip, create_coinbase(), self.block_time) |
||||
b.solve() |
||||
test.blocks_and_transactions.append([b, True]) |
||||
self.tip = b.sha256 |
||||
self.block_time += 1 |
||||
yield test |
||||
|
||||
''' Iterate through script tests. ''' |
||||
counter = 0 |
||||
for script_test in self.scripts.get_records(): |
||||
''' Reset the blockchain to genesis block + 100 blocks. ''' |
||||
if self.nodes[0].getblockcount() > 101: |
||||
self.nodes[0].invalidateblock(self.nodes[0].getblockhash(102)) |
||||
self.nodes[1].invalidateblock(self.nodes[1].getblockhash(102)) |
||||
|
||||
self.tip = int ("0x" + self.nodes[0].getbestblockhash() + "L", 0) |
||||
|
||||
[scriptsig, scriptpubkey, flags] = script_test[0:3] |
||||
flags = ParseScriptFlags(flags) |
||||
|
||||
# We can use block time to determine whether the nodes should be |
||||
# enforcing BIP16. |
||||
# |
||||
# We intentionally let the block time grow by 1 each time. |
||||
# This forces the block hashes to differ between tests, so that |
||||
# a call to invalidateblock doesn't interfere with a later test. |
||||
if (flags & SCRIPT_VERIFY_P2SH): |
||||
self.block_time = 1333238400 + counter # Advance to enforcing BIP16 |
||||
else: |
||||
self.block_time = 1333230000 + counter # Before the BIP16 switchover |
||||
|
||||
print "Script test: [%s]" % script_test |
||||
|
||||
yield self.generate_test_instance(scriptpubkey, scriptsig) |
||||
counter += 1 |
||||
|
||||
if __name__ == '__main__': |
||||
ScriptTest().main() |
Loading…
Reference in new issue