def test_update_mediated_transfer(settle_timeout, tester_state,
tester_channels, tester_events):
privatekey0_raw, privatekey1_raw, nettingchannel, channel0, channel1 = tester_channels[
0]
privatekey0 = PrivateKey(privatekey0_raw, ctx=GLOBAL_CTX, raw=True)
privatekey1 = PrivateKey(privatekey1_raw, ctx=GLOBAL_CTX, raw=True)
address0 = privatekey_to_address(privatekey0_raw)
address1 = privatekey_to_address(privatekey1_raw)
transfer_amount = 3
direct_transfer0 = channel0.create_directtransfer(
transfer_amount,
1 # TODO: fill in identifier
)
direct_transfer0.sign(privatekey0, address0)
direct_transfer0_data = str(direct_transfer0.packed().data)
channel0.register_transfer(direct_transfer0)
channel1.register_transfer(direct_transfer0)
target = tester.a0
initiator = tester.a1
lock_amount = 5
lock_expiration = tester_state.block.number + DEFAULT_REVEAL_TIMEOUT + 3
lock_hashlock = sha3('secret')
mediated_transfer0 = channel0.create_mediatedtransfer(
transfer_initiator=initiator,
transfer_target=target,
fee=0,
amount=lock_amount,
identifier=1, # TODO: fill in identifier
expiration=lock_expiration,
hashlock=lock_hashlock,
)
mediated_transfer0.sign(privatekey0, address0)
mediated_transfer0_data = str(mediated_transfer0.packed().data)
channel0.register_transfer(mediated_transfer0)
channel1.register_transfer(mediated_transfer0)
transfer_amount = 13
direct_transfer1 = channel1.create_directtransfer(transfer_amount)
direct_transfer1.sign(privatekey1, address1)
direct_transfer1_data = str(direct_transfer1.packed().data)
channel0.register_transfer(direct_transfer1)
channel1.register_transfer(direct_transfer1)
nettingchannel.close(
direct_transfer0_data,
direct_transfer1_data,
sender=privatekey0_raw,
)
nettingchannel.updateTransfer(
mediated_transfer0_data,
sender=privatekey1_raw,
)
tester_state.mine(number_of_blocks=settle_timeout + 1)
def test_verify_recoverable_sign(self):
"""Verifies recovering a signature."""
test_requests = [TEST_REQUEST_TRANSFER_ICX, TEST_REQUEST_SCORE_FUNCTION_CALL,
TEST_REQUEST_SEND_MESSAGE, TEST_REQUEST_SCORE_UPDATE, TEST_REQUEST_SCORE_ISNTALL]
for request in test_requests:
# Serialize a signature
private_key_object = PrivateKey()
msg_hash_bytes = sha3_256(serialize(request["params"])).digest()
sign_bytes = sign(msg_hash_bytes, private_key_object.private_key)
# Deserialize a signature
recoverable_sign = private_key_object.ecdsa_recoverable_deserialize(sign_bytes[0:64], sign_bytes[64])
sign_ = private_key_object.ecdsa_recoverable_convert(recoverable_sign)
# Verify a signature with a public key
self.assertTrue(private_key_object.pubkey.ecdsa_verify(msg_hash_bytes, sign_, raw=True))
# Verify a signature when an message is invalid
invalid_msg_hash = sha3_256(f'invalid message'.encode()).digest()
self.assertFalse(private_key_object.pubkey.ecdsa_verify(invalid_msg_hash, sign_, raw=True))
# Verify a signature when a private key is invalid
invalid_private_key = PrivateKey()
self.assertFalse(invalid_private_key.pubkey.ecdsa_verify(msg_hash_bytes, sign_, raw=True))
def _sha3_secp256k1_deploy_data(current_height,
bytecode,
value,
quota,
privatekey,
version,
receiver=None):
sender = get_sender(privatekey, False)
if privatekey is None:
temp = private_key()
privkey = PrivateKey(hex2bytes(temp))
else:
privkey = PrivateKey(hex2bytes(privatekey))
logger.debug(sender)
nonce = get_nonce()
logger.debug("nonce is {}".format(nonce))
tx = Transaction()
tx.valid_until_block = current_height + 88
tx.nonce = nonce
tx.version = version
if version == 0:
chainid = get_chainid()
logger.info("version-{}, chainid-{}".format(version, chainid))
tx.chain_id = chainid
elif version < 3:
chainid = get_chainid_v1()
logger.info("version-{}, chainid_v1-{}".format(version, chainid))
tx.chain_id_v1 = chainid.to_bytes(32, byteorder='big')
else:
logger.error("unexpected version {}".format(version))
if receiver is not None:
if version == 0:
tx.to = receiver
elif version < 3:
tx.to_v1 = hex2bytes(receiver)
else:
logger.error("unexpected version {}".format(version))
tx.data = hex2bytes(bytecode)
tx.value = value.to_bytes(32, byteorder='big')
tx.quota = quota
message = sha3(tx.SerializeToString())
logger.debug("hash message: {}")
sign_recover = privkey.ecdsa_sign_recoverable(message, raw=True)
sig = privkey.ecdsa_recoverable_serialize(sign_recover)
signature = binascii.hexlify(sig[0]) + binascii.hexlify(
bytes(bytearray([sig[1]])))
unverify_tx = UnverifiedTransaction()
unverify_tx.transaction.CopyFrom(tx)
unverify_tx.signature = hex2bytes(signature)
unverify_tx.crypto = Crypto.Value('DEFAULT')
logger.info("unverify_tx is {}".format(
binascii.hexlify(unverify_tx.SerializeToString())))
return binascii.hexlify(unverify_tx.SerializeToString())
def test_settlement_with_unauthorized_token_transfer(deposit, settle_timeout,
tester_state,
tester_channels,
tester_events,
tester_token):
privatekey0_raw, privatekey1_raw, nettingchannel, channel0, channel1 = tester_channels[
0]
privatekey0 = PrivateKey(privatekey0_raw, ctx=GLOBAL_CTX, raw=True)
privatekey1 = PrivateKey(privatekey1_raw, ctx=GLOBAL_CTX, raw=True)
address0 = privatekey_to_address(privatekey0_raw)
address1 = privatekey_to_address(privatekey1_raw)
# transfer some extra tokens to the contract to try to mess up the balance
extra_amount = 10
assert tester_token.transfer(nettingchannel.address,
extra_amount,
sender=privatekey0_raw)
initial_balance0 = tester_token.balanceOf(address0, sender=privatekey0_raw)
initial_balance1 = tester_token.balanceOf(address1, sender=privatekey1_raw)
transfer_amount0 = 10
direct_transfer0 = channel0.create_directtransfer(
transfer_amount0,
1 # TODO: fill in identifier
)
direct_transfer0.sign(privatekey0, address0)
transfer_amount1 = 30
direct_transfer1 = channel1.create_directtransfer(
transfer_amount1,
1 # TODO: fill in identifier
)
direct_transfer1.sign(privatekey1, address1)
nettingchannel.close(
str(direct_transfer0.packed().data),
str(direct_transfer1.packed().data),
sender=privatekey1_raw,
)
block_number = tester_state.block.number
assert nettingchannel.closed(sender=privatekey0_raw) == block_number
assert nettingchannel.closingAddress(
sender=privatekey0_raw) == encode_hex(address1)
tester_state.mine(number_of_blocks=settle_timeout + 1)
nettingchannel.settle(sender=privatekey0_raw)
assert tester_token.balanceOf(
address0, sender=privatekey0_raw
) == initial_balance0 + deposit - transfer_amount0 + transfer_amount1 # noqa
assert tester_token.balanceOf(
address1, sender=privatekey1_raw
) == initial_balance1 + deposit + transfer_amount0 - transfer_amount1 # noqa
# Make sure that the extra amount is burned/locked in the netting channel
assert tester_token.balanceOf(nettingchannel.address,
sender=privatekey1_raw) == extra_amount
def test_wallet_load_by_private_key(self):
"""A wallet loads by a private key correctly."""
# Creates a wallet.
private_key_object = PrivateKey()
private_key = private_key_object.private_key
wallet1 = KeyWallet.load(private_key)
# Checks a private key as same.
self.assertEqual(private_key.hex(), wallet1.get_private_key())
# Checks a wallet's address is correct.
self.assertTrue(is_wallet_address(wallet1.get_address()))
# Creates the other wallet.
private_key_object2 = PrivateKey()
private_key2 = private_key_object2.private_key
wallet2 = KeyWallet.load(private_key2)
# Checks a private key as same.
self.assertEqual(private_key2.hex(), wallet2.get_private_key())
# Checks a wallet's address is correct.
self.assertTrue(is_wallet_address(wallet2.get_address()))
self.assertNotEqual(private_key2, private_key)
def test_closewithouttransfer_badalice(deposit, settle_timeout, tester_state,
tester_events, tester_channels,
tester_token):
privatekeyA_raw, privatekeyB_raw, nettingchannel, channelAB, channelBA = tester_channels[
0]
privatekeyA = PrivateKey(privatekeyA_raw, ctx=GLOBAL_CTX, raw=True)
privatekeyB = PrivateKey(privatekeyB_raw, ctx=GLOBAL_CTX, raw=True)
addressA = privatekey_to_address(privatekeyA_raw)
addressB = privatekey_to_address(privatekeyB_raw)
initial_balanceA = tester_token.balanceOf(addressA, sender=privatekeyA_raw)
initial_balanceB = tester_token.balanceOf(addressB, sender=privatekeyB_raw)
transfer_amount = 50
AB_Transfer0 = channelAB.create_directtransfer(
transfer_amount,
1 # TODO: fill in identifier
)
AB_Transfer0.sign(privatekeyA, addressA)
channelAB.register_transfer(AB_Transfer0)
channelBA.register_transfer(AB_Transfer0)
transfer_amount = 40
BA_Transfer0 = channelBA.create_directtransfer(
transfer_amount,
1 # TODO: fill in identifier
)
BA_Transfer0.sign(privatekeyB, addressB)
channelAB.register_transfer(BA_Transfer0)
channelBA.register_transfer(BA_Transfer0)
transfer_amount = 90
AB_Transfer1 = channelAB.create_directtransfer(
transfer_amount,
1 # TODO: fill in identifier
)
AB_Transfer1.sign(privatekeyA, addressA)
channelAB.register_transfer(AB_Transfer1)
channelBA.register_transfer(AB_Transfer1)
AB_Transfer1_data = str(AB_Transfer1.packed().data)
nettingchannel.close("", "", sender=privatekeyA_raw)
nettingchannel.updateTransfer(
AB_Transfer1_data,
sender=privatekeyB_raw,
)
tester_state.mine(number_of_blocks=settle_timeout + 1)
nettingchannel.settle(sender=privatekeyB_raw)
tester_state.mine(number_of_blocks=2)
assert tester_token.balanceOf(nettingchannel.address,
sender=privatekeyA_raw) == 0
assert tester_token.balanceOf(
addressB, sender=privatekeyA_raw) == initial_balanceB + 100
assert tester_token.balanceOf(
addressA, sender=privatekeyA_raw) == initial_balanceA + deposit - 100
def setUp(self):
# create private key and sender_address receive_address
self.private_key = PrivateKey()
self.send_address = self.__create_address(self.private_key.pubkey)
logging.debug(f"create sender address : {self.send_address}")
self.receive_address = self.__create_address(PrivateKey().pubkey)
logging.debug(f"create sender address : {self.receive_address}")
self.hash_generator = get_tx_hash_generator(conf.LOOPCHAIN_DEFAULT_CHANNEL)
self.tx_validator = TxValidator(conf.LOOPCHAIN_DEFAULT_CHANNEL, conf.SendTxType.icx, self.hash_generator)
def sign(priv_key, message):
sk = PrivateKey(priv_key, True)
pk = binascii.hexlify(sk.pubkey.serialize(True)).decode("utf-8")
sig_raw = sk.ecdsa_sign(bytes(bytearray.fromhex(message)),
digest=bitcoin_hash)
sig = sk.ecdsa_serialize(sig_raw)
return pk, binascii.hexlify(sig).decode("utf-8")
def generate_wallet() -> Dict[str, str]:
privkey = PrivateKey().serialize()
return {
"private_key": privkey,
"public_key": privkey_to_pubkey(privkey),
"address": privkey_to_address(privkey),
}
def from_private_key(private_key: Optional[PrivateKey] = None) -> 'IconJsonrpc':
"""Create IconJsonrpc object from PrivateKey object. If parameter is None, make PrivateKey object.
:param private_key: PrivateKey object
:return: IconJsonrpc object
"""
return IconJsonrpc(IcxSigner(private_key=private_key or PrivateKey().private_key))
def sign(self, key):
"""Sign this transaction with a private key.
A potentially already existing signature would be overridden.
"""
if not is_bitcoin_available() or not is_secp256k1_available():
raise ImportError(
"In order to sign transactions the "
"`bitcoin` and `secp256k1` packages must be installed.")
from bitcoin import privtopub
from secp256k1 import PrivateKey
if key in (0, b'', b'\x00' * 32, b'0' * 64):
raise ValueError("Zero privkey cannot sign")
rawhash = decode_hex(sha3(rlp.encode(self, UnsignedTransaction)))
if len(key) in {64, 66}:
# we need a binary key
key = decode_hex(key)
pk = PrivateKey(key, raw=True)
sig_bytes, rec_id = pk.ecdsa_recoverable_serialize(
pk.ecdsa_sign_recoverable(rawhash, raw=True))
signature = sig_bytes + force_bytes(chr(rec_id))
self.v = (ord(signature[64])
if is_string(signature[64]) else signature[64]) + 27
self.r = decode_big_endian_int(signature[0:32])
self.s = decode_big_endian_int(signature[32:64])
self.sender = to_address(sha3(privtopub(key)[1:])[-40:])
return self
def test_receive_hashlocktransfer_unknown(raiden_network):
app0 = raiden_network[0] # pylint: disable=unbalanced-tuple-unpacking
token_manager0 = app0.raiden.managers_by_token_address.values()[0]
other_key = PrivateKey(HASH2, ctx=GLOBAL_CTX, raw=True)
other_address = privatekey_to_address(other_key.private_key)
amount = 10
lock = Lock(amount, 1, HASH)
refund_transfer = RefundTransfer(identifier=1,
nonce=1,
token=token_manager0.token_address,
transferred_amount=amount,
recipient=app0.raiden.address,
locksroot=HASH,
lock=lock)
sign_and_send(refund_transfer, other_key, other_address, app0)
transfer_timeout = TransferTimeout(HASH, HASH)
sign_and_send(transfer_timeout, other_key, other_address, app0)
secret = Secret(1, HASH, token_manager0.token_address)
sign_and_send(secret, other_key, other_address, app0)
secret_request = SecretRequest(1, HASH, 1)
sign_and_send(secret_request, other_key, other_address, app0)
reveal_secret = RevealSecret(HASH)
sign_and_send(reveal_secret, other_key, other_address, app0)
# Whenever processing of ConfirmTransfer is implemented test it here
# too by removing the expectation of an exception
with pytest.raises(KeyError):
confirm_transfer = ConfirmTransfer(HASH)
sign_and_send(confirm_transfer, other_key, other_address, app0)
def __init__(self, private_key, env: Optional[BinanceEnvironment] = None):
super().__init__(env)
self._private_key = private_key
self._pk = PrivateKey(bytes(bytearray.fromhex(self._private_key)))
self._public_key = self._pk.pubkey.serialize(compressed=True)
self._address = address_from_public_key(self._public_key,
self._env.hrp)
def main():
args = render_args()
from random import Random
rng = Random(0xabad533d)
def randbytes(l):
ret = []
while len(ret) < l:
ret.append(rng.randrange(0, 256))
return bytes(ret)
rand = Rand(randbytes)
test_vectors = []
for i in range(10):
chaincode = rand.b(32)
pk = PrivateKey(rand.b(32), True).pubkey.serialize(compressed=True)
(external_ovk, internal_ovk) = derive_ovks(chaincode, pk)
test_vectors.append({
'c' : chaincode,
'pk': pk,
'external_ovk': external_ovk,
'internal_ovk': internal_ovk,
})
render_tv(
args,
'zip_0316',
(
('c', '[u8; 32]'),
('pk', '[u8; 33]'),
('external_ovk', '[u8; 32]'),
('internal_ovk', '[u8; 32]'),
),
test_vectors,
)
def test_receive_hashlocktransfer_unknown(raiden_network):
app0 = raiden_network[0] # pylint: disable=unbalanced-tuple-unpacking
graph0 = app0.raiden.channelgraphs.values()[0]
other_key = PrivateKey(HASH2, ctx=GLOBAL_CTX, raw=True)
other_address = privatekey_to_address(other_key.private_key)
amount = 10
lock = Lock(amount, 1, HASH)
refund_transfer = RefundTransfer(identifier=1,
nonce=1,
token=graph0.token_address,
transferred_amount=amount,
recipient=app0.raiden.address,
locksroot=HASH,
lock=lock)
sign_and_send(refund_transfer, other_key, other_address, app0)
secret = Secret(1, HASH, graph0.token_address)
sign_and_send(secret, other_key, other_address, app0)
secret_request = SecretRequest(1, HASH, 1)
sign_and_send(secret_request, other_key, other_address, app0)
reveal_secret = RevealSecret(HASH)
sign_and_send(reveal_secret, other_key, other_address, app0)
def private_to_public_uncompressed(private_key):
if(type(private_key) == str):
private_key = bytes.fromhex(private_key)
private_key_object = PrivateKey(private_key)
uncompressed = hexlify(private_key_object.pubkey.serialize(
compressed=False)).decode('ascii')
return uncompressed
def create_message(sender, receiver, content):
"""create message""" ""
try:
store = JsonStore(default_path)
sender_address = store.get(sender)['address']
sender_ecc_prikey = store.get(sender)['ecc_prikey']
sender_ecc_pubkey = store.get(sender)['ecc_pubkey']
receiver_address = store.get(receiver)['address']
receiver_rsa_pubkey = store.get(receiver)['rsa_pubkey']
# use receiver's rsa pubkey encrypt content
h = SHA.new(content.encode('utf-8'))
key = RSA.importKey(receiver_rsa_pubkey)
cipher = PKCS1_v1_5.new(key)
encrypt = cipher.encrypt(content.encode('utf-8') + h.digest())
encrypted_content = binascii.hexlify(encrypt).decode('utf-8')
# sign message use sender's ecc prikey
ecc_prikey = PrivateKey(bytes(bytearray.fromhex(sender_ecc_prikey)))
sign = ecc_prikey.ecdsa_sign(encrypt)
msg_sing = binascii.hexlify(
ecc_prikey.ecdsa_serialize(sign)).decode('utf-8')
return MessageLayout(sender=sender_address,
receiver=receiver_address,
content=encrypted_content,
sign=msg_sing,
pubkey=sender_ecc_pubkey,
t=str(time.asctime(time.localtime(time.time()))))
except Exception as e:
print(str(e))
def __init__(self, node_id, port):
super().__init__()
self.type = HANDSHAKE_MESSAGE
self.sigtype = 0
self.network_version = int('0x04b6', 16)
self.chain_id = bytes.fromhex(config.CHAIN_ID)
self.node_id = node_id #hashlib.sha256().digest() # random sha256
self.key = bytes([0 for n in range(34)])
self.time = int(time.time() * 1000000000)
self.token = bytes([0 for n in range(32)])
#self.token = hashlib.sha256(self.time).digest()
pri = get_private_ket_by_wif(config.prvkey)
privkey = PrivateKey(bytes(pri), raw=True)
#self.sig,_ = privkey.ecdsa_sign(self.token, raw=True, count=0)
#self.sig = bytes(self.sig.data)
self.sig = bytes([0 for n in range(66)])
self.p2p_address = "fakenode:%d - %s" % (port, self.node_id.hex()[0:7])
self.p2p_address = self.p2p_address.encode('unicode_escape')
self.last_irreversible_block_num = config.last_irreversible_block_num
self.last_irreversible_block_id = bytes.fromhex(
config.last_irreversible_block_id)
self.head_num = config.head_num
self.head_id = bytes.fromhex(config.head_id)
self.os = "linux" # linux/osx/win32/other
self.os = self.os.encode('unicode_escape')
self.agent = '"F**k eos"'
self.agent = self.agent.encode('unicode_escape')
self.generation = 1
def from_prikey_file(prikey_file: str, password):
if isinstance(password, str):
password = password.encode()
# if prikey_file.endswith('.der') or prikey_file.endswith('.pem'):
with open(prikey_file, "rb") as file:
private_bytes = file.read()
try:
if is_binaray_string(prikey_file):
temp_private = serialization \
.load_der_private_key(private_bytes,
password,
default_backend())
else:
temp_private = serialization \
.load_pem_private_key(private_bytes,
password,
default_backend())
except Exception as e:
raise ValueError("Invalid Password or Certificate load Failure)")
no_pass_private = temp_private.private_bytes(
encoding=serialization.Encoding.DER,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.NoEncryption()
)
key_info = keys.PrivateKeyInfo.load(no_pass_private)
val = key_info['private_key'].native['private_key']
width = val.bit_length()
width += 8 - ((width % 8) or 8)
fmt = '%%0%dx' % (width // 4)
prikey = binascii.unhexlify(fmt % val)
pubkey = PrivateKey(prikey).pubkey.serialize(compressed=False)
hash_pub = hashlib.sha3_256(pubkey[1:]).hexdigest()
return prikey
def verify_sig(secret, hash_digest, sig_bytes):
"""
Verify that the provided signature was in fact
generated by the given private key for the
given hash_digest
inputs:
- privkey: a hex-string private key scalar
- hash_digest: a hex-string hash message
- sig: a 64-byte array of concatenated r + s values of the signature to verify
returns:
- True if valid signature,
- False otherwise
"""
if len(sig_bytes) != 64:
raise ValueError(
"Expected a 64-byte array for sig, got {} ({})".format(
len(sig_bytes), sig_bytes.hex()))
privkey = PrivateKey(bytes(bytearray.fromhex(secret)), raw=True)
sig = privkey.ecdsa_deserialize_compact(sig_bytes)
return privkey.pubkey.ecdsa_verify(bytes(bytearray.fromhex(hash_digest)),
sig,
raw=True)
def convert(self, value, param, ctx) -> PrivateKey:
val = value[2:] if value.startswith(('0x', '0X')) else value
try:
num = bytes.fromhex(val)
return PrivateKey(num)
except (ValueError, TypeError):
self.fail('%s is not a valid private key of 64 hexadecimal digits')
def test_ecrecover():
s = tester.state()
c = s.abi_contract(ecrecover_code)
priv = utils.sha3('some big long brainwallet password')
pub = bitcoin.privtopub(priv)
msghash = utils.sha3('the quick brown fox jumps over the lazy dog')
pk = PrivateKey(priv, raw=True)
signature = pk.ecdsa_recoverable_serialize(
pk.ecdsa_sign_recoverable(msghash, 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])
assert bitcoin.ecdsa_raw_verify(msghash, (V, R, S), pub)
addr = utils.big_endian_to_int(
utils.sha3(bitcoin.encode_pubkey(pub, 'bin')[1:])[12:])
assert utils.big_endian_to_int(utils.privtoaddr(priv)) == addr
result = c.test_ecrecover(utils.big_endian_to_int(msghash), V, R, S)
assert result == addr
def sign(message, private_key_hex):
private_key = PrivateKey(bytes(bytearray.fromhex(private_key_hex)),
raw=True)
signature = private_key.ecdsa_sign(message)
signature = private_key.ecdsa_serialize_compact(signature).hex()
return signature
def test_decode_direct_transfer(private_keys, settle_timeout, tester_state,
tester_token, tester_events, tester_registry):
privatekey0 = tester.DEFAULT_KEY
privatekey1 = private_keys[1]
address0 = privatekey_to_address(privatekey0)
address1 = privatekey_to_address(privatekey1)
dtester = deploy_decoder_tester(tester_token.address, address0, address1,
settle_timeout)
locksroot = sha3("Waldemarstr")
message = DirectTransfer(identifier=1,
nonce=2,
asset=tester_token.address,
transferred_amount=1337,
recipient=address1,
locksroot=locksroot)
message.sign(PrivateKey(privatekey0, ctx=GLOBAL_CTX, raw=True), address0)
_, publickey = wrap_and_validate(message.encode())
recovered_address = address_from_key(publickey)
assert recovered_address == address0
assert dtester.testDecodeTransfer(message.encode()) is True
assert dtester.decodedNonce() == 2
assert dtester.decodedAsset() == tester_token.address.encode('hex')
assert dtester.decodedRecipient() == address1.encode('hex')
assert dtester.decodedAmount() == 1337
assert dtester.decodedLocksroot() == locksroot
def test_from_private_key_bytes(self):
byte_data = f'{"0"*32}'.encode()
private_key_object = PrivateKey(byte_data)
from_private_key = IconJsonrpc.from_private_key(
private_key_object.private_key)
self.assertTrue(from_private_key.signer)
self.assertTrue(from_private_key.address)
def test_sign_recoverable_verify_sig(self):
# get sign, recovery
sign, recovery_id = self.signer.sign_recoverable(self.hashed_message)
# Convert recoverable sig to normal sig
deserialized_recoverable_sig = self.test_private_key.ecdsa_recoverable_deserialize(
sign, recovery_id)
normal_sig = self.test_private_key.ecdsa_recoverable_convert(
deserialized_recoverable_sig)
# Check sig
self.assertTrue(
self.test_private_key.pubkey.ecdsa_verify(self.hashed_message,
normal_sig,
raw=True))
# Verify using invalid message
m = hashlib.sha256()
m.update(b'invalid message')
invalid_message = m.digest()
self.assertFalse(
self.test_private_key.pubkey.ecdsa_verify(invalid_message,
normal_sig,
raw=True))
# Verify using invalid private key
invalid_privateKey = PrivateKey()
self.assertFalse(
invalid_privateKey.pubkey.ecdsa_verify(self.hashed_message,
normal_sig,
raw=True))
def test_update_must_fail_with_a_nonparticipant_transfer(
tester_channels, private_keys):
""" updateTransfer must not accept a transfer from a non participant. """
pkey0, pkey1, nettingchannel, channel0, channel1 = tester_channels[0]
nonparticipant_key = private_keys[2]
# make a transfer where pkey1 is the target
transfer_nonparticipant = DirectTransfer(
identifier=1,
nonce=1,
token=channel0.token_address,
transferred_amount=10,
recipient=channel1.our_address,
locksroot='',
)
nonparticipant_address = privatekey_to_address(nonparticipant_key)
nonparticipant_sign_key = PrivateKey(nonparticipant_key,
ctx=GLOBAL_CTX,
raw=True)
transfer_nonparticipant.sign(nonparticipant_sign_key,
nonparticipant_address)
transfer_nonparticipant_data = str(transfer_nonparticipant.packed().data)
nettingchannel.close('', sender=pkey0)
with pytest.raises(TransactionFailed):
nettingchannel.updateTransfer(transfer_nonparticipant_data,
sender=pkey1)
class BlockVerifier(ABC):
version = None
_ecdsa = PrivateKey()
def __init__(self, tx_versioner: 'TransactionVersioner'):
self._tx_versioner = tx_versioner
self.invoke_func: Callable[['Block'], ('Block', dict)] = None
@abstractmethod
def verify(self,
block: 'Block',
prev_block: 'Block',
blockchain=None,
generator: 'ExternalAddress' = None):
raise NotImplementedError
@abstractmethod
def verify_loosely(self,
block: 'Block',
prev_block: 'Block',
blockchain=None,
generator: 'ExternalAddress' = None):
raise NotImplementedError
def verify_version(self, block: 'Block'):
if block.header.version != self.version:
raise BlockVersionNotMatch(
block.header.version, self.version,
f"The block version is incorrect. Block({block.header})")
def verify_signature(self, block: 'Block'):
recoverable_sig = self._ecdsa.ecdsa_recoverable_deserialize(
block.header.signature.signature(),
block.header.signature.recover_id())
raw_public_key = self._ecdsa.ecdsa_recover(block.header.hash,
recover_sig=recoverable_sig,
raw=True,
digest=hashlib.sha3_256)
public_key = PublicKey(raw_public_key, ctx=self._ecdsa.ctx)
hash_pub = hashlib.sha3_256(
public_key.serialize(compressed=False)[1:]).digest()
expect_address = hash_pub[-20:]
if expect_address != block.header.peer_id:
raise RuntimeError(
f"block peer id {block.header.peer_id.hex_xx()}, "
f"expected {ExternalAddress(expect_address).hex_xx()}")
@classmethod
def new(cls, version: str,
tx_versioner: 'TransactionVersioner') -> 'BlockVerifier':
from . import v0_1a, v0_2
if version == v0_1a.version:
return v0_1a.BlockVerifier(tx_versioner)
if version == v0_2.version:
return v0_2.BlockVerifier(tx_versioner)
raise NotImplementedError(
f"BlockBuilder Version({version}) not supported.")
def sign(self, privkey):
"""Sign this with a private key"""
if self.v:
raise InvalidSignature("already signed")
if privkey in (0, '', '\x00' * 32):
raise InvalidSignature("Zero privkey cannot sign")
rawhash = sha3(
rlp.encode(self, self.__class__.exclude(['v', 'r', 's'])))
if len(privkey) == 64:
privkey = encode_privkey(privkey, 'bin')
pk = PrivateKey(privkey, raw=True)
signature = pk.ecdsa_recoverable_serialize(
pk.ecdsa_sign_recoverable(rawhash, raw=True))
signature = signature[0] + chr(signature[1])
self.v = ord(signature[64]) + 27
self.r = big_endian_to_int(signature[0:32])
self.s = big_endian_to_int(signature[32:64])
self._sender = None
return self
def generate_deploy_data(bytecode, privatekey, receiver=None):
privkey = PrivateKey(hex2bytes(privatekey))
sender = get_sender()
print(sender)
nonce = get_nonce(sender)
print("nonce is {}".format(nonce))
tx = Transaction()
tx.valid_until_block = 4294967296
tx.nonce = nonce
if receiver is not None:
tx.to = receiver
tx.data = hex2bytes(bytecode)
message = sha3(tx.SerializeToString())
sign_recover = privkey.ecdsa_sign_recoverable(message, raw=True)
sig = privkey.ecdsa_recoverable_serialize(sign_recover)
signature = binascii.hexlify(
sig[0]) + binascii.hexlify(bytes(bytearray([sig[1]])))
unverify_tx = UnverifiedTransaction()
unverify_tx.transaction.CopyFrom(tx)
unverify_tx.signature = hex2bytes(signature)
unverify_tx.crypto = Crypto.Value('SECP')
signed_transaction = SignedTransaction()
signed_transaction.transaction_with_sig.CopyFrom(unverify_tx)
signed_transaction.tx_hash = sha3(unverify_tx.SerializeToString())
pub = recover_pub(hex2bytes(privatekey))
signed_transaction.signer = pub
#print(binascii.hexlify(pub))
return binascii.hexlify(signed_transaction.SerializeToString())
