Moved ecrecover and signing to a function in utils

Author: vub

ethereum/specials.py

@@ -1,10 +1,6 @@
 # -*- coding: utf8 -*-
 import bitcoin
 from rlp.utils import ascii_chr
-try:
-    from secp256k1 import PublicKey, ALL_FLAGS
-except:
-    pass
 
 from ethereum import utils, opcodes
 from ethereum.utils import safe_ord, decode_hex
@@ -32,34 +28,11 @@ def proc_ecrecover(ext, msg):
 
     if r >= bitcoin.N or s >= bitcoin.N or v < 27 or v > 28:
         return 1, msg.gas - opcodes.GECRECOVER, []
-
     try:
-        signature_bytes = [0] * 64
-        msg.data.extract_copy(signature_bytes, 0, 64, 32)
-        msg.data.extract_copy(signature_bytes, 32, 96, 32)
-        signature = b''.join(map(ascii_chr, signature_bytes))
-    
-        pk = PublicKey(flags=ALL_FLAGS)
-        try:
-            pk.public_key = pk.ecdsa_recover(
-                message_hash,
-                pk.ecdsa_recoverable_deserialize(
-                    signature,
-                    v - 27
-                ),
-                raw=True
-            )
-        except Exception:
-            # Recovery failed
-            return 1, msg.gas - gas_cost, []
-    
-        pub = pk.serialize(compressed=False)
+        pub = utils.ecrecover_to_pub(message_hash, v, r, s)
     except:
-        recovered_addr = bitcoin.ecdsa_raw_recover(message_hash, (v, r, s))
-        if recovered_addr in (False, (0, 0)):
-            return 1, msg.gas - gas_cost, []
-        pub = bitcoin.encode_pubkey(recovered_addr, 'bin')
-    o = [0] * 12 + [safe_ord(x) for x in utils.sha3(pub[1:])[-20:]]
+        return 1, msg.gas - gas_cost, []
+    o = [0] * 12 + [safe_ord(x) for x in utils.sha3(pub)[-20:]]
     return 1, msg.gas - gas_cost, o
 
 

ethereum/testutils.py

@@ -10,7 +10,9 @@
 from ethereum.db import EphemDB
 from ethereum.utils import to_string, safe_ord, parse_int_or_hex, zpad
 from ethereum.utils import remove_0x_head, int_to_hex, normalize_address
+from ethereum.block import FakeHeader
 from ethereum.config import Env
+from ethereum.config import default_config
 from ethereum import state_transition
 from state import State
 import json
@@ -44,7 +46,7 @@
 check_vm_test = lambda params: run_vm_test(params, VERIFY)
 time_vm_test = lambda params: run_vm_test(params, TIME)
 fill_state_test = lambda params: run_state_test(params, FILL)
-check_state_test = lambda params: run_state_test(params, VERIFY)
+check_state_test = lambda params: run_state_test1(params, VERIFY)
 time_state_test = lambda params: run_state_test(params, TIME)
 fill_ethash_test = lambda params: run_ethash_test(params, FILL)
 check_ethash_test = lambda params: run_ethash_test(params, VERIFY)
@@ -60,7 +62,10 @@
 
 
 def normalize_hex(s):
-    s = (s if len(s) > 2 else b'0x00')
+    if s[:2] != '0x':
+        s = '0x' + s
+    if s == '0x':
+        s = '0x00'
     if len(s) < 66:
         s = s[:2] + b'0' * (66 - len(s)) + s[2:]
     return s
@@ -278,12 +283,6 @@ def normalize_value(k, p):
     elif mode == TIME:
         return time_post - time_pre
 
-
-class FakeHeader():
-    def __init__(self, h):
-        self.hash = h
-        self.uncles = []
-
 fake_headers = {}
 
 def mk_fake_header(blknum):
@@ -300,13 +299,16 @@ def run_state_test1(params, mode):
                                    'previousHash', 'currentCoinbase',
                                    'currentDifficulty', 'currentNumber'])
     assert len(env['currentCoinbase']) == 40
