Bug fixes

Author: vub

ethereum/blocks.py

@@ -14,7 +14,8 @@
 from ethereum.pruning_trie import Trie
 from ethereum.securetrie import SecureTrie
 from ethereum import utils
-from ethereum.utils import address, int256, trie_root, hash32, to_string,
+from ethereum.utils import address, int256, trie_root, hash32, to_string
+from ethereum.utils import big_endian_to_int
 from ethereum import processblock
 from ethereum.transactions import Transaction
 from ethereum import bloom
@@ -990,7 +991,7 @@ def get_storage_data(self, address, index):
         if len(bytez) >= 32:
             return big_endian_to_int(bytez[-32:])
         else:
-            return big_endian_to_int(bytez) * (1 << (8 * (32 - len(bytes))))
+            return big_endian_to_int(bytez) * (1 << (8 * (32 - len(bytez))))
 
     def set_storage_data(self, address, index, value):
         """Set a specific item in the storage of an account.
@@ -1006,6 +1007,7 @@ def set_storage_data(self, address, index, value):
         if CACHE_KEY not in self.caches:
             self.caches[CACHE_KEY] = {}
             self.set_and_journal('all', address, True)
+        assert isinstance(value, (str, bytes))
         self.set_and_journal(CACHE_KEY, index, value)
 
     def account_exists(self, address):

ethereum/specials.py

@@ -1,7 +1,10 @@
 # -*- coding: utf8 -*-
 import bitcoin
 from rlp.utils import ascii_chr
-from secp256k1 import PublicKey, ALL_FLAGS
+try:
+    from secp256k1 import PublicKey, ALL_FLAGS
+except:
+    pass
 
 from ethereum import utils, opcodes
 from ethereum.utils import safe_ord, decode_hex
@@ -30,26 +33,32 @@ 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, []
 
-    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)
+        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)
+    except:
+        recovered_addr = bitcoin.ecdsa_raw_recover(h, (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
 

ethereum/testutils.py

@@ -8,7 +8,7 @@
 from ethereum import processblock as pb
 import copy
 from ethereum.db import EphemDB
-from ethereum.utils import to_string, safe_ord, parse_int_or_hex
+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.config import Env
 import json
@@ -58,7 +58,10 @@
 
 
 def normalize_hex(s):
-    return s if len(s) > 2 else b'0x00'
+    s = (s if len(s) > 2 else b'0x00')
+    if len(s) < 66:
+        s = s[:2] + b'0' * (66 - len(s)) + s[2:]
+    return s
 
 
 def acct_standard_form(a):
@@ -154,7 +157,7 @@ def run_vm_test(params, mode, profiler=None):
         for k, v in h['storage'].items():
             blk.set_storage_data(address,
                                  utils.big_endian_to_int(decode_hex(k[2:])),
-                                 utils.big_endian_to_int(decode_hex(v[2:])))
+                                 zpad(decode_hex(v[2:]), 32))
 
     # execute transactions
     sender = decode_hex(exek['caller'])  # a party that originates a call
@@ -306,7 +309,7 @@ def run_state_test(params, mode):
         for k, v in h['storage'].items():
             blk.set_storage_data(address,
                                  utils.big_endian_to_int(decode_hex(k[2:])),
-                                 utils.big_endian_to_int(decode_hex(v[2:])))
+                                 zpad(decode_hex(v[2:]), 32))
 
     for address, h in list(pre.items()):
         address = decode_hex(address)

ethereum/transactions.py

@@ -3,7 +3,10 @@
 from bitcoin import encode_pubkey, N, encode_privkey
 from rlp.sedes import big_endian_int, binary
 from rlp.utils import encode_hex, str_to_bytes, ascii_chr
-from secp256k1 import PublicKey, ALL_FLAGS, PrivateKey
+try:
+    from secp256k1 import PublicKey, ALL_FLAGS, PrivateKey
+except:
+    pass
 
 from ethereum.exceptions import InvalidTransaction
 from ethereum import bloom
@@ -82,19 +85,27 @@ def sender(self):
                 rlpdata = rlp.encode(self, UnsignedTransaction)
                 rawhash = utils.sha3(rlpdata)
 
-                pk = PublicKey(flags=ALL_FLAGS)
                 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)")
+                    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:
                     raise InvalidTransaction("Invalid signature (zero privkey cannot sign)")