lukechilds
/
electrum
mirror of https://github.com/lukechilds/electrum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Moved bitcoin.py tests to their own file 

This allows standard python testing tools to discover and run them.
283
Chris Glass 11 years ago
parent
a286b18aed
commit
73c33820db
3 changed files with 112 additions and 113 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 139
      lib/bitcoin.py
  2. 0
      lib/tests/__init__.py
  3. 86
      lib/tests/test_bitcoin.py

139
lib/bitcoin.py
View File

@ -23,6 +23,7 @@ import re
import sys import sys
import hmac import hmac
from util import print_error
try: try:
import ecdsa import ecdsa
@ -34,15 +35,9 @@ try:
except ImportError: except ImportError:
sys.exit("Error: AES does not seem to be installed. Try 'sudo pip install slowaes'") sys.exit("Error: AES does not seem to be installed. Try 'sudo pip install slowaes'")
try: ################################## transactions
import pbkdf2
except ImportError:
sys.exit("Error: pbkdf2 does not seem to be installed. Try 'sudo pip install pbkdf2'")
from util import print_error
MIN_RELAY_TX_FEE = 1000
# AES encryption # AES encryption
@ -99,7 +94,7 @@ def op_push(i):
return '4d' + int_to_hex(i,2) return '4d' + int_to_hex(i,2)
else: else:
return '4e' + int_to_hex(i,4) return '4e' + int_to_hex(i,4)
def sha256(x): def sha256(x):
@ -136,7 +131,7 @@ def is_old_seed(seed):
is_hex = (len(seed) == 32) is_hex = (len(seed) == 32)
except Exception: except Exception:
is_hex = False is_hex = False
return is_hex or (uses_electrum_words and len(words) == 12) return is_hex or (uses_electrum_words and len(words) == 12)
@ -164,9 +159,9 @@ def i2d_ECPrivateKey(pkey, compressed=False):
'022100' + \ '022100' + \
'%064x' % _r + \ '%064x' % _r + \
'020101a144034200' '020101a144034200'
return key.decode('hex') + i2o_ECPublicKey(pkey.pubkey, compressed) return key.decode('hex') + i2o_ECPublicKey(pkey.pubkey, compressed)
def i2o_ECPublicKey(pubkey, compressed=False): def i2o_ECPublicKey(pubkey, compressed=False):
# public keys are 65 bytes long (520 bits) # public keys are 65 bytes long (520 bits)
# 0x04 + 32-byte X-coordinate + 32-byte Y-coordinate # 0x04 + 32-byte X-coordinate + 32-byte Y-coordinate
@ -181,14 +176,14 @@ def i2o_ECPublicKey(pubkey, compressed=False):
key = '04' + \ key = '04' + \
'%064x' % pubkey.point.x() + \ '%064x' % pubkey.point.x() + \
'%064x' % pubkey.point.y() '%064x' % pubkey.point.y()
return key.decode('hex') return key.decode('hex')
# end pywallet openssl private key implementation # end pywallet openssl private key implementation
############ functions from pywallet ##################### ############ functions from pywallet #####################
def hash_160(public_key): def hash_160(public_key):
try: try:
@ -349,7 +344,7 @@ def is_address(addr):
def is_private_key(key): def is_private_key(key):
try: try:
k = ASecretToSecret(key) k = ASecretToSecret(key)
return k is not False return k is not False
except: except:
return False return False
@ -513,19 +508,19 @@ class EC_KEY(object):
@classmethod @classmethod
def encrypt_message(self, message, pubkey): def encrypt_message(self, message, pubkey):
pk = ser_to_point(pubkey) pk = ser_to_point(pubkey)
if not ecdsa.ecdsa.point_is_valid(generator_secp256k1, pk.x(), pk.y()): if not ecdsa.ecdsa.point_is_valid(generator_secp256k1, pk.x(), pk.y()):
raise Exception('invalid pubkey') raise Exception('invalid pubkey')
ephemeral_exponent = number_to_string(ecdsa.util.randrange(pow(2,256)), generator_secp256k1.order()) ephemeral_exponent = number_to_string(ecdsa.util.randrange(pow(2,256)), generator_secp256k1.order())
ephemeral = EC_KEY(ephemeral_exponent) ephemeral = EC_KEY(ephemeral_exponent)
ecdh_key = (pk * ephemeral.privkey.secret_multiplier).x() ecdh_key = (pk * ephemeral.privkey.secret_multiplier).x()
ecdh_key = ('%064x' % ecdh_key).decode('hex') ecdh_key = ('%064x' % ecdh_key).decode('hex')
key = hashlib.sha512(ecdh_key).digest() key = hashlib.sha512(ecdh_key).digest()
key_e, key_m = key[:32], key[32:] key_e, key_m = key[:32], key[32:]
iv_ciphertext = aes.encryptData(key_e, message) iv_ciphertext = aes.encryptData(key_e, message)
ephemeral_pubkey = ephemeral.get_public_key(compressed=True).decode('hex') ephemeral_pubkey = ephemeral.get_public_key(compressed=True).decode('hex')
@ -536,20 +531,20 @@ class EC_KEY(object):
def decrypt_message(self, encrypted): def decrypt_message(self, encrypted):
encrypted = base64.b64decode(encrypted) encrypted = base64.b64decode(encrypted)
if len(encrypted) < 85: if len(encrypted) < 85:
raise Exception('invalid ciphertext: length') raise Exception('invalid ciphertext: length')
magic = encrypted[:4] magic = encrypted[:4]
ephemeral_pubkey = encrypted[4:37] ephemeral_pubkey = encrypted[4:37]
iv_ciphertext = encrypted[37:-32] iv_ciphertext = encrypted[37:-32]
mac = encrypted[-32:] mac = encrypted[-32:]
if magic != 'BIE1': if magic != 'BIE1':
raise Exception('invalid ciphertext: invalid magic bytes') raise Exception('invalid ciphertext: invalid magic bytes')
try: try:
ephemeral_pubkey = ser_to_point(ephemeral_pubkey) ephemeral_pubkey = ser_to_point(ephemeral_pubkey)
except AssertionError, e: except AssertionError, e:
@ -608,10 +603,10 @@ def _CKD_priv(k, c, s, is_prime):
return k_n, c_n return k_n, c_n
# Child public key derivation function (from public key only) # Child public key derivation function (from public key only)
# K = master public key # K = master public key
# c = master chain code # c = master chain code
# n = index of key we want to derive # n = index of key we want to derive
# This function allows us to find the nth public key, as long as n is # This function allows us to find the nth public key, as long as n is
# non-negative. If n is negative, we need the master private key to find it. # non-negative. If n is negative, we need the master private key to find it.
def CKD_pub(cK, c, n): def CKD_pub(cK, c, n):
if n & BIP32_PRIME: raise if n & BIP32_PRIME: raise
@ -633,7 +628,7 @@ def _CKD_pub(cK, c, s):
def deserialize_xkey(xkey): def deserialize_xkey(xkey):
xkey = DecodeBase58Check(xkey) xkey = DecodeBase58Check(xkey)
assert len(xkey) == 78 assert len(xkey) == 78
assert xkey[0:4].encode('hex') in ["0488ade4", "0488b21e"] assert xkey[0:4].encode('hex') in ["0488ade4", "0488b21e"]
depth = ord(xkey[4]) depth = ord(xkey[4])
@ -650,7 +645,7 @@ def deserialize_xkey(xkey):
def bip32_root(seed): def bip32_root(seed):
import hmac import hmac
seed = seed.decode('hex') seed = seed.decode('hex')
I = hmac.new("Bitcoin seed", seed, hashlib.sha512).digest() I = hmac.new("Bitcoin seed", seed, hashlib.sha512).digest()
master_k = I[0:32] master_k = I[0:32]
master_c = I[32:] master_c = I[32:]
@ -709,86 +704,4 @@ def bip32_private_key(sequence, k, chain):
################################## transactions
MIN_RELAY_TX_FEE = 1000
import unittest
class Test_bitcoin(unittest.TestCase):
def test_crypto(self):
for message in ["Chancellor on brink of second bailout for banks", chr(255)*512]:
self.do_test_crypto(message)
def do_test_crypto(self, message):
G = generator_secp256k1
_r = G.order()
pvk = ecdsa.util.randrange( pow(2,256) ) %_r
Pub = pvk*G
pubkey_c = point_to_ser(Pub,True)
pubkey_u = point_to_ser(Pub,False)
addr_c = public_key_to_bc_address(pubkey_c)
addr_u = public_key_to_bc_address(pubkey_u)
#print "Private key ", '%064x'%pvk
eck = EC_KEY(number_to_string(pvk,_r))
#print "Compressed public key ", pubkey_c.encode('hex')
enc = EC_KEY.encrypt_message(message, pubkey_c)
dec = eck.decrypt_message(enc)
assert dec == message
#print "Uncompressed public key", pubkey_u.encode('hex')
enc2 = EC_KEY.encrypt_message(message, pubkey_u)
dec2 = eck.decrypt_message(enc)
assert dec2 == message
signature = eck.sign_message(message, True, addr_c)
#print signature
EC_KEY.verify_message(addr_c, signature, message)
def test_bip32(self):
# see https://en.bitcoin.it/wiki/BIP_0032_TestVectors
xpub, xprv = self.do_test_bip32("000102030405060708090a0b0c0d0e0f", "m/0'/1/2'/2/1000000000")
assert xpub == "xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy"
assert xprv == "xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76"
xpub, xprv = self.do_test_bip32("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542","m/0/2147483647'/1/2147483646'/2")
assert xpub == "xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt"
assert xprv == "xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j"
def do_test_bip32(self, seed, sequence):
xprv, xpub = bip32_root(seed)
assert sequence[0:2] == "m/"
path = 'm'
sequence = sequence[2:]
for n in sequence.split('/'):
child_path = path + '/' + n
if n[-1] != "'":
xpub2 = bip32_public_derivation(xpub, path, child_path)
xprv, xpub = bip32_private_derivation(xprv, path, child_path)
if n[-1] != "'":
assert xpub == xpub2
path = child_path
return xpub, xprv
def test_aes(self):
s = u'\u66f4\u7a33\u5b9a\u7684\u4ea4\u6613\u5e73\u53f0'
self.do_test_aes(s, s)
def do_test_aes(self, s, p):
enc = pw_encode(s, p)
dec = pw_decode(enc, p)
assert dec == s
if __name__ == "__main__":
unittest.main()