+
+    default_config['HOMESTEAD_FORK_BLKNUM'] = 1000000
 
     state = State(db=db,
                   prev_headers=[mk_fake_header(i) for i in range(parse_int_or_hex(env['currentNumber']) -1, max(-1, parse_int_or_hex(env['currentNumber']) -257), -1)],
                   block_number=parse_int_or_hex(env['currentNumber']),
                   block_coinbase=utils.normalize_address(env['currentCoinbase']),
                   timestamp=parse_int_or_hex(env['currentTimestamp']),
-                  gas_limit=parse_int_or_hex(env['currentGasLimit']))
+                  gas_limit=parse_int_or_hex(env['currentGasLimit']),
+                  block_difficulty=parse_int_or_hex(env['currentDifficulty']))
     # setup state
     for address, h in list(pre.items()):
         assert len(address) == 40
@@ -342,6 +344,7 @@ def run_state_test1(params, mode):
         success, output = False, b''
         time_pre = time.time()
         time_post = time_pre
+        state.commit()
     else:
         if 'secretKey' in exek:
             tx.sign(exek['secretKey'])
@@ -354,7 +357,6 @@ def run_state_test1(params, mode):
 
         time_pre = time.time()
         state.commit()
-        print state.to_dict()
         snapshot = state.snapshot()
         try:
             print('trying')
@@ -372,10 +374,41 @@ def run_state_test1(params, mode):
             pass
         time_post = time.time()
 
+
         if tx.to == b'':
             output = state.get_code(output) if output else b''
 
 
+    params2 = copy.deepcopy(params)
+    if success:
+        params2['logs'] = [log.to_dict() for log in logs]
+
+
+    params2['out'] = b'0x' + encode_hex(output)
+    params2['post'] = copy.deepcopy(state.to_dict())
+    params2['postStateRoot'] = encode_hex(state.trie.root_hash)
+
+    if mode == FILL:
+        return params2
+    elif mode == VERIFY:
+        params1 = copy.deepcopy(params)
+        shouldbe, reallyis = params1.get('post', None), params2.get('post', None)
+        compare_post_states(shouldbe, reallyis)
+        for k in ['pre', 'exec', 'env', 'callcreates',
+                  'out', 'gas', 'logs', 'postStateRoot']:
+            _shouldbe = params1.get(k, None)
+            _reallyis = params2.get(k, None)
+            if _shouldbe != _reallyis:
+                print 's', shouldbe
+                print 'r', reallyis
+                print state.trie.to_dict()
+                raise Exception("Mismatch: " + k + ':\n shouldbe %r\n reallyis %r' %
+                                (_shouldbe, _reallyis))
+
+    elif mode == TIME:
+        return time_post - time_pre
+
+
 # Fills up a vm test without post data, or runs the test
 def run_state_test(params, mode):
     pre = params['pre']

ethereum/transactions.py

@@ -3,17 +3,13 @@
 from bitcoin import encode_pubkey, N, encode_privkey, ecdsa_raw_sign
 from rlp.sedes import big_endian_int, binary
 from rlp.utils import encode_hex, str_to_bytes, ascii_chr
-try:
-    from secp256k1 import PublicKey, ALL_FLAGS, PrivateKey
-except:
-    pass
 
 from ethereum.exceptions import InvalidTransaction
 from ethereum import bloom
 from ethereum import opcodes
 from ethereum import utils
 from ethereum.slogging import get_logger
-from ethereum.utils import TT256, mk_contract_address, zpad, int_to_32bytearray, big_endian_to_int
+from ethereum.utils import TT256, mk_contract_address, zpad, int_to_32bytearray, big_endian_to_int, ecsign, ecrecover_to_pub
 
 
 log = get_logger('eth.chain.tx')
@@ -84,33 +80,10 @@ def sender(self):
                 log.debug('recovering sender')
                 rlpdata = rlp.encode(self, UnsignedTransaction)
                 rawhash = utils.sha3(rlpdata)
