def test_sig_bitcoin1(bare_session):
msg = "this is a test message"
name1, name2 = "member_a", "member_b"
priv1, addr1 = makeTestKey(name1)
priv2, addr2 = makeTestKey(name2)
msg = b"this is a test message"
sig1 = bitcoin.ecdsa_sign(msg, priv1)
sig2 = bitcoin.ecdsa_sign(msg, priv2)
with pytest.raises(ValidationError):
# member not existing
checkSig(msg, sig1, name1)
m1 = Member(name1, addr1)
m2 = Member(name2, addr2)
bare_session.add(m1)
bare_session.add(m2)
# should succeed
checkSig(msg, sig1, name1)
with pytest.raises(ValidationError):
# wrong sig
checkSig(msg, sig2, name1)
# should succeed
checkSig(msg, sig2, name2)
def create_intkey_transaction(verb, name, value, private_key, public_key):
payload = IntKeyPayload(verb=verb, name=name, value=value)
# The prefix should eventually be looked up from the
# validator's namespace registry.
intkey_prefix = hashlib.sha512('intkey'.encode('utf-8')).hexdigest()[0:6]
addr = intkey_prefix + hashlib.sha512(name.encode('utf-8')).hexdigest()
header = transaction_pb2.TransactionHeader(
signer_pubkey=public_key,
family_name='intkey',
family_version='1.0',
inputs=[addr],
outputs=[addr],
dependencies=[],
payload_encoding="application/cbor",
payload_sha512=payload.sha512(),
batcher_pubkey=public_key,
nonce=time.time().hex().encode())
header_bytes = header.SerializeToString()
signature = bitcoin.ecdsa_sign(header_bytes, private_key)
transaction = transaction_pb2.Transaction(header=header_bytes,
payload=payload.to_cbor(),
header_signature=signature)
return transaction
def makeTestAction(author, apart, pgp=False):
""" Create signed test action where privkey of author equals sha256(author). """
action_string = config.action_prefix + apart
privkey = bitcoin.sha256(author.name)
if pgp: # use PGP signature
assert author.name in ["member_a", "member_b"]
gpg = gpglayer.gpgInstance()
ki1 = gpg.import_keys(testkeys.privkey1)
ki2 = gpg.import_keys(testkeys.privkey2)
signature = gpg.sign(action_string,
keyid=(ki1.fingerprints[0] if author.name
== "member_a" else ki2.fingerprints[0]),
detach=True,
passphrase="123").data.decode("ascii")
assert len(signature)
else:
signature = bitcoin.ecdsa_sign(action_string, privkey)
return Action(author=author,
action_string=action_string,
signature=signature)
def _do_config_set(args):
"""Executes the 'set' subcommand. Given a key file, and a series of
key/value pairs, it generates batches of sawtooth_config transactions in a
BatchList instance, and stores it in a file.
"""
settings = [s.split('=', 1) for s in args.setting]
with open(args.key, 'r') as key_file:
wif_key = key_file.read().strip()
signing_key = bitcoin.encode_privkey(
bitcoin.decode_privkey(wif_key, 'wif'), 'hex')
pubkey = bitcoin.encode_pubkey(bitcoin.privkey_to_pubkey(signing_key),
'hex')
txns = [
_create_config_txn(pubkey, signing_key, setting)
for setting in settings
]
txn_ids = [txn.header_signature for txn in txns]
batch_header = BatchHeader(signer_pubkey=pubkey,
transaction_ids=txn_ids).SerializeToString()
batch = Batch(header=batch_header,
header_signature=bitcoin.ecdsa_sign(batch_header,
signing_key),
transactions=txns)
batch_list = BatchList(batches=[batch]).SerializeToString()
try:
with open(args.output, 'wb') as batch_file:
batch_file.write(batch_list)
except:
raise CliException('Unable to write to {}'.format(args.output))
def _create_config_txn(pubkey, signing_key, setting_key_value):
"""Creates an individual sawtooth_config transaction for the given key and
value.
"""
setting_key = setting_key_value[0]
setting_value = setting_key_value[1]
nonce = str(datetime.datetime.utcnow().timestamp())
proposal = ConfigProposal(setting=setting_key,
value=setting_value,
nonce=nonce)
payload = ConfigPayload(data=proposal.SerializeToString(),
action=ConfigPayload.PROPOSE).SerializeToString()
header = TransactionHeader(
signer_pubkey=pubkey,
family_name='sawtooth_config',
family_version='1.0',
inputs=_config_inputs(setting_key),
outputs=_config_outputs(setting_key),
dependencies=[],
payload_encoding='application/protobuf',
payload_sha512=hashlib.sha512(payload).hexdigest(),
batcher_pubkey=pubkey).SerializeToString()
signature = bitcoin.ecdsa_sign(header, signing_key)
return Transaction(header=header,
header_signature=signature,
payload=payload)
def make_transaction(inputs, outputs):
timestamp = datetime.datetime.now().isoformat()
out_total, out_msg = _process_outputs(outputs, timestamp)
tx = {'inputs': [], 'outputs': [], 'timestamp': timestamp}
in_total = 0
for in_ in inputs:
try:
address, amount, privkey = in_
except ValueError:
raise Exception(
"Transaction inputs must be a 3 item list: [address, amount, privkey]"
)
if amount <= 0:
raise InvalidAmounts("Input can't be zero or negative")
amount = _cut_to_8(amount)
msg = "%s%s%s" % (address, amount, out_msg)
sig = ecdsa_sign(msg, privkey)
in_total += amount
tx['inputs'].append([address, amount, sig])
if in_total < out_total:
raise InvalidAmounts("Not enough inputs for outputs: %s in, %s out" %
(in_total, out_total))
random.shuffle(outputs)
tx['outputs'] = outputs
return tx
def create_intkey_transaction(verb, name, value, private_key, public_key):
payload = IntKeyPayload(
verb=verb, name=name, value=value)
# The prefix should eventually be looked up from the
# validator's namespace registry.
intkey_prefix = hashlib.sha512('intkey'.encode('utf-8')).hexdigest()[0:6]
addr = intkey_prefix + hashlib.sha512(name.encode('utf-8')).hexdigest()
header = transaction_pb2.TransactionHeader(
signer_pubkey=public_key,
family_name='intkey',
family_version='1.0',
inputs=[addr],
outputs=[addr],
dependencies=[],
payload_encoding="application/cbor",
payload_sha512=payload.sha512(),
batcher_pubkey=public_key,
nonce=time.time().hex().encode())
header_bytes = header.SerializeToString()
signature = bitcoin.ecdsa_sign(
header_bytes,
private_key)
transaction = transaction_pb2.Transaction(
header=header_bytes,
payload=payload.to_cbor(),
header_signature=signature)
return transaction
def templateReplaceOne(s, Jorig):
# FIXME: This is kind of ugly code..
match = re.match(r"\<bitcoin-address\:([a-z]+)\>", s)
if match:
res = bitcoin.privtoaddr(bitcoin.sha256(match.group(1)))
#logging.info("Replace %s with %s" % (match.group(0), res))
return res
match = re.match(r"\<hash-of\:([^>]+)\>", s)
if match:
fn = match.group(1)
res = bitcoin.sha256(open(fn).read())
#logging.info("Replace %s with %s" % (match.group(0), res))
return res
match = re.match(r"\<signature:([a-z]+)\>", s)
if match:
msg = "VOTE-FORMAT-VERSION-1 %s %s %s %s %s" % (
templateReplaceOne(Jorig["handle"], Jorig),
templateReplaceOne(Jorig["addr"], Jorig),
templateReplaceOne(Jorig["ballot_option"], Jorig),
templateReplaceOne(Jorig["proposal"], Jorig),
templateReplaceOne(Jorig["proposal_meta"], Jorig))
privkey = bitcoin.sha256(match.group(1))
res = bitcoin.ecdsa_sign(msg, privkey)
#logging.info("Replace %s with %s" % (match.group(0), res))
return res
else:
return s
def templateReplaceOne(s, Jorig):
# FIXME: This is kind of ugly code..
match=re.match(r"\<bitcoin-address\:([a-z]+)\>", s)
if match:
res=bitcoin.privtoaddr(
bitcoin.sha256(match.group(1)))
#logging.info("Replace %s with %s" % (match.group(0), res))
return res
match=re.match(r"\<hash-of\:([^>]+)\>", s)
if match:
fn=match.group(1)
res=bitcoin.sha256(open(fn).read())
#logging.info("Replace %s with %s" % (match.group(0), res))
return res
match=re.match(r"\<signature:([a-z]+)\>", s)
if match:
msg="VOTE-FORMAT-VERSION-1 %s %s %s %s %s" % (
templateReplaceOne(Jorig["handle"], Jorig),
templateReplaceOne(Jorig["addr"], Jorig),
templateReplaceOne(Jorig["ballot_option"], Jorig),
templateReplaceOne(Jorig["proposal"], Jorig),
templateReplaceOne(Jorig["proposal_meta"], Jorig)
)
privkey=bitcoin.sha256(match.group(1))
res=bitcoin.ecdsa_sign(msg, privkey)
#logging.info("Replace %s with %s" % (match.group(0), res))
return res
else:
return s
def create_transaction(name, private_key, public_key):
payload = name
addr = '000000' + hashlib.sha512(name.encode()).hexdigest()
header = transaction_pb2.TransactionHeader(
signer_pubkey=public_key,
family_name='scheduler_test',
family_version='1.0',
inputs=[addr],
outputs=[addr],
dependencies=[],
payload_encoding="application/cbor",
payload_sha512=hashlib.sha512(payload.encode()).hexdigest(),
batcher_pubkey=public_key)
header_bytes = header.SerializeToString()
signature = bitcoin.ecdsa_sign(
header_bytes,
private_key)
transaction = transaction_pb2.Transaction(
header=header_bytes,
payload=payload.encode(),
header_signature=signature)
return transaction
def create_transaction(name, private_key, public_key):
payload = name
addr = '000000' + hashlib.sha512(name.encode()).hexdigest()
header = transaction_pb2.TransactionHeader(
signer_pubkey=public_key,
family_name='scheduler_test',
family_version='1.0',
inputs=[addr],
outputs=[addr],
dependencies=[],
payload_encoding="application/cbor",
payload_sha512=hashlib.sha512(payload.encode()).hexdigest(),
batcher_pubkey=public_key)
header_bytes = header.SerializeToString()
signature = bitcoin.ecdsa_sign(
header_bytes,
private_key)
transaction = transaction_pb2.Transaction(
header=header_bytes,
payload=payload.encode(),
header_signature=signature)
return transaction
def test_go_sig():
"""
go client started with:
ethereum -port="40404" -loglevel=5 -nodekeyhex="9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658" -bootnodes="enode://2da47499d52d9161a778e4c711e22e8651cb90350ec066452f9516d1d11eb465d1ec42bb27ec6cd4488b8b6a1a411cb5ef83c16cbb8bee194624bb65fef0f7fd@127.0.0.1:30303"
"""
r_pubkey = "ab16b8c7fc1febb74ceedf1349944ffd4a04d11802451d02e808f08cb3b0c1c1a9c4e1efb7d309a762baa4c9c8da08890b3b712d1666b5b630d6c6a09cbba171".decode(
'hex')
d = {
'signed_data':
'a061e5b799b5bb3a3a68a7eab6ee11207d90672e796510ac455e985bd206e240',
'cmd':
'find_node',
'body':
'03f847b840ab16b8c7fc1febb74ceedf1349944ffd4a04d11802451d02e808f08cb3b0c1c1a9c4e1efb7d309a762baa4c9c8da08890b3b712d1666b5b630d6c6a09cbba1718454e869b1',
'signature':
'0de032c62e30f4a9f9f07f25ac5377c5a531116147617a6c08f946c97991f351577e53ae138210bdb7447bab53f3398d746d42c64a9ce67a6248e59353f1bc6e01'
}
priv_seed = 'test'
priv_key = mk_privkey(priv_seed)
assert priv_key == "9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658".decode(
'hex')
my_pubkey = privtopub(priv_key)
assert my_pubkey == r_pubkey, (my_pubkey, r_pubkey)
go_body = d['body'].decode('hex') # cmd_id, rlp.encoded
import rlp
target_node_id, expiry = rlp.decode(go_body[1:])
assert target_node_id == r_pubkey # lookup for itself
go_signed_data = d['signed_data'].decode('hex')
go_signature = d['signature'].decode('hex')
b_signature = bitcoin.ecdsa_sign(go_signed_data,
priv_key) # base64 encoded!
# https://github.com/vbuterin/pybitcointools/blob/master/bitcoin/main.py#L500
my_signature = ecdsa_sign(go_signed_data, priv_key)
assert my_signature == ecdsa_sign(go_signed_data,
priv_key) # deterministic k
assert len(go_signed_data) == 32 # sha3()
assert len(go_signature) == 65
assert len(my_signature) == 65 # length is okay
try:
assert my_signature == go_signature
failed = False
except:
"expected fail, go signatures are not generated with deterministic k"
failed = True
pass
assert failed
# decoding works when we signed it
assert my_pubkey == ecdsa_recover(go_signed_data, my_signature)
# problem we can not decode the pubkey from the go signature
# and go can not decode ours
ecdsa_recover(go_signed_data, go_signature)
def make(cls, epoch, correct_hash, wrong_push, my_pk):
msg = "%s%s%s" % (epoch, correct_hash, cls._make_reason(wrong_push))
return {
'epoch': epoch,
'correct_hash': correct_hash,
'push': wrong_push,
'signature': ecdsa_sign(msg, my_pk)
}
def make_transaction_rejection(tx, exc, my_domain, my_pk):
msg = "%s%s" % (tx['txid'], my_domain)
return {
'domain': my_domain,
'txid': tx['txid'],
'signature': ecdsa_sign(msg, my_pk),
'reason': exc.display()
}
def sign_db(self, privkey, index):
#function to add a signature to the mapping object generated from the supplied key
jsonstring = json.dumps(self.map["assets"], sort_keys=True)
jsonstring += str(self.map["n"]) + str(self.map["m"]) + str(
self.map["time"]) + str(self.map["height"])
strhash = bc.sha256(jsonstring)
sig = bc.ecdsa_sign(jsonstring, privkey)
self.map["sigs"][index] = sig
def test_invalid1(bare_session, member_list, member_a):
privkey = bitcoin.sha256("invalid")
multi_action_string = mas1(member_list)
multi_signature = bitcoin.ecdsa_sign(multi_action_string, privkey)
with pytest.raises(ValidationError):
ma = MultiAction(member_a, multi_action_string, multi_signature)
def make(cls, epoch, from_domain, to_domain, from_pk, hashes):
msg = "%s%s%s%s" % (from_domain, to_domain, "".join(hashes), epoch)
return {
'epoch': epoch,
'from_domain': from_domain,
'to_domain': to_domain,
'hashes': hashes,
'signature': ecdsa_sign(msg, from_pk)
}
def make_peer_registration(pk, domain):
timestamp = datetime.datetime.now().isoformat()
address = privtoaddr(pk)
to_sign = "%s%s%s" % (domain, address, timestamp)
return {
'domain': domain,
'payout_address': address,
'timestamp': timestamp,
'signature': ecdsa_sign(to_sign, pk)
}
def sign(self, priv):
# tx_in들에 sign에 self.hash에 대한 서명을 작성
for tx_in in self.inputs:
# digest = SHA256.new(str(tx_in).encode())
# signer = PKCS1_v1_5.new(priv)
# tx_in.sign = signer.sign(digest) # 서명
# tx_in.pubk = str(priv.publickey())
tx_in.pubk = bitcoin.privkey_to_pubkey(priv)
digest = bitcoin.sha256(str(tx_in))
tx_in.sign = bitcoin.ecdsa_sign(digest, priv)
def test_construct1(bare_session, member_list, member_a):
privkey = bitcoin.sha256(member_a.name)
multi_action_string = mas1(member_list)
multi_signature = bitcoin.ecdsa_sign(multi_action_string, privkey)
ma = MultiAction(member_a, multi_action_string, multi_signature)
assert len(ma.actions) == 3
def auth_counterparty(self, nick, cr):
#deserialize the commitment revelation
cr_dict = btc.PoDLE.deserialize_revelation(cr)
#check the validity of the proof of discrete log equivalence
tries = jm_single().config.getint("POLICY", "taker_utxo_retries")
def reject(msg):
log.info("Counterparty commitment not accepted, reason: " + msg)
return False
if not btc.verify_podle(cr_dict['P'], cr_dict['P2'], cr_dict['sig'],
cr_dict['e'], self.maker.commit,
index_range=range(tries)):
reason = "verify_podle failed"
return reject(reason)
#finally, check that the proffered utxo is real, old enough, large enough,
#and corresponds to the pubkey
res = jm_single().bc_interface.query_utxo_set([cr_dict['utxo']],
includeconf=True)
if len(res) != 1 or not res[0]:
reason = "authorizing utxo is not valid"
return reject(reason)
age = jm_single().config.getint("POLICY", "taker_utxo_age")
if res[0]['confirms'] < age:
reason = "commitment utxo not old enough: " + str(res[0]['confirms'])
return reject(reason)
reqd_amt = int(self.cj_amount * jm_single().config.getint(
"POLICY", "taker_utxo_amtpercent") / 100.0)
if res[0]['value'] < reqd_amt:
reason = "commitment utxo too small: " + str(res[0]['value'])
return reject(reason)
if res[0]['address'] != btc.pubkey_to_address(cr_dict['P'],
get_p2pk_vbyte()):
reason = "Invalid podle pubkey: " + str(cr_dict['P'])
return reject(reason)
# authorisation of taker passed
# Send auth request to taker
# Need to choose an input utxo pubkey to sign with
# (no longer using the coinjoin pubkey from 0.2.0)
# Just choose the first utxo in self.utxos and retrieve key from wallet.
auth_address = self.utxos[self.utxos.keys()[0]]['address']
auth_key = self.maker.wallet.get_key_from_addr(auth_address)
auth_pub = btc.privtopub(auth_key)
btc_sig = btc.ecdsa_sign(self.kp.hex_pk(), auth_key)
self.maker.msgchan.send_ioauth(nick, self.utxos.keys(), auth_pub,
self.cj_addr, self.change_addr, btc_sig)
#In case of *blacklisted (ie already used) commitments, we already
#broadcasted them on receipt; in case of valid, and now used commitments,
#we broadcast them here, and not early - to avoid accidentally
#blacklisting commitments that are broadcast between makers in real time
#for the same transaction.
self.maker.transfer_commitment(self.maker.commit)
#now persist the fact that the commitment is actually used.
check_utxo_blacklist(self.maker.commit, persist=True)
return True
def start_encryption(self, nick, maker_pk):
if nick not in self.active_orders.keys():
raise Exception("Counterparty not part of this transaction.")
self.crypto_boxes[nick] = [maker_pk, enc_wrapper.as_init_encryption(\
self.kp, enc_wrapper.init_pubkey(maker_pk))]
#send authorisation request
my_btc_addr = self.input_utxos.itervalues().next()['address']
my_btc_priv = self.wallet.get_key_from_addr(my_btc_addr)
my_btc_pub = btc.privtopub(my_btc_priv)
my_btc_sig = btc.ecdsa_sign(self.kp.hex_pk(), my_btc_priv)
self.msgchan.send_auth(nick, my_btc_pub, my_btc_sig)
def makeTestMultiAction(author, aparts):
""" Create signed multi action with privkey of authors as for makeTestAction. """
multi_action_string = config.action_prefix + (
"\n@@@@@\n" + config.action_prefix).join(aparts)
privkey = bitcoin.sha256(author.name)
multi_signature = bitcoin.ecdsa_sign(multi_action_string, privkey)
return MultiAction(author=author,
multi_action_string=multi_action_string,
multi_signature=multi_signature)
def start_encryption(self, nick, maker_pk):
if nick not in self.active_orders.keys():
raise Exception("Counterparty not part of this transaction.")
self.crypto_boxes[nick] = [maker_pk, enc_wrapper.as_init_encryption(\
self.kp, enc_wrapper.init_pubkey(maker_pk))]
#send authorisation request
my_btc_addr = self.input_utxos.itervalues().next()['address']
my_btc_priv = self.wallet.get_key_from_addr(my_btc_addr)
my_btc_pub = btc.privtopub(my_btc_priv)
my_btc_sig = btc.ecdsa_sign(self.kp.hex_pk(), my_btc_priv)
self.msgchan.send_auth(nick, my_btc_pub, my_btc_sig)
def test_invalid_newml(bare_session, member_list, member_a):
newml = makeTestMemberList(Global.current_member_list())
Global.set_current_member_list(newml)
# invalid action string (not current member list)
action_string = config.action_prefix+member_list.hashref()
privkey = bitcoin.sha256(member_a.name)
signature = bitcoin.ecdsa_sign(action_string, privkey)
with pytest.raises(ValidationError):
Action(member_a, action_string, signature)
def test_invalid(bare_session, member_list, member_a, newmember5):
# invalid signature string (not base64)
with pytest.raises(ValidationError):
Action(member_a, "123", "invalidsig\x00")
# valid signature, but wrong address
action_string = "123"
privkey = bitcoin.sha256("invalid")
signature = bitcoin.ecdsa_sign(action_string, privkey)
with pytest.raises(ValidationError):
Action(member_a, action_string, signature)
# invalid action string (no prefix)
action_string = "invalid"
privkey = bitcoin.sha256(member_a.name)
signature = bitcoin.ecdsa_sign(action_string, privkey)
with pytest.raises(ValidationError):
Action(member_a, action_string, signature)
# invalid action string (no member list)
action_string = config.action_prefix+(64*"0")
privkey = bitcoin.sha256(member_a.name)
signature = bitcoin.ecdsa_sign(action_string, privkey)
with pytest.raises(ValidationError):
Action(member_a, action_string, signature)
# invalid action string (member not in current list)
action_string = config.action_prefix+member_list.hashref()
privkey = bitcoin.sha256(newmember5.name)
signature = bitcoin.ecdsa_sign(action_string, privkey)
with pytest.raises(ValidationError):
Action(newmember5, action_string, signature)
def postAction(client, astr, member, upload_data=None, upload_fn=None):
""" Create dictionary for /action POST command. """
privkey, address = makeTestKey(member)
data = {}
data["author_name"] = member
data["action_string"] = (config.action_prefix +
("%s " % current_member_list_hash(client)) + astr)
data["signature"] = bitcoin.ecdsa_sign(data["action_string"], privkey)
if upload_data is not None:
data["upload"] = (BytesIO(upload_data), upload_fn)
result = client.post(prefix + "action", data=data)
rexpect(result, 201)
return result
def start_encryption(self, nick, maker_pk):
if nick not in self.active_orders.keys():
log.debug("Counterparty not part of this transaction. Ignoring")
return
self.crypto_boxes[nick] = [maker_pk, as_init_encryption(
self.kp, init_pubkey(maker_pk))]
# send authorisation request
if self.auth_addr:
my_btc_addr = self.auth_addr
else:
my_btc_addr = self.input_utxos.itervalues().next()['address']
my_btc_priv = self.wallet.get_key_from_addr(my_btc_addr)
my_btc_pub = btc.privtopub(my_btc_priv)
my_btc_sig = btc.ecdsa_sign(self.kp.hex_pk(), my_btc_priv)
self.msgchan.send_auth(nick, my_btc_pub, my_btc_sig)
def auth_counterparty(self, nick, i_utxo_pubkey, btc_sig): self.i_utxo_pubkey = i_utxo_pubkey if not btc.ecdsa_verify(self.taker_pk, btc_sig, self.i_utxo_pubkey): print 'signature didnt match pubkey and message' return False #authorisation of taker passed #(but input utxo pubkey is checked in verify_unsigned_tx). #Send auth request to taker #TODO the next 2 lines are a little inefficient. btc_key = self.maker.wallet.get_key_from_addr(self.cj_addr) btc_pub = btc.privtopub(btc_key) btc_sig = btc.ecdsa_sign(self.kp.hex_pk(), btc_key) self.maker.msgchan.send_ioauth(nick, self.utxos.keys(), btc_pub, self.change_addr, btc_sig) return True
def create_batch(transactions, private_key, public_key):
transaction_signatures = [t.header_signature for t in transactions]
header = batch_pb2.BatchHeader(signer_pubkey=public_key,
transaction_ids=transaction_signatures)
header_bytes = header.SerializeToString()
signature = bitcoin.ecdsa_sign(header_bytes, private_key)
batch = batch_pb2.Batch(header=header_bytes,
transactions=transactions,
header_signature=signature)
return batch
def start_encryption(self, nick, maker_pk):
if nick not in self.active_orders.keys():
log.debug("Counterparty not part of this transaction. Ignoring")
return
self.crypto_boxes[nick] = [
maker_pk,
as_init_encryption(self.kp, init_pubkey(maker_pk))
]
# send authorisation request
if self.auth_addr:
my_btc_addr = self.auth_addr
else:
my_btc_addr = self.input_utxos.itervalues().next()['address']
my_btc_priv = self.wallet.get_key_from_addr(my_btc_addr)
my_btc_pub = btc.privtopub(my_btc_priv)
my_btc_sig = btc.ecdsa_sign(self.kp.hex_pk(), my_btc_priv)
self.msgchan.send_auth(nick, my_btc_pub, my_btc_sig)
def create_batch(transactions, private_key, public_key):
transaction_ids = [t.header_signature for t in transactions]
header = batch_pb2.BatchHeader(
signer_pubkey=public_key,
transaction_ids=transaction_ids)
header_bytes = header.SerializeToString()
signature = bitcoin.ecdsa_sign(
header_bytes,
private_key)
batch = batch_pb2.Batch(
header=header_bytes,
transactions=transactions,
header_signature=signature)
return batch
def start_encryption(self, nick, maker_pk):
if nick not in self.active_orders.keys():
log.debug("Counterparty not part of this transaction. Ignoring")
return
try:
self.crypto_boxes[nick] = [maker_pk, as_init_encryption(
self.kp, init_pubkey(maker_pk))]
except NaclError as e:
log.debug("Unable to setup crypto box with " + nick + ": " + repr(e))
self.msgchan.send_error(nick, "invalid nacl pubkey: " + maker_pk)
return
# send authorisation request
if self.auth_addr:
my_btc_addr = self.auth_addr
else:
my_btc_addr = self.input_utxos.itervalues().next()['address']
my_btc_priv = self.wallet.get_key_from_addr(my_btc_addr)
my_btc_pub = btc.privtopub(my_btc_priv)
my_btc_sig = btc.ecdsa_sign(self.kp.hex_pk(), my_btc_priv)
self.msgchan.send_auth(nick, my_btc_pub, my_btc_sig)
def privmsg(self, nick, cmd, message):
log.debug('>>privmsg ' + 'nick=' + nick + ' cmd=' + cmd + ' msg=' +
message)
# should we encrypt?
box, encrypt = self.get_encryption_box(cmd, nick)
if encrypt:
if not box:
log.debug('error, dont have encryption box object for ' + nick +
', dropping message')
return
message = encrypt_encode(message, box)
#Anti-replay measure: append the message channel identifier
#to the signature; this prevents cross-channel replay but NOT
#same-channel replay (in case of snooper after dropped connection
#on this channel).
msg_to_be_signed = message + str(self.hostid)
sig = btc.ecdsa_sign(msg_to_be_signed, self.nick_priv)
message += ' ' + self.nick_pubkey + ' ' + sig
#forward to the implementation class (use single _ for polymrphsm to work)
self._privmsg(nick, cmd, message)
return pub
def test():
sign = "HGbib2kv9gm9IJjDt1FXbXFczZi35u0rZR3iPUIt5GglDDCeIQ7v8eYXVNIaLoJRI4URGZrhwmsYQ9aVtRTnTfQ="
pubkey = "044827c756561b8ef6b28b5e53a000805adbf4938ab82e1c2b7f7ea16a0d6face9a509a0a13e794d742210b00581f3e249ebcc705240af2540ea19591091ac1d41"
assert getMessagePubkey("hello", sign).encode("hex") == pubkey
test() # Make sure it working right
if __name__ == "__main__":
import time
import os
import sys
sys.path.append("../pybitcointools")
import bitcoin as btctools
print "OpenSSL version %s" % openssl_version
print ssl._lib
priv = "5JsunC55XGVqFQj5kPGK4MWgTL26jKbnPhjnmchSNPo75XXCwtk"
address = "1N2XWu5soeppX2qUjvrf81rpdbShKJrjTr"
sign = btctools.ecdsa_sign(
"hello", priv
) # HGbib2kv9gm9IJjDt1FXbXFczZi35u0rZR3iPUIt5GglDDCeIQ7v8eYXVNIaLoJRI4URGZrhwmsYQ9aVtRTnTfQ=
s = time.time()
for i in range(1000):
pubkey = getMessagePubkey("hello", sign)
verified = btctools.pubkey_to_address(pubkey) == address
print "1000x Verified", verified, time.time() - s
def sign(args):
data=stdin.readline()[:-1] # remove newline
privkey=bitcoin.sha256(args.handle)
print bitcoin.ecdsa_sign(data, privkey)
print
print bitcoin.privtoaddr(privkey)
closeLibrary()
openLibrary()
"""
return pub
def test():
sign = "HGbib2kv9gm9IJjDt1FXbXFczZi35u0rZR3iPUIt5GglDDCeIQ7v8eYXVNIaLoJRI4URGZrhwmsYQ9aVtRTnTfQ="
pubkey = "044827c756561b8ef6b28b5e53a000805adbf4938ab82e1c2b7f7ea16a0d6face9a509a0a13e794d742210b00581f3e249ebcc705240af2540ea19591091ac1d41"
assert getMessagePubkey("hello", sign).encode("hex") == pubkey
test() # Make sure it working right
if __name__ == "__main__":
import time
import os
import sys
sys.path.append("../pybitcointools")
import bitcoin as btctools
print "OpenSSL version %s" % openssl_version
print ssl._lib
priv = "5JsunC55XGVqFQj5kPGK4MWgTL26jKbnPhjnmchSNPo75XXCwtk"
address = "1N2XWu5soeppX2qUjvrf81rpdbShKJrjTr"
sign = btctools.ecdsa_sign("hello", priv) # HGbib2kv9gm9IJjDt1FXbXFczZi35u0rZR3iPUIt5GglDDCeIQ7v8eYXVNIaLoJRI4URGZrhwmsYQ9aVtRTnTfQ=
s = time.time()
for i in range(1000):
pubkey = getMessagePubkey("hello", sign)
verified = btctools.pubkey_to_address(pubkey) == address
print "100x Verified", verified, time.time() - s
def _sign(content, private):
return bitcoin.ecdsa_sign(content, private)
def auth_counterparty(self, nick, cr):
#deserialize the commitment revelation
cr_dict = btc.PoDLE.deserialize_revelation(cr)
#check the validity of the proof of discrete log equivalence
tries = jm_single().config.getint("POLICY", "taker_utxo_retries")
def reject(msg):
log.debug("Counterparty commitment not accepted, reason: " + msg)
return False
if not btc.verify_podle(cr_dict['P'],
cr_dict['P2'],
cr_dict['sig'],
cr_dict['e'],
self.maker.commit,
index_range=range(tries)):
reason = "verify_podle failed"
return reject(reason)
#finally, check that the proffered utxo is real, old enough, large enough,
#and corresponds to the pubkey
res = jm_single().bc_interface.query_utxo_set([cr_dict['utxo']],
includeconf=True)
if len(res) != 1 or not res[0]:
reason = "authorizing utxo is not valid"
return reject(reason)
age = jm_single().config.getint("POLICY", "taker_utxo_age")
if res[0]['confirms'] < age:
reason = "commitment utxo not old enough: " + str(
res[0]['confirms'])
return reject(reason)
reqd_amt = int(
self.cj_amount *
jm_single().config.getint("POLICY", "taker_utxo_amtpercent") /
100.0)
if res[0]['value'] < reqd_amt:
reason = "commitment utxo too small: " + str(res[0]['value'])
return reject(reason)
if res[0]['address'] != btc.pubkey_to_address(cr_dict['P'],
get_p2pk_vbyte()):
reason = "Invalid podle pubkey: " + str(cr_dict['P'])
return reject(reason)
# authorisation of taker passed
# Send auth request to taker
# Need to choose an input utxo pubkey to sign with
# (no longer using the coinjoin pubkey from 0.2.0)
# Just choose the first utxo in self.utxos and retrieve key from wallet.
auth_address = self.utxos[self.utxos.keys()[0]]['address']
auth_key = self.maker.wallet.get_key_from_addr(auth_address)
auth_pub = btc.privtopub(auth_key)
btc_sig = btc.ecdsa_sign(self.kp.hex_pk(), auth_key)
self.maker.msgchan.send_ioauth(nick, self.utxos.keys(), auth_pub,
self.cj_addr, self.change_addr, btc_sig)
#In case of *blacklisted (ie already used) commitments, we already
#broadcasted them on receipt; in case of valid, and now used commitments,
#we broadcast them here, and not early - to avoid accidentally
#blacklisting commitments that are broadcast between makers in real time
#for the same transaction.
self.maker.transfer_commitment(self.maker.commit)
#now persist the fact that the commitment is actually used.
check_utxo_blacklist(self.maker.commit, persist=True)
return True
def _sign(content, private):
return bitcoin.ecdsa_sign(content, private)