0
lib/tests/__init__.py
View File

86
lib/tests/test_bitcoin.py
View File

@ -0,0 +1,86 @@
import unittest
import sys
from ecdsa.util import number_to_string
from lib.bitcoin import (
generator_secp256k1, point_to_ser, public_key_to_bc_address, EC_KEY,
bip32_root, bip32_public_derivation, bip32_private_derivation, pw_encode,
pw_decode)
try:
import ecdsa
except ImportError:
sys.exit("Error: python-ecdsa does not seem to be installed. Try 'sudo pip install ecdsa'")
class Test_bitcoin(unittest.TestCase):
def test_crypto(self):
for message in ["Chancellor on brink of second bailout for banks", chr(255)*512]:
self.do_test_crypto(message)
def do_test_crypto(self, message):
G = generator_secp256k1
_r = G.order()
pvk = ecdsa.util.randrange( pow(2,256) ) %_r
Pub = pvk*G
pubkey_c = point_to_ser(Pub,True)
#pubkey_u = point_to_ser(Pub,False)
addr_c = public_key_to_bc_address(pubkey_c)
#addr_u = public_key_to_bc_address(pubkey_u)
#print "Private key ", '%064x'%pvk
eck = EC_KEY(number_to_string(pvk,_r))
#print "Compressed public key ", pubkey_c.encode('hex')
enc = EC_KEY.encrypt_message(message, pubkey_c)
dec = eck.decrypt_message(enc)
assert dec == message
#print "Uncompressed public key", pubkey_u.encode('hex')
#enc2 = EC_KEY.encrypt_message(message, pubkey_u)
dec2 = eck.decrypt_message(enc)
assert dec2 == message
signature = eck.sign_message(message, True, addr_c)
#print signature
EC_KEY.verify_message(addr_c, signature, message)
def test_bip32(self):
# see https://en.bitcoin.it/wiki/BIP_0032_TestVectors
xpub, xprv = self.do_test_bip32("000102030405060708090a0b0c0d0e0f", "m/0'/1/2'/2/1000000000")
assert xpub == "xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy"
assert xprv == "xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76"
xpub, xprv = self.do_test_bip32("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542","m/0/2147483647'/1/2147483646'/2")
assert xpub == "xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt"
assert xprv == "xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j"
def do_test_bip32(self, seed, sequence):
xprv, xpub = bip32_root(seed)
assert sequence[0:2] == "m/"
path = 'm'
sequence = sequence[2:]
for n in sequence.split('/'):
child_path = path + '/' + n
if n[-1] != "'":
xpub2 = bip32_public_derivation(xpub, path, child_path)
xprv, xpub = bip32_private_derivation(xprv, path, child_path)
if n[-1] != "'":
assert xpub == xpub2
path = child_path
return xpub, xprv
def test_aes(self):
s = u'\u66f4\u7a33\u5b9a\u7684\u4ea4\u6613\u5e73\u53f0'
self.do_test_aes(s, s)
def do_test_aes(self, s, p):
enc = pw_encode(s, p)
dec = pw_decode(enc, p)
assert dec == s
Write Preview
Loading…
Cancel
Save