-
-                try:
-                    pk = PublicKey(flags=ALL_FLAGS)
-                    using_pk = 1
-                except:
-                    pk, using_pk = None, 0
-                if not using_pk:
-                    recovered_addr = bitcoin.ecdsa_raw_recover(rawhash, (self.v, self.r, self.s))
-                    pub = bitcoin.encode_pubkey(recovered_addr, 'bin')
-                else:
-                    try:
-                        pk.public_key = pk.ecdsa_recover(
-                            rawhash,
-                            pk.ecdsa_recoverable_deserialize(
-                                zpad(utils.bytearray_to_bytestr(int_to_32bytearray(self.r)), 32) + zpad(utils.bytearray_to_bytestr(int_to_32bytearray(self.s)), 32),
-                                self.v - 27
-                            ),
-                            raw=True
-                        )
-                        pub = pk.serialize(compressed=False)
-                    except Exception:
-                        raise InvalidTransaction("Invalid signature values (x^3+7 is non-residue)")
-
-                if pub[1:] == b"\x00" * 32:
+                pub = ecrecover_to_pub(rawhash, self.v, self.r, self.s)
+                if pub == b"\x00" * 64:
                     raise InvalidTransaction("Invalid signature (zero privkey cannot sign)")
-                pub = encode_pubkey(pub, 'bin')
-                self._sender = utils.sha3(pub[1:])[-20:]
+                self._sender = utils.sha3(pub)[-20:]
                 assert self.sender == self._sender
             else:
                 self._sender = 0
@@ -133,17 +106,7 @@ def sign(self, key):
             # we need a binary key
             key = encode_privkey(key, 'bin')
 
-        try:
-            pk = PrivateKey(key, raw=True)
-            signature = pk.ecdsa_recoverable_serialize(
-                pk.ecdsa_sign_recoverable(rawhash, raw=True)
-            )
-            signature = signature[0] + utils.bytearray_to_bytestr([signature[1]])
-            self.v = utils.safe_ord(signature[64]) + 27
-            self.r = big_endian_to_int(signature[0:32])
-            self.s = big_endian_to_int(signature[32:64])
-        except:
-            self.v, self.r, self.s = ecdsa_raw_sign(rawhash, key)
+        self.v, self.r, self.s = ecsign(rawhash, key)
 
         self.sender = utils.privtoaddr(key)
         return self

ethereum/utils.py

@@ -4,13 +4,18 @@
 except:
     import sha3 as _sha3
     sha3_256 = lambda x: _sha3.sha3_256(x).digest()
-from bitcoin import privtopub
+from bitcoin import privtopub, ecdsa_raw_sign, ecdsa_raw_recover, encode_pubkey
 import sys
 import rlp
 from rlp.sedes import big_endian_int, BigEndianInt, Binary
 from rlp.utils import decode_hex, encode_hex, ascii_chr, str_to_bytes
 import random
 
+try:
+    from secp256k1 import PublicKey, ALL_FLAGS, PrivateKey
+except:
+    pass
+
 big_endian_to_int = lambda x: big_endian_int.deserialize(str_to_bytes(x).lstrip(b'\x00'))
 int_to_big_endian = lambda x: big_endian_int.serialize(x)
 
@@ -65,6 +70,41 @@ def bytearray_to_bytestr(value):
 isnumeric = is_numeric
 
 
+def ecrecover_to_pub(rawhash, v, r, s):
+    try:
+        pk = PublicKey(flags=ALL_FLAGS)
+        using_pk = 1
+        pk.public_key = pk.ecdsa_recover(
+            rawhash,
+            pk.ecdsa_recoverable_deserialize(
+                zpad(utils.bytearray_to_bytestr(int_to_32bytearray(r)), 32) + zpad(utils.bytearray_to_bytestr(int_to_32bytearray(s)), 32),
+                v - 27
+            ),
+            raw=True
+        )
+        pub = pk.serialize(compressed=False)[1:]
+    except:
+        recovered_addr = ecdsa_raw_recover(rawhash, (v, r, s))
+        pub = encode_pubkey(recovered_addr, 'bin_electrum')
+    assert len(pub) == 64
+    return pub
+
+
+def ecsign(rawhash, key):
+    try:
+        pk = PrivateKey(key, raw=True)
+        signature = pk.ecdsa_recoverable_serialize(
+            pk.ecdsa_sign_recoverable(rawhash, raw=True)
+        )
+        signature = signature[0] + utils.bytearray_to_bytestr([signature[1]])
+        v = utils.safe_ord(signature[64]) + 27
+        r = big_endian_to_int(signature[0:32])
+        s = big_endian_to_int(signature[32:64])
+    except:
+        v, r, s = ecdsa_raw_sign(rawhash, key)
+    return v, r, s
+
+
 def mk_contract_address(sender, nonce):
     return sha3(rlp.encode([normalize_address(sender), nonce]))[12:]