def test_segwit_create_tx(self):
from pycoin.tx.tx_utils import create_tx, sign_tx
from pycoin.tx.Spendable import Spendable
from pycoin.tx.pay_to.ScriptPayToAddress import ScriptPayToAddress
from pycoin.tx.pay_to.ScriptPayToAddressWit import ScriptPayToAddressWit
from pycoin.tx.pay_to.ScriptPayToScriptWit import ScriptPayToScriptWit
from pycoin.ui import address_for_pay_to_script_wit, script_obj_from_address
key1 = Key(1)
coin_value = 5000000
script = ScriptPayToAddressWit(b'\0', key1.hash160()).script()
tx_hash = b'\ee' * 32
tx_out_index = 0
spendable = Spendable(coin_value, script, tx_hash, tx_out_index)
key2 = Key(2)
tx = create_tx([spendable], [(key2.address(), coin_value)])
self.check_unsigned(tx)
sign_tx(tx, [key1.wif()])
self.check_signed(tx)
self.assertEqual(len(tx.txs_in[0].witness), 2)
s1 = ScriptPayToAddress(key1.hash160()).script()
address = address_for_pay_to_script_wit(s1)
spendable.script = script_obj_from_address(address).script()
tx = create_tx([spendable], [(key2.address(), coin_value)])
self.check_unsigned(tx)
sign_tx(tx, [key1.wif()], p2sh_lookup=build_p2sh_lookup([s1]))
self.check_signed(tx)
def test_segwit_create_tx(self):
from pycoin.tx.tx_utils import create_tx, sign_tx
from pycoin.tx.Spendable import Spendable
from pycoin.tx.pay_to.ScriptPayToAddress import ScriptPayToAddress
from pycoin.tx.pay_to.ScriptPayToAddressWit import ScriptPayToAddressWit
from pycoin.tx.pay_to.ScriptPayToScriptWit import ScriptPayToScriptWit
from pycoin.ui import address_for_pay_to_script_wit, script_obj_from_address
key1 = Key(1)
coin_value = 5000000
script = ScriptPayToAddressWit(b'\0', key1.hash160()).script()
tx_hash = b'\ee' * 32
tx_out_index = 0
spendable = Spendable(coin_value, script, tx_hash, tx_out_index)
key2 = Key(2)
tx = create_tx([spendable], [(key2.address(), coin_value)])
self.check_unsigned(tx)
sign_tx(tx, [key1.wif()])
self.check_signed(tx)
self.assertEqual(len(tx.txs_in[0].witness), 2)
s1 = ScriptPayToAddress(key1.hash160()).script()
address = address_for_pay_to_script_wit(s1)
spendable.script = script_obj_from_address(address).script()
tx = create_tx([spendable], [(key2.address(), coin_value)])
self.check_unsigned(tx)
sign_tx(tx, [key1.wif()], p2sh_lookup=build_p2sh_lookup([s1]))
self.check_signed(tx)
def vanitygen(s):
s = '1' + s.lower()
l = len(s)
while True:
r = int.from_bytes(os.urandom(32), 'big')
k = Key(secret_exponent=r)
if k.address()[:l] == s:
print('Address:', k.address())
print('WIF:'. k.wif())
def test_against_myself():
"""
Test code that verifies against ourselves only. Useful but not so great.
"""
from pycoin.key import Key, msg_signing
from pycoin.encoding import bitcoin_address_to_hash160_sec_with_prefix
from pycoin.encoding import wif_to_tuple_of_secret_exponent_compressed
from pycoin.key.msg_signing import parse_signed_message
for wif, right_addr in [
('L4gXBvYrXHo59HLeyem94D9yLpRkURCHmCwQtPuWW9m6o1X8p8sp',
'1LsPb3D1o1Z7CzEt1kv5QVxErfqzXxaZXv'),
('5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss',
'1HZwkjkeaoZfTSaJxDw6aKkxp45agDiEzN'),
]:
se, comp = wif_to_tuple_of_secret_exponent_compressed(wif)
k = Key(secret_exponent=se, is_compressed=comp)
assert k.address() == right_addr
#print("\nAddr %s compressed=%s" % (right_addr, comp))
vk = Key(public_pair=k.public_pair(), is_compressed=comp)
assert vk.address() == right_addr
h160, pubpre = bitcoin_address_to_hash160_sec_with_prefix(right_addr)
vk2 = Key(hash160=h160)
assert vk2.address() == right_addr
for i in range(1, 30, 10):
msg = 'test message %s' % ('A'*i)
sig = msg_signing.sign_message(k, msg, verbose=1)
#print(sig)
assert right_addr in sig
# check parsing works
m,a,s = parse_signed_message(sig)
assert m == msg, m
assert a == right_addr, a
sig2 = msg_signing.sign_message(k, msg, verbose=0)
assert sig2 in sig, (sig, sig2)
assert s == sig2, s
ok = msg_signing.verify_message(k, sig2, msg)
#print("verifies: %s" % ("Ok" if ok else "WRONG"))
assert ok
def verify_dash_signature(generator, address, message, signature):
compressed = False
G = generator
curve = G.curve()
order = G.order()
_a, _b, _p = curve.a(), curve.b(), curve.p()
sig = base64.b64decode(signature)
if len(sig) != 65:
raise Exception("vmB", "Bad signature")
hb = ord(sig[0])
r, s = map(str_to_long, [sig[1:33], sig[33:65]])
if hb < 27 or hb >= 35:
raise Exception("vmB", "Bad first byte")
if hb >= 31:
compressed = True
hb -= 4
recid = hb - 27
x = (r + (recid / 2) * order) % _p
y2 = (pow(x, 3, _p) + _a * x + _b) % _p
yomy = numbertheory.modular_sqrt(y2, _p)
if (yomy - recid) % 2 == 0:
y = yomy
else:
y = _p - yomy
R = ellipticcurve.Point(curve, x, y, order)
e = str_to_long(message)
minus_e = -e % order
inv_r = numbertheory.inverse_mod(r, order)
Q = inv_r * (R * s + G * minus_e)
key = Key(public_pair=(Q.x(), Q.y()), netcode='DASH')
return key.address(use_uncompressed=not compressed) == address
def gen_key_pair():
key, pri_hex = _gen_pri_key()
my_key = Key(secret_exponent=key,
prefer_uncompressed=False,
netcode=NET_CODE)
return pri_hex, my_key.address()
def create(cls, sec_num):
key_obj = Key(secret_exponent=sec_num)
publicKey, privateKey = key_obj._public_pair
key_obj = Key(public_pair=[publicKey, privateKey])
pubicAddress = key_obj.address()
cert = '''-----BEGIN CERTIFICATE-----
MIIDLjCCAhagAwIBAgIJAKTZkez5jH1vMA0GCSqGSIb3DQEBBQUAMG8xCzAJBgNV
BAYTAkNOMRAwDgYDVQQIDAdCZWlqaW5nMQ0wCwYDVQQKDARUUFVCMREwDwYDVQQL
DAhTZWN1cml0eTENMAsGA1UEAwwEdHB1YjEdMBsGCSqGSIb3DQEJARYOYWRtaW5A
dHB1Yi5jb20wHhcNMTcwNTA4MDgxMTEwWhcNMjcwNTA2MDgxMTEwWjBvMQswCQYD
VQQGEwJDTjEQMA4GA1UECAwHQmVpamluZzENMAsGA1UECgwEVFBVQjERMA8GA1UE
CwwIU2VjdXJpdHkxDTALBgNVBAMMBHRwdWIxHTAbBgkqhkiG9w0BCQEWDmFkbWlu
QHRwdWIuY29tMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEfStTpZiZKqNHJd2tYj/E
MOGYOxFrh/TTliVA3lXadzablXdB27YqBAQirbGnw+NJuvgxa7CBi/nMqahAMTnC
IGFBC/MLll7T4kS/f359/BiRbs4wMiuWNIzhoRugOAmgo3sweTAJBgNVHRMEAjAA
MCwGCWCGSAGG+EIBDQQfFh1PcGVuU1NMIEdlbmVyYXRlZCBDZXJ0aWZpY2F0ZTAd
BgNVHQ4EFgQUZ/QPXuhN9WaAjgAOUhOVNN1cELcwHwYDVR0jBBgwFoAUNUt6r4IA
A3nI7bjzFAXN2SRaapQwDQYJKoZIhvcNAQEFBQADggEBAMlXmy0e8a+KqUKZGW6P
+arugviHapt0QLUAxdFPPwbAQm7/wJYcbguAwPvxUQlHMsdvdSqEdDQeOYiOwft8
IGZ0dzNbynvhyH99tK42p5wgWRQyf4hMHrOnCdCgYUNOUVB0kPsSZ1R1ajSgfE/0
Xsi5Jbhpqpzm2G8NVqnPXeYfzQPZwzSgDs9INLs4Yw6aA8ei1IT8ESPSUtCSbFiT
HDB9G7UT/ZJBG6ZeGGONsf6ZOHZz38OkonBfL/tGS6NQzTFpr4H6yKyA3GlnYLOn
E+FOPdz0PSfhJOsKHY+AXFWPVrKfOimfznDYHpyQ0G6X9s31MAjF1JddRG6Xo1Vl
Ftg=
-----END CERTIFICATE-----
'''
return cls(publicKey, pubicAddress, privateKey, cert, sec_num)
def _build_signature(key, tbs, network):
''' Takes a utility.ECPrivateKey() as key, tbs as rfc2459.TBSCertificate, and network as pycoin.NETWORK_NAMES
'''
secret_exponent = encoding.to_long(256, encoding.byte_to_int,
key[0][1].asOctets())[0]
coin = Key(secret_exponent=secret_exponent, netcode=network)
public_pair = coin.public_pair()
coin_address = coin.address()
print "building signature for %s address %s" % (network, coin_address)
pubkeybitstring = (key[0].getComponentByPosition(2),
key[0].getComponentByPosition(3))
tbsder = encoder.encode(tbs)
hashvalue = SHA256.new(tbsder)
dgst = hashvalue.digest()
dgstaslong = encoding.to_long(256, encoding.byte_to_int, dgst)[0]
order2 = pycoin.ecdsa.generator_secp256k1.order()
## random sign
generator = pycoin.ecdsa.generator_secp256k1
rawsig2 = randomsign(generator, secret_exponent, dgstaslong)
# deterministic sign
##rawsig2 = pycoin.ecdsa.sign(pycoin.ecdsa.generator_secp256k1, secret_exponent, dgstaslong)
r2, s2 = rawsig2
print "signature: r: %x s: %x" % (r2, s2)
if not pycoin.ecdsa.verify(generator, coin.public_pair(), dgstaslong,
rawsig2):
raise SignatureVerifyException(
"Generated signature r: %x s: %x does not verify against public key %s"
% (r2, s2, public_pair))
signature = utility.ECDSASigValue()
signature.setComponentByName('r', r2)
signature.setComponentByName('s', s2)
dersig = encoder.encode(signature)
signaturevalue = "'{0}'H".format(binascii.hexlify(dersig))
bitstring = univ.BitString(value=signaturevalue)
return rfc2314.Signature(bitstring)
def _build_signature(key, certreqinfo, network):
secret_exponent = encoding.to_long(256, encoding.byte_to_int, key[0][1].asOctets())[0]
coin = Key(secret_exponent=secret_exponent, netcode=network)
print "building signature for %s address: %s" % (network, coin.address())
pubkeybitstring = (key[0].getComponentByPosition(2), key[0].getComponentByPosition(3))
certreqinfoder = encoder.encode(certreqinfo)
hashvalue = SHA256.new(certreqinfoder)
dgst = hashvalue.digest()
dgstaslong = encoding.to_long(256, encoding.byte_to_int, dgst)[0]
order2 = pycoin.ecdsa.generator_secp256k1.order()
## random sign
generator = pycoin.ecdsa.generator_secp256k1
rawsig2 = randomsign(generator, secret_exponent, dgstaslong)
## deterministic sign
##rawsig2 = pycoin.ecdsa.sign(pycoin.ecdsa.generator_secp256k1, secret_exponent, dgstaslong)
r2, s2 = rawsig2
print "signature: r: %x s: %x" % (r2, s2)
if not pycoin.ecdsa.verify(generator, coin.public_pair(), dgstaslong, rawsig2):
raise SignatureVerifyException("Generated signature r: %x s: %x does not verify against public key %s" % (r2, s2, public_pair))
signature = ECDSASigValue()
signature.setComponentByName('r', r2)
signature.setComponentByName('s', s2)
dersig = encoder.encode(signature)
signaturevalue = "'{0}'H".format(binascii.hexlify(dersig))
bitstring = univ.BitString( value=signaturevalue )
return rfc2314.Signature( bitstring )
def test_against_myself():
"""
Test code that verifies against ourselves only. Useful but not so great.
"""
from pycoin.contrib.msg_signing import (parse_signed_message, sign_message,
verify_message)
from pycoin.encoding import bitcoin_address_to_hash160_sec_with_prefix
from pycoin.encoding import wif_to_tuple_of_secret_exponent_compressed
for wif, right_addr in [
('L4gXBvYrXHo59HLeyem94D9yLpRkURCHmCwQtPuWW9m6o1X8p8sp',
'1LsPb3D1o1Z7CzEt1kv5QVxErfqzXxaZXv'),
('5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss',
'1HZwkjkeaoZfTSaJxDw6aKkxp45agDiEzN'),
]:
se, comp = wif_to_tuple_of_secret_exponent_compressed(wif)
k = Key(secret_exponent=se, is_compressed=comp)
assert k.address() == right_addr
vk = Key(public_pair=k.public_pair(), is_compressed=comp)
assert vk.address() == right_addr
h160, pubpre = bitcoin_address_to_hash160_sec_with_prefix(right_addr)
vk2 = Key(hash160=h160)
assert vk2.address() == right_addr
for i in range(1, 30, 10):
msg = 'test message %s' % ('A' * i)
sig = sign_message(k, msg, verbose=1)
assert right_addr in sig
# check parsing works
m, a, s = parse_signed_message(sig)
assert m == msg, m
assert a == right_addr, a
sig2 = sign_message(k, msg, verbose=0)
assert sig2 in sig, (sig, sig2)
assert s == sig2, s
ok = verify_message(k, sig2, msg)
assert ok
ok = verify_message(k, sig2.encode('ascii'), msg)
assert ok
def show_address(args):
key, wif = decrypt_key()
pub_key = Key(public_pair=key.public_pair())
addr = pub_key.address()
data = explorer.get_address(addr)
print()
print('Address: ', data.addrStr)
print('Balance: ', data.balanceSat)
def test_script_type_pay_to_address(self):
for se in range(1, 100):
key = Key(secret_exponent=se)
for b in [True, False]:
addr = key.address(use_uncompressed=b)
st = script_obj_from_address(addr)
self.assertEqual(st.address(), addr)
sc = st.script()
st = script_obj_from_script(sc)
self.assertEqual(st.address(), addr)
def test_script_type_pay_to_public_pair(self):
for se in range(1, 100):
key = Key(secret_exponent=se)
for b in [True, False]:
st = ScriptPayToPublicKey.from_key(key, use_uncompressed=b)
addr = key.address(use_uncompressed=b)
self.assertEqual(st.address(), addr)
sc = st.script()
st = script_obj_from_script(sc)
self.assertEqual(st.address(), addr)
def test_script_type_pay_to_address(self):
for se in range(1, 100):
key = Key(secret_exponent=se)
for b in [True, False]:
addr = key.address(use_uncompressed=b)
st = script_obj_from_address(addr)
self.assertEqual(st.address(), addr)
sc = st.script()
st = script_obj_from_script(sc)
self.assertEqual(st.address(), addr)
def test_script_type_pay_to_public_pair(self):
for se in range(1, 100):
key = Key(secret_exponent=se)
for b in [True, False]:
st = ScriptPayToPublicKey.from_key(key, use_uncompressed=b)
addr = key.address(use_uncompressed=b)
self.assertEqual(st.address(), addr)
sc = st.script()
st = script_obj_from_script(sc)
self.assertEqual(st.address(), addr)
def test_repr(self):
key = Key(secret_exponent=273, netcode='XTN')
address = key.address()
pub_k = Key.from_text(address)
self.assertEqual(repr(pub_k), '<mhDVBkZBWLtJkpbszdjZRkH1o5RZxMwxca>')
wif = key.wif()
priv_k = Key.from_text(wif)
self.assertEqual(repr(priv_k), 'private_for <0264e1b1969f9102977691a40431b0b672055dcf31163897d996434420e6c95dc9>')
def test_repr(self):
key = Key(secret_exponent=273, netcode='XTN')
address = key.address()
pub_k = Key.from_text(address)
self.assertEqual(repr(pub_k), '<mhDVBkZBWLtJkpbszdjZRkH1o5RZxMwxca>')
wif = key.wif()
priv_k = Key.from_text(wif)
self.assertEqual(
repr(priv_k),
'private_for <0264e1b1969f9102977691a40431b0b672055dcf31163897d996434420e6c95dc9>'
)
def test_solve_pay_to_address(self):
for se in range(1, 10):
key = Key(secret_exponent=se)
for b in [True, False]:
addr = key.address(use_uncompressed=b)
st = script_obj_from_address(addr)
self.assertEqual(st.address(), addr)
hl = build_hash160_lookup([se])
sv = 100
solution = st.solve(hash160_lookup=hl, signature_for_hash_type_f=const_f(sv), signature_type=SIGHASH_ALL)
sc = st.script()
st = script_obj_from_script(sc)
self.assertEqual(st.address(), addr)
def test_solve_pay_to_public_pair(self):
for se in range(1, 10):
key = Key(secret_exponent=se)
for b in [True, False]:
addr = key.address(use_uncompressed=b)
st = ScriptPayToPublicKey.from_key(key, use_uncompressed=b)
self.assertEqual(st.address(), addr)
hl = build_hash160_lookup([se])
sv = 100
solution = st.solve(hash160_lookup=hl, sign_value=sv, signature_type=SIGHASH_ALL)
sc = st.script()
st = script_obj_from_script(sc)
self.assertEqual(st.address(), addr)
def test_solve_pay_to_public_pair(self):
for se in range(1, 10):
key = Key(secret_exponent=se)
for b in [True, False]:
addr = key.address(use_uncompressed=b)
st = ScriptPayToPublicKey.from_key(key, use_uncompressed=b)
self.assertEqual(st.address(), addr)
hl = build_hash160_lookup([se])
sv = 100
solution = st.solve(hash160_lookup=hl, sign_value=sv, signature_type=SIGHASH_ALL)
sc = st.script()
st = script_obj_from_script(sc)
self.assertEqual(st.address(), addr)
def test_solve_pay_to_address(self):
for se in range(1, 10):
key = Key(secret_exponent=se)
for b in [True, False]:
addr = key.address(use_uncompressed=b)
st = script_obj_from_address(addr)
self.assertEqual(st.address(), addr)
hl = build_hash160_lookup([se])
sv = 100
solution = st.solve(hash160_lookup=hl, signature_for_hash_type_f=const_f(sv), signature_type=SIGHASH_ALL)
sc = st.script()
st = script_obj_from_script(sc)
self.assertEqual(st.address(), addr)
def sign_document(args):
key, wif = decrypt_key()
pub_key = Key(public_pair=key.public_pair())
addr = pub_key.address()
out = get_spendable(addr)
if out is None:
raise Exception('Insufficient funds')
signature, file_hash = file_signature(args.filename)
print('Signing document: ', args.filename)
print('File hash: ', file_hash.hex())
print('File signature: ', signature.hex())
tx = build_tx(signature, addr, wif)
print(tx.as_hex())
def _gen (self):
logger.debug ('Generating entropy for new wallet...')
# Generate entropy
entropy = bytearray()
try:
entropy.extend(open("/dev/random", "rb").read(64))
except Exception:
print("warning: can't use /dev/random as entropy source")
entropy = bytes(entropy)
if len(entropy) < 64:
raise OSError("can't find sources of entropy")
secret_exponent = int(binascii.hexlify (entropy)[0:32], 16)
wif = secret_exponent_to_wif(secret_exponent, compressed=True, wif_prefix=wif_prefix_for_netcode (self.chain))
key = Key (secret_exponent=secret_exponent, netcode=self.chain)
return (str (key.address ()), str (key.wif ()))
def generatePrivateKey(seed, net="XTN"):
"""
Generating a private key from any hexadecimal seed and net
Args:
-----
seed: The seed to be used to generate the private key.
net: The network to be used.
Returns:
--------
The private key to be used.
"""
# Generating the hexadecimal representation of the brainwallet
key_bytes = hexlify(seed)
# '68656c6c6f' for "hello"
priv = Key(secret_exponent=int(codecs.encode(key_bytes, "hex"), 16),
netcode=net)
# Representation of the wallet
print("\tSeed: " + seed)
print("\tAddress: " + priv.address())
print("\tWIF: " + priv.wif())
return priv
parser = argparse.ArgumentParser()
parser.add_argument('--privkey-bytes',
help='provide hexlified raw privkey bytes',
default='',
type=str)
parser.add_argument('--send-all-to',
help='where to send all the money at this address',
default='1MaxKayeQg4YhFkzFz4x6NDeeNv1bwKKVA',
type=str)
args = parser.parse_args()
key_bytes = unhexlify(args.privkey_bytes.encode()
) if args.privkey_bytes != '' else os.urandom(32)
private_key = Key(secret_exponent=int.from_bytes(key_bytes, 'big'))
address = private_key.address()
print('Your Bitcoin address is...', address)
print('Your --privkey-bytes', hexlify(key_bytes).decode())
try:
spendables = spendables_for_address(address, None)
print('Spending', spendables)
except HTTPError as e:
print(
'Blockchain throws a 500 error if there are no spendables. Try sending some coins to',
address, 'and try again. Remeber to copy privkey-bytes.')
sys.exit()
tx = create_tx(spendables, [args.send_all_to])
print('TX created:', repr(tx))
def address_from_pri_hex(pri_hex):
my_key = Key(secret_exponent=int(pri_hex, 16),
prefer_uncompressed=False,
netcode=NET_CODE)
return my_key.address()
def _test_sighash_single(self, netcode):
k0 = Key(secret_exponent=PRIV_KEYS[0],
is_compressed=True,
netcode=netcode)
k1 = Key(secret_exponent=PRIV_KEYS[1],
is_compressed=True,
netcode=netcode)
k2 = Key(secret_exponent=PRIV_KEYS[2],
is_compressed=True,
netcode=netcode)
k3 = Key(secret_exponent=PRIV_KEYS[3],
is_compressed=True,
netcode=netcode)
k4 = Key(secret_exponent=PRIV_KEYS[4],
is_compressed=True,
netcode=netcode)
k5 = Key(secret_exponent=PRIV_KEYS[5],
is_compressed=True,
netcode=netcode)
# Fake a coinbase transaction
coinbase_tx = Tx.coinbase_tx(k0.sec(), 500000000)
coinbase_tx.txs_out.append(
TxOut(1000000000,
pycoin_compile('%s OP_CHECKSIG' % b2h(k1.sec()))))
coinbase_tx.txs_out.append(
TxOut(1000000000,
pycoin_compile('%s OP_CHECKSIG' % b2h(k2.sec()))))
self.assertEqual(
'2acbe1006f7168bad538b477f7844e53de3a31ffddfcfc4c6625276dd714155a',
b2h_rev(coinbase_tx.hash()))
# Make the test transaction
txs_in = [
TxIn(coinbase_tx.hash(), 0),
TxIn(coinbase_tx.hash(), 1),
TxIn(coinbase_tx.hash(), 2),
]
txs_out = [
TxOut(900000000, standard_tx_out_script(k3.address())),
TxOut(800000000, standard_tx_out_script(k4.address())),
TxOut(800000000, standard_tx_out_script(k5.address())),
]
tx = Tx(1, txs_in, txs_out)
tx.set_unspents(coinbase_tx.txs_out)
self.assertEqual(
'791b98ef0a3ac87584fe273bc65abd89821569fd7c83538ac0625a8ca85ba587',
b2h_rev(tx.hash()))
sig_type = SIGHASH_SINGLE
sig_hash = tx.signature_hash(coinbase_tx.txs_out[0].script, 0,
sig_type)
self.assertEqual(
'cc52d785a3b4133504d1af9e60cd71ca422609cb41df3a08bbb466b2a98a885e',
b2h(to_bytes_32(sig_hash)))
sig = sigmake(k0, sig_hash, sig_type)
self.assertTrue(sigcheck(k0, sig_hash, sig[:-1]))
tx.txs_in[0].script = pycoin_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(0))
sig_hash = tx.signature_hash(coinbase_tx.txs_out[1].script, 1,
sig_type)
self.assertEqual(
'93bb883d70fccfba9b8aa2028567aca8357937c65af7f6f5ccc6993fd7735fb7',
b2h(to_bytes_32(sig_hash)))
sig = sigmake(k1, sig_hash, sig_type)
self.assertTrue(sigcheck(k1, sig_hash, sig[:-1]))
tx.txs_in[1].script = pycoin_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(1))
sig_hash = tx.signature_hash(coinbase_tx.txs_out[2].script, 2,
sig_type)
self.assertEqual(
'53ef7f67c3541bffcf4e0d06c003c6014e2aa1fb38ff33240b3e1c1f3f8e2a35',
b2h(to_bytes_32(sig_hash)))
sig = sigmake(k2, sig_hash, sig_type)
self.assertTrue(sigcheck(k2, sig_hash, sig[:-1]))
tx.txs_in[2].script = pycoin_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(2))
sig_type = SIGHASH_SINGLE | SIGHASH_ANYONECANPAY
sig_hash = tx.signature_hash(coinbase_tx.txs_out[0].script, 0,
sig_type)
self.assertEqual(
'2003393d246a7f136692ce7ab819c6eadc54ffea38eb4377ac75d7d461144e75',
b2h(to_bytes_32(sig_hash)))
sig = sigmake(k0, sig_hash, sig_type)
self.assertTrue(sigcheck(k0, sig_hash, sig[:-1]))
tx.txs_in[0].script = pycoin_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(0))
sig_hash = tx.signature_hash(coinbase_tx.txs_out[1].script, 1,
sig_type)
self.assertEqual(
'e3f469ac88e9f35e8eff0bd8ad4ad3bf899c80eb7645947d60860de4a08a35df',
b2h(to_bytes_32(sig_hash)))
sig = sigmake(k1, sig_hash, sig_type)
self.assertTrue(sigcheck(k1, sig_hash, sig[:-1]))
tx.txs_in[1].script = pycoin_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(1))
sig_hash = tx.signature_hash(coinbase_tx.txs_out[2].script, 2,
sig_type)
self.assertEqual(
'bacd7c3ab79cad71807312677c1788ad9565bf3c00ab9a153d206494fb8b7e6a',
b2h(to_bytes_32(sig_hash)))
sig = sigmake(k2, sig_hash, sig_type)
self.assertTrue(sigcheck(k2, sig_hash, sig[:-1]))
tx.txs_in[2].script = pycoin_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(2))
def secret_to_address(secret_exponent):
k = Key(secret_exponent=secret_exponent)
addr = k.address(use_uncompressed=True)
caddr = k.address()
wif = k.wif(use_uncompressed=True)
return secret_exponent, wif, addr, caddr
from pycoin.key import Key from pycoin.serialize import h2b from pycoin.tx import Tx, TxIn, TxOut, SIGHASH_ALL, tx_utils from pycoin.tx.TxOut import standard_tx_out_script from pycoin.tx.pay_to import ScriptMultisig, ScriptPayToPublicKey from pycoin.tx.pay_to import address_for_pay_to_script, build_hash160_lookup, build_p2sh_lookup from pycoin.tx.pay_to import script_obj_from_address, script_obj_from_script publicaddress = "mkR94WCqr4gpZauH8ieTLTG6jkZ2uBB6SA" wif = "cUDx8gXXBZRePmm46LSZetbWqNwXBmm3WQziGVykAgL8NJKMRjQR" key = Key.from_text(publicaddress) key = Key(secret_exponent=1) print key.address() print key.wif() print key.secret_exponent()
def _test_sighash_single(self, netcode):
k0 = Key(secret_exponent=PRIV_KEYS[0], is_compressed=True, netcode=netcode)
k1 = Key(secret_exponent=PRIV_KEYS[1], is_compressed=True, netcode=netcode)
k2 = Key(secret_exponent=PRIV_KEYS[2], is_compressed=True, netcode=netcode)
k3 = Key(secret_exponent=PRIV_KEYS[3], is_compressed=True, netcode=netcode)
k4 = Key(secret_exponent=PRIV_KEYS[4], is_compressed=True, netcode=netcode)
k5 = Key(secret_exponent=PRIV_KEYS[5], is_compressed=True, netcode=netcode)
# Fake a coinbase transaction
coinbase_tx = Tx.coinbase_tx(k0.sec(), 500000000)
coinbase_tx.txs_out.append(TxOut(1000000000, pycoin_compile('%s OP_CHECKSIG' % b2h(k1.sec()))))
coinbase_tx.txs_out.append(TxOut(1000000000, pycoin_compile('%s OP_CHECKSIG' % b2h(k2.sec()))))
self.assertEqual('2acbe1006f7168bad538b477f7844e53de3a31ffddfcfc4c6625276dd714155a',
b2h_rev(coinbase_tx.hash()))
# Make the test transaction
txs_in = [
TxIn(coinbase_tx.hash(), 0),
TxIn(coinbase_tx.hash(), 1),
TxIn(coinbase_tx.hash(), 2),
]
txs_out = [
TxOut(900000000, standard_tx_out_script(k3.address())),
TxOut(800000000, standard_tx_out_script(k4.address())),
TxOut(800000000, standard_tx_out_script(k5.address())),
]
tx = Tx(1, txs_in, txs_out)
tx.set_unspents(coinbase_tx.txs_out)
self.assertEqual('791b98ef0a3ac87584fe273bc65abd89821569fd7c83538ac0625a8ca85ba587', b2h_rev(tx.hash()))
sig_type = SIGHASH_SINGLE
sig_hash = tx.signature_hash(coinbase_tx.txs_out[0].script, 0, sig_type)
self.assertEqual('cc52d785a3b4133504d1af9e60cd71ca422609cb41df3a08bbb466b2a98a885e', b2h(to_bytes_32(sig_hash)))
sig = sigmake(k0, sig_hash, sig_type)
self.assertTrue(sigcheck(k0, sig_hash, sig[:-1]))
tx.txs_in[0].script = pycoin_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(0))
sig_hash = tx.signature_hash(coinbase_tx.txs_out[1].script, 1, sig_type)
self.assertEqual('93bb883d70fccfba9b8aa2028567aca8357937c65af7f6f5ccc6993fd7735fb7', b2h(to_bytes_32(sig_hash)))
sig = sigmake(k1, sig_hash, sig_type)
self.assertTrue(sigcheck(k1, sig_hash, sig[:-1]))
tx.txs_in[1].script = pycoin_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(1))
sig_hash = tx.signature_hash(coinbase_tx.txs_out[2].script, 2, sig_type)
self.assertEqual('53ef7f67c3541bffcf4e0d06c003c6014e2aa1fb38ff33240b3e1c1f3f8e2a35', b2h(to_bytes_32(sig_hash)))
sig = sigmake(k2, sig_hash, sig_type)
self.assertTrue(sigcheck(k2, sig_hash, sig[:-1]))
tx.txs_in[2].script = pycoin_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(2))
sig_type = SIGHASH_SINGLE | SIGHASH_ANYONECANPAY
sig_hash = tx.signature_hash(coinbase_tx.txs_out[0].script, 0, sig_type)
self.assertEqual('2003393d246a7f136692ce7ab819c6eadc54ffea38eb4377ac75d7d461144e75', b2h(to_bytes_32(sig_hash)))
sig = sigmake(k0, sig_hash, sig_type)
self.assertTrue(sigcheck(k0, sig_hash, sig[:-1]))
tx.txs_in[0].script = pycoin_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(0))
sig_hash = tx.signature_hash(coinbase_tx.txs_out[1].script, 1, sig_type)
self.assertEqual('e3f469ac88e9f35e8eff0bd8ad4ad3bf899c80eb7645947d60860de4a08a35df', b2h(to_bytes_32(sig_hash)))
sig = sigmake(k1, sig_hash, sig_type)
self.assertTrue(sigcheck(k1, sig_hash, sig[:-1]))
tx.txs_in[1].script = pycoin_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(1))
sig_hash = tx.signature_hash(coinbase_tx.txs_out[2].script, 2, sig_type)
self.assertEqual('bacd7c3ab79cad71807312677c1788ad9565bf3c00ab9a153d206494fb8b7e6a', b2h(to_bytes_32(sig_hash)))
sig = sigmake(k2, sig_hash, sig_type)
self.assertTrue(sigcheck(k2, sig_hash, sig[:-1]))
tx.txs_in[2].script = pycoin_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(2))
def secret_to_address(secret_exponent):
k = Key(secret_exponent=secret_exponent)
addr = k.address(use_uncompressed=True)
caddr = k.address()
wif = k.wif(use_uncompressed=True)
return secret_exponent, wif, addr, caddr
def register_page(request, refererUUID):
getBtcPrice()
price = sysvar.objects.get(pk=1)
btcPrice = price.btcPrice
counter = price.counter
email_taken = False
username_taken = False
if request.user.is_authenticated():
return render(request, 'home.html')
registration_form = RegistrationForm()
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
datas = {}
if User.objects.filter(
username=form.cleaned_data['username']).exists():
username_taken = True
return render(
request, 'register_page.html', {
'form': registration_form,
'username_taken': username_taken,
'btcPrice': btcPrice
})
elif User.objects.filter(
email=form.cleaned_data['email']).exists():
email_taken = True
return render(
request, 'register_page.html', {
'form': registration_form,
'email_taken': email_taken,
'btcPrice': btcPrice
})
datas['username'] = form.cleaned_data['username']
datas['email'] = form.cleaned_data['email']
datas['password1'] = form.cleaned_data['password1']
datas['referer'] = refererUUID
#We will generate a random activation key
s = 'xprv9s21ZrQH143K2Lap6SnULZfdEi4ivcbottMVoY7MaupCQhVLfARkygyW9N7PKsBSPd2gTQXZr1R4iqkLCQ3TUxvs9NvwYRScCVGV8Aos7ad'
mykey = Key.from_text(s)
mysub = mykey.subkey(counter)
address = Key.address(mysub)
wif = Key.wif(mysub)
datas['deposit_add'] = address
datas['wif'] = wif
price.counter = price.counter + 1
price.save()
salt = hashlib.sha1(str(
random.random()).encode('utf-8')).hexdigest()[:5]
usernamesalt = datas['email']
if isinstance(usernamesalt, str):
usernamesalt = str.encode(usernamesalt)
if isinstance(salt, str):
salt = str.encode(salt)
print(salt)
print(usernamesalt)
datas['activation_key'] = hashlib.sha1(salt +
usernamesalt).hexdigest()
datas[
'email_path'] = "/home/connell-gough/django/bl4btc/btc/static/ActivationEmail.txt"
datas['email_subject'] = "activate your account"
form.sendEmail(datas) #Send validation email
form.save(datas) #Save the user and his profile
request.session['registered'] = True #For display purposes
return render(request, 'register_page.html', {
'email_sent': True,
'btcPrice': btcPrice
})
else:
registration_form = form #Display form with error messages (incorrect fields, etc)
return render(
request, 'register_page.html', {
'form': registration_form,
'btcPrice': btcPrice,
'refererUUID': refererUUID
})
def main():
parser = argparse.ArgumentParser(
description='utxocsr.py by MiWCryptoCurrency for UTXOC UTXO based certificate signing request generation (CSR).'
)
parser.add_argument('-k', '--key', required=True, type=argparse.FileType('r'), help='Private EC Key')
parser.add_argument('-f', '--filename', required=True, help='Output CSR Filename')
parser.add_argument('-n', "--network", help='specify network (default: BTC = Bitcoin)',
default='BTC', choices=NETWORK_NAMES)
parser.add_argument('-t', "--transactionid", required=False, help='transaction id (hex)')
inputkey=""
args = parser.parse_args()
out = args.filename
network = args.network
while True:
line = args.key.readline().strip()
if not line: break
inputkey += line + '\n'
parsed_key = decoder.decode(utility.read_ec_private_pem(inputkey), asn1Spec=utility.ECPrivateKey())
secret_exponent = encoding.to_long(256, encoding.byte_to_int, parsed_key[0][1].asOctets())[0]
coin = Key(secret_exponent=secret_exponent, netcode=network)
pubaddr = coin.address(use_uncompressed=False)
if (network=="BTC"):
uriname = "bitcoin"
elif (network=="NMC"):
uriname = "namecoin"
elif (network=="LTC"):
uriname = "litecoin"
elif (network=="DOGE"):
uriname = "dogecoin"
elif (network=="BLK"):
uriname = "blackcoin"
if not args.transactionid:
print "Please enter transaction hash to reference in certificate. Leave blank to only encode the address."
transactionid = raw_input()
if transactionid == "":
uri = uriname + ":" + pubaddr
else:
uri = uriname + ":" + pubaddr + "?" + "transaction=" + transactionid
else:
transactionid = args.transactionid
uri = uriname + ":" + pubaddr + "?" + "transaction=" + transactionid
dn = ""
dn_c = raw_input("Please enter Country (eg: US): ")
if (dn_c == ""):
dn_c = "US"
dn_st = raw_input("Please enter State (eg: California): ")
if (dn_st == ""):
dn_st = "California"
dn_l = raw_input("Please enter City (eg: Sunnyvale): ")
if (dn_l == ""):
dn_l = "Sunnyvale"
dn_o = raw_input("Please enter Organization (eg: Widgets Inc.): ")
if (dn_o == ""):
dn_o = "Widgets Inc."
dn_ou = raw_input("Please enter Organization Unit: (eg: Information Security): ")
if (dn_ou == ""):
dn_ou = "Information Security"
dn_cn = raw_input("Please enter Common Name: (eg: My first UTXOC): ")
if (dn_cn == ""):
dn_cn = "My first UTXOC"
san = raw_input("Please enter Subject Alt Name values (DNS name, blank for none, seperate multiple entries with space): ")
sanentry = []
if (san == ""):
sanentry = 'URI:%s' % uri
else:
for entry in san.split(" "):
sanentry.append('DNS:%s' % entry)
sanentry.append('URI:%s' % uri)
dn = "/C=" + dn_c + "/ST=" + dn_st + "/L=" + dn_l + "/O=" + dn_o + "/OU=" + dn_ou + "/CN=" + dn_cn
attributes={
'extensionRequest': (
('x509basicConstraints', True,
(False,)),
('subjectAlternativeName', False,
sanentry
),
)
}
create_csr_ec(parsed_key, dn, csrfilename=out, attributes=attributes, network=network)
def main():
parser = argparse.ArgumentParser(
description=
'utxocsr.py by MiWCryptoCurrency for UTXOC UTXO based certificate signing request generation (CSR).'
)
parser.add_argument('-k',
'--key',
required=True,
type=argparse.FileType('r'),
help='Private EC Key')
parser.add_argument('-f',
'--filename',
required=True,
help='Output CSR Filename')
parser.add_argument('-n',
"--network",
help='specify network (default: BTC = Bitcoin)',
default='BTC',
choices=NETWORK_NAMES)
parser.add_argument('-t',
"--transactionid",
required=False,
help='transaction id (hex)')
inputkey = ""
args = parser.parse_args()
out = args.filename
network = args.network
while True:
line = args.key.readline().strip()
if not line: break
inputkey += line + '\n'
parsed_key = decoder.decode(utility.read_ec_private_pem(inputkey),
asn1Spec=utility.ECPrivateKey())
secret_exponent = encoding.to_long(256, encoding.byte_to_int,
parsed_key[0][1].asOctets())[0]
coin = Key(secret_exponent=secret_exponent, netcode=network)
pubaddr = coin.address(use_uncompressed=False)
if (network == "BTC"):
uriname = "bitcoin"
elif (network == "NMC"):
uriname = "namecoin"
elif (network == "LTC"):
uriname = "litecoin"
elif (network == "DOGE"):
uriname = "dogecoin"
elif (network == "BLK"):
uriname = "blackcoin"
if not args.transactionid:
print "Please enter transaction hash to reference in certificate. Leave blank to only encode the address."
transactionid = raw_input()
if transactionid == "":
uri = uriname + ":" + pubaddr
else:
uri = uriname + ":" + pubaddr + "?" + "transaction=" + transactionid
else:
transactionid = args.transactionid
uri = uriname + ":" + pubaddr + "?" + "transaction=" + transactionid
dn = ""
dn_c = raw_input("Please enter Country (eg: US): ")
if (dn_c == ""):
dn_c = "US"
dn_st = raw_input("Please enter State (eg: California): ")
if (dn_st == ""):
dn_st = "California"
dn_l = raw_input("Please enter City (eg: Sunnyvale): ")
if (dn_l == ""):
dn_l = "Sunnyvale"
dn_o = raw_input("Please enter Organization (eg: Widgets Inc.): ")
if (dn_o == ""):
dn_o = "Widgets Inc."
dn_ou = raw_input(
"Please enter Organization Unit: (eg: Information Security): ")
if (dn_ou == ""):
dn_ou = "Information Security"
dn_cn = raw_input("Please enter Common Name: (eg: My first UTXOC): ")
if (dn_cn == ""):
dn_cn = "My first UTXOC"
san = raw_input(
"Please enter Subject Alt Name values (DNS name, blank for none, seperate multiple entries with space): "
)
sanentry = []
if (san == ""):
sanentry = 'URI:%s' % uri
else:
for entry in san.split(" "):
sanentry.append('DNS:%s' % entry)
sanentry.append('URI:%s' % uri)
dn = "/C=" + dn_c + "/ST=" + dn_st + "/L=" + dn_l + "/O=" + dn_o + "/OU=" + dn_ou + "/CN=" + dn_cn
attributes = {
'extensionRequest': (
('x509basicConstraints', True, (False, )),
('subjectAlternativeName', False, sanentry),
)
}
create_csr_ec(parsed_key,
dn,
csrfilename=out,
attributes=attributes,
network=network)
print(" uncompressed: ", my_key.sec_as_hex(use_uncompressed=True))
assert(my_key.sec_as_hex() == bitcoin.core.b2x(my_key.sec()))
print("Public key hash160: ", b2h(my_key.hash160()))
print(" uncompressed: ", b2h(my_key.hash160(use_uncompressed=True)))
#print("Bitcoin Address : ", my_key.address())
addr_compressed = encoding.public_pair_to_bitcoin_address(public_key, True, my_addr_prefix)
addr_uncompressed = encoding.public_pair_to_bitcoin_address(public_key, False, my_addr_prefix)
print("Bitcoin Address: ", addr_compressed)
print(" uncompressed: ", addr_uncompressed)
assert(encoding.is_valid_bitcoin_address(addr_compressed, my_addr_prefix))
assert(encoding.is_valid_bitcoin_address(addr_uncompressed, my_addr_prefix))
assert(my_key.address() == addr_compressed)
pubkey_bytes = encoding.public_pair_to_sec(public_key, True);
assert(my_key.sec_as_hex() == b2h(pubkey_bytes))
pubkey_bytes = encoding.public_pair_to_sec(public_key, False);
assert(my_key.sec_as_hex(use_uncompressed=True) == b2h(pubkey_bytes))
print()
#CBitcoinAddress.from_bytes(bitcoin.core.serialize.Hash160(my_key.address()), 111)
btc_addr = CBitcoinAddress.from_bytes(bitcoin.base58.decode(my_key.address()), bitcoin.params.BASE58_PREFIXES['PUBKEY_ADDR'])
print("Bitcoin Address hex: ", hexlify(btc_addr.to_bytes()))
assert(bitcoin.base58.encode(btc_addr.to_bytes()) == addr_compressed)
pubkey_b58 = encoding.b2a_base58(pubkey_bytes)
#CBitcoinAddress.from_scriptPubKey(pubkey_b58)
def main():
parser = argparse.ArgumentParser(
description='ECkey2coin.py by [email protected] for UTXO based Certificates UTXOC.',
epilog='Known networks codes:\n ' \
+ ', '.join(['%s (%s)'%(i, full_network_name_for_netcode(i)) for i in NETWORK_NAMES])
)
parser.add_argument('-k', '--key', required=False, type=argparse.FileType('r'), help='The EC private key in PEM format')
parser.add_argument('-q', '--qrfilename', required=False, help='QR code output filename')
parser.add_argument('-n', "--network", help='specify network (default: BTC = Bitcoin)',
default='BTC', choices=NETWORK_NAMES)
args = parser.parse_args()
network = args.network
inputprivatekey = ''
if args.key:
keyfile = args.key
while True:
line = keyfile.readline().strip()
if not line: break
inputprivatekey += line + '\n'
print 'Loaded EC Key from %s' % keyfile
else:
print ('Please enter EC KEY in pem format:')
inputprivatekey = ''
while True:
line = raw_input().strip()
if not line: break
inputprivatekey += line + '\n'
if not args.qrfilename:
qrfilename = raw_input("Please enter qrcode output filename: ")
else:
qrfilename = args.qrfilename
pkey = decoder.decode(read_pem(inputprivatekey), asn1Spec=ECPrivateKey())
print 'Key loaded'
if not isValidECKey(pkey[0]):
print "EC Key Supplied cannot be used"
exit
print "Key Validated OK"
inputkey = encoding.to_long(256, pycoin.encoding.byte_to_int, pkey[0][1].asOctets())[0]
if inputkey:
key = Key(secret_exponent=inputkey, netcode=network)
btcsecret = key.secret_exponent()
btcpublic = key.public_pair()
hash160_c = key.hash160(use_uncompressed=False)
hash160_u = key.hash160(use_uncompressed=True)
qrimg = qrcode.QRCode (
version=1,
error_correction=qrcode.constants.ERROR_CORRECT_L,
box_size=10,
border=4,
)
qrimg.add_data(key.address(use_uncompressed=False))
qrimg.make(fit=True)
img = qrimg.make_image()
img.save(qrfilename)
print"----------------- BEGIN EC PRIVATE KEYS -----------------"
print "Secret: %d" % btcsecret
print "Secret hex: %x" % btcsecret
print "wif: %s" % key.wif(use_uncompressed=False)
print "----------------- END EC PRIVATE KEYS -----------------------------"
print "----------------- BEGIN PUBLIC KEY -----------------------------"
print "Public X: %d" % btcpublic[0]
print "Public Y: %d" % btcpublic[1]
print "hash160 uncompressed: %s" % b2h(hash160_u)
print "Sec: (uncompressed): %s" % b2h(key.sec(use_uncompressed=True))
print "%s address: %s (uncompressed)" % (key._netcode, key.address(use_uncompressed=True))
print "Public X (hex): %x" % btcpublic[0]
print "Public Y (hex): %x" % btcpublic[1]
print "Sec: %s" % b2h(key.sec(use_uncompressed=False))
print "hash160 compressed: %s" % b2h(hash160_c)
print "----------------- END PUBLIC KEYS -----------------------------"
print "------------------ BEGIN %s ADDRESSES -------------------------" % key._netcode
print "%s address: %s" % (key._netcode, key.address(use_uncompressed=False))
print "------------------ END %s ADDRESSES -------------------------" % key._netcode
