def sign(self, unsigned_tx, privtKey):
before_hash = utils.sha3(binascii.unhexlify(unsigned_tx.encode()))
v, r, s = ecsign(before_hash, normalize_key(privtKey))
signature = binascii.hexlify(
int_to_big_endian(r) + int_to_big_endian(s) +
bytes(chr(v).encode())).decode()
return signature
def sign(safe, multi):
"""Sign transation of a Safe.
This will sign a given transaction hash and return the signature.
"""
transaction_hash = click.prompt('Please enter transaction hash')
transaction_hash = codecs.decode(transaction_hash, 'hex_codec')
choice = click.prompt('What would you like to use for signing?\n(1) Private key\n(2) Account mnemonic\n(3) Safe mnemonic (Yields 2 signatures)\n', type=int)
loops = 1 if not multi else safe.get_threshold()
account_info = []
while loops > 0:
if choice == 1:
private_key = click.prompt('Please enter private key (Input hidden)', hide_input=True)
address = Account.privateKeyToAccount(private_key).address
account_info.append((private_key, address))
elif choice == 2:
mnemonic = click.prompt('Please enter account mnemonic (Input hidden)', hide_input=True)
account_info.append(get_account_info_from_mnemonic(mnemonic))
else:
mnemonic = click.prompt('Please enter Safe mnemonic (Input hidden)', hide_input=True)
account_info.append(get_account_info_from_mnemonic(mnemonic, index=0))
account_info.append(get_account_info_from_mnemonic(mnemonic, index=1))
for i, info in enumerate(account_info):
loops -= 1
private_key = info[0]
address = info[1]
v, r, s = ecsign(transaction_hash, codecs.decode(private_key, 'hex_codec'))
signature = {'v': v, 'r': r, 's': s}
click.echo('Signature {} ({}):\n\n{}'.format(i, address, json.dumps(signature)))
def _generate_signature(self, data):
"""Generate v, r, s values from payload
"""
# pack parameters based on type
sig_str = b''
for d in data:
val = d[1]
if d[2] == 'address':
# remove 0x prefix and convert to bytes
val = val[2:].encode('utf-8')
elif d[2] == 'uint256':
# encode, pad and convert to bytes
val = binascii.b2a_hex(encode_int32(int(d[1])))
sig_str += val
# hash the packed string
rawhash = sha3(codecs.decode(sig_str, 'hex_codec'))
# salt the hashed packed string
salted = sha3(u"\x19Ethereum Signed Message:\n32".encode('utf-8') + rawhash)
# sign string
v, r, s = ecsign(salted, codecs.decode(self._private_key[2:], 'hex_codec'))
# pad r and s with 0 to 64 places
return {'v': v, 'r': "{0:#0{1}x}".format(r, 66), 's': "{0:#0{1}x}".format(s, 66)}
def test_ethereum_signed_message(self):
eth_address, eth_key = get_eth_address_with_key()
eth_address_bad_checksum = eth_address.lower()
prefix = settings.ETH_HASH_PREFIX
message = faker.name()
prefixed_message = prefix + message
message_hash = utils.sha3(prefixed_message)
v, r, s = utils.ecsign(message_hash, eth_key)
ethereum_signed_message = EthereumSignedMessage(message, v, r, s)
self.assertTrue(ethereum_signed_message.check_message_hash(message))
self.assertTrue(
ethereum_signed_message.check_signing_address(eth_address))
self.assertTrue(
ethereum_signed_message.check_signing_address(eth_address.lower()))
self.assertTrue(
ethereum_signed_message.check_signing_address(eth_address[2:]))
self.assertTrue(
ethereum_signed_message.check_signing_address(
eth_address_bad_checksum))
self.assertEqual(ethereum_signed_message.get_signing_address(),
eth_address)
self.assertTrue(
utils.check_checksum(
ethereum_signed_message.get_signing_address()))
def sign_data(data, key):
data_hash = eth.sha3(data)
key_bytes = eth.normalize_key(key)
sig = eth.ecsign(data_hash, key_bytes)
logging.debug('Signature created: {0}'.format(sig))
return sig
def sign_block(block, key, randao_parent, vchash, skips):
block.header.extra_data = \
randao_parent + \
utils.zpad(utils.encode_int(skips), 32) + \
vchash
for val in utils.ecsign(block.header.signing_hash, key):
block.header.extra_data += utils.zpad(utils.encode_int(val), 32)
return block
def withdraw(self, gasprice=20 * 10**9):
h = sha3(b'withdrawwithdrawwithdrawwithdraw')
v, r, s = ecsign(h, self.key)
sigdata = encode_int32(v) + encode_int32(r) + encode_int32(s)
txdata = casper_ct.encode('startWithdrawal', [self.indices[0], self.indices[1], sigdata])
tx = Transaction(self.chain.state.get_nonce(self.address), gasprice, 650000, self.chain.config['CASPER_ADDR'], 0, txdata).sign(self.key)
self.chain.add_transaction(tx)
self.network.broadcast(self, tx)
print 'Withdrawing!'
def sign(self, payload):
rawhash = keccak256(payload)
v, r, s = ecsign(rawhash, self.key)
signature = \
zpad(bytearray_to_bytestr(int_to_32bytearray(r)), 32) + \
zpad(bytearray_to_bytestr(int_to_32bytearray(s)), 32) + \
bytearray_to_bytestr([v])
return signature
def main(accounts):
from py_eth_sig_utils import signing
data['message'] = {
'channel_adr': '0x254dffcd3277C0b1660F6d42EFbB754edaBAbC2B',
'channel_seq': 39,
'balance': 2700,
}
# signature: 0xe32976b152f5d3107a789bee8512741493c262984145415c1ffb3a42c1a80e7224dd52cc552bf86665dd185d9e04004eb8d783f624eeb6aab0011c21757e6bb21b
# generate a new raw random private key
if True:
# maker_key
# pkey_raw = a2b_hex('6370fd033278c143179d81c5526140625662b8daa446c22ee2d73db3707e620c')
# consumer_delegate_key
#pkey_raw = a2b_hex('e485d098507f54e7733a205420dfddbe58db035fa577fc294ebd14db90767a52')
pkey_raw = a2b_hex(
'a4985a2ed93107886e9a1f12c7b8e2e351cc1d26c42f3aab7f220f3a7d08fda6')
else:
pkey_raw = os.urandom(32)
print('Using private key: {}'.format(b2a_hex(pkey_raw).decode()))
# make a private key object from the raw private key bytes
pkey = eth_keys.keys.PrivateKey(pkey_raw)
# make a private account from the private key
acct = Account.privateKeyToAccount(pkey)
# get the public key of the account
addr = pkey.public_key.to_canonical_address()
print('Account address: {}'.format(b2a_hex(addr).decode()))
# get the canonical address of the account
caddr = web3.Web3.toChecksumAddress(addr)
print('Account canonical address: {}'.format(caddr))
# step-wise computation of signature
msg_hash = signing.encode_typed_data(data)
print('Ok, MSG_HASH = 0x{}'.format(b2a_hex(msg_hash).decode()))
sig_vrs = utils.ecsign(msg_hash, pkey_raw)
sig = signing.v_r_s_to_signature(*sig_vrs)
signature = signing.v_r_s_to_signature(
*signing.sign_typed_data(data, pkey_raw))
assert len(signature) == 32 + 32 + 1
#assert signature == sig
print('Ok, signed typed data (using key {}):\nSIGNATURE = 0x{}'.format(
caddr,
b2a_hex(signature).decode()))
signer_address = signing.recover_typed_data(
data, *signing.signature_to_v_r_s(signature))
assert signer_address == caddr
print('Ok, verified signature was signed by {}'.format(signer_address))
def sign_args(self,typeList, valueList, privtKey):
'''
:param typeList: ['bytes32', 'bytes32', 'uint256', 'uint256']
:param valueList: ["0x3ae88fe370c39384fc16da2c9e768cf5d2495b48", "0x9da26fc2e1d6ad9fdd46138906b0104ae68a65d8", 1, 1]
:param privtKey: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
:return:
'''
data_hash = self.solidity_hash(typeList, valueList)
v, r, s = ecsign(data_hash, normalize_key(privtKey))
signature = self.int_to_big_endian(r) + self.int_to_big_endian(s) + bytes(chr(v - 27).encode())
return signature.hex()
def withdraw(self, gasprice=20 * 10**9):
h = sha3(b'withdrawwithdrawwithdrawwithdraw')
v, r, s = ecsign(h, self.key)
sigdata = encode_int32(v) + encode_int32(r) + encode_int32(s)
txdata = casper_ct.encode('startWithdrawal',
[self.indices[0], self.indices[1], sigdata])
tx = Transaction(self.chain.state.get_nonce(self.address), gasprice,
650000, self.chain.config['CASPER_ADDR'], 0,
txdata).sign(self.key)
self.chain.add_transaction(tx)
self.network.broadcast(self, tx)
print 'Withdrawing!'
def __init__(self,
message: str,
key: bytes,
hash_prefix: str = settings.ETH_HASH_PREFIX):
"""
:param message: message
:param key: ethereum key for signing the message
:param hash_prefix: prefix for hashing
"""
self.hash_prefix = hash_prefix if hash_prefix else ''
v, r, s = utils.ecsign(self.calculate_hash(message), key)
super().__init__(message, v, r, s, hash_prefix=hash_prefix)
def sign_payload(private_key, payload):
if isinstance(private_key, str):
private_key = data_decoder(private_key)
rawhash = sha3(payload)
v, r, s = ecsign(rawhash, private_key)
signature = zpad(bytearray_to_bytestr(int_to_32bytearray(r)), 32) + \
zpad(bytearray_to_bytestr(int_to_32bytearray(s)), 32) + \
bytearray_to_bytestr([v])
return data_encoder(signature)
def personal_sign(private_key, message):
if isinstance(private_key, str):
private_key = data_decoder(private_key)
rawhash = sha3("\x19Ethereum Signed Message:\n{}{}".format(len(message), message))
v, r, s = ecsign(rawhash, private_key)
signature = zpad(bytearray_to_bytestr(int_to_32bytearray(r)), 32) + \
zpad(bytearray_to_bytestr(int_to_32bytearray(s)), 32) + \
bytearray_to_bytestr([v])
return data_encoder(signature)
def sign_args(self, typeList, valueList, privtKey):
'''
:param typeList: ['bytes32', 'bytes32', 'uint256', 'uint256']
:param valueList: ["0x3ae88fe370c39384fc16da2c9e768cf5d2495b48", "0x9da26fc2e1d6ad9fdd46138906b0104ae68a65d8", 1, 1]
:param privtKey: "095e53c9c20e23fd01eaad953c01da9e9d3ed9bebcfed8e5b2c2fce94037d963"
:return:
'''
data_hash = Web3.soliditySha3(typeList, valueList)
v, r, s = ecsign(data_hash, normalize_key(privtKey))
signature = binascii.hexlify(int_to_big_endian(r) + int_to_big_endian(s)
+ bytes(chr(v - 27).encode()))
return signature
def sign_apphash(apphash):
sedes = CountableList(List([rlp.sedes.binary,
rlp.sedes.big_endian_int,
rlp.sedes.big_endian_int,
rlp.sedes.binary,
rlp.sedes.binary]))
decoded = rlp.decode(bytes.fromhex(apphash), sedes)
for i in decoded:
data = list(i)
data[2] = bool(data[2])
msg_hash = w3.soliditySha3(['bytes32', 'uint256', 'bool', 'bytes', 'bytes'], data).hex()[2:]
signed = utils.ecsign(bytes.fromhex(msg_hash), operator_normalize_key)
tx = '1{0:0{1}X}{2:0{3}X}{4:0{5}X}{6:X}'.format(signed[1], 64,
signed[2], 64, signed[0], 2, data[1])
requests.get('http://localhost:26657/broadcast_tx_async?tx="{}"'.format(tx))
def test_ecrecover():
c = tester.Chain()
x = c.contract(ecrecover_code, language='serpent')
priv = utils.sha3('some big long brainwallet password')
pub = bitcoin.privtopub(priv)
msghash = utils.sha3('the quick brown fox jumps over the lazy dog')
V, R, S = utils.ecsign(msghash, priv)
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 = x.test_ecrecover(utils.big_endian_to_int(msghash), V, R, S)
assert result == addr
def sign(self, key, network_id=None):
"""Sign this transaction with a private key.
A potentially already existing signature would be overridden.
"""
if network_id is None:
rawhash = utils.sha3(rlp.encode(self, UnsignedTransaction))
else:
assert 1 <= network_id < 2**63 - 18
rlpdata = rlp.encode(rlp.infer_sedes(self).serialize(self)[
:-3] + [network_id, b'', b''])
rawhash = utils.sha3(rlpdata)
key = normalize_key(key)
self.v, self.r, self.s = ecsign(rawhash, key)
if network_id is not None:
self.v += 8 + network_id * 2
self._sender = utils.privtoaddr(key)
return self
def sign(self, key, network_id=None):
"""Sign this transaction with a private key.
A potentially already existing signature would be overridden.
"""
if network_id is None:
rawhash = utils.sha3(rlp.encode(self, UnsignedTransaction))
else:
assert 1 <= network_id < 2**63 - 18
rlpdata = rlp.encode(rlp.infer_sedes(self).serialize(self)[
:-3] + [network_id, b'', b''])
rawhash = utils.sha3(rlpdata)
key = normalize_key(key)
self.v, self.r, self.s = ecsign(rawhash, key)
if network_id is not None:
self.v += 8 + network_id * 2
self._sender = utils.privtoaddr(key)
return self
ecrecover_test = """
def test_ecrecover(h: bytes32, v:num256, r:num256, s:num256) -> address:
return ecrecover(h, v, r, s)
def test_ecrecover2() -> address:
return ecrecover(0x3535353535353535353535353535353535353535353535353535353535353535,
as_num256(28),
as_num256(63198938615202175987747926399054383453528475999185923188997970550032613358815),
as_num256(6577251522710269046055727877571505144084475024240851440410274049870970796685))
"""
c = s.abi_contract(ecrecover_test, language='viper')
h = b'\x35' * 32
k = b'\x46' * 32
v, r, S = u.ecsign(h, k)
assert c.test_ecrecover(h, v, r, S) == '0x' + u.encode_hex(u.privtoaddr(k))
assert c.test_ecrecover2() == '0x' + u.encode_hex(u.privtoaddr(k))
print("Passed ecrecover test")
extract32_code = """
y: bytes <= 100
def extrakt32(inp: bytes <= 100, index: num) -> bytes32:
return extract32(inp, index)
def extrakt32_mem(inp: bytes <= 100, index: num) -> bytes32:
x = inp
return extract32(x, index)
def extrakt32_storage(index: num, inp: bytes <= 100) -> bytes32:
def createOrder(orderHash, key=tester.k0):
key = normalize_key(key)
v, r, s = ecsign(sha3("\x19Ethereum Signed Message:\n32" + orderHash), key)
return v, zpad(bytearray_to_bytestr(int_to_32bytearray(r)),
32), zpad(bytearray_to_bytestr(int_to_32bytearray(s)), 32)
def sign(seq, to, value, data, key):
h1 = utils.sha3(utils.encode_int32(seq) + b'\x00' * 12 + to + utils.encode_int32(value) + data)
h2 = utils.sha3(b"\x19Ethereum Signed Message:\n32" + h1)
return list(utils.ecsign(h2, key))
def createOrder(orderHash, key=tester.k0):
key = normalize_key(key)
v, r, s = ecsign(sha3("\x19Ethereum Signed Message:\n32" + orderHash), key)
return v, zpad(bytearray_to_bytestr(int_to_32bytearray(r)), 32), zpad(bytearray_to_bytestr(int_to_32bytearray(s)), 32)
from ethereum import utils
token1 = 'fjDy8vAdvHE:APA91bHGE51C3j0OJz6fBuRUwa_aV1pLzVCh3vePVA4h2-9nhTbz4-gy6KIcduMs3PGncPAryNQ0VxyF7z3KdKviD10_yNGzgzVkXhdNQ7OWlxYgEaIorXXYkPPe45aUR4C0ic2aYSIw'
priv1 = bytes.fromhex(
'17fa8dab3ff55ca2156a47a0f128e67789a3a2da6adebf581e1c4c2f99fbc071')
address1 = '0x919aff0cc2975DEB38379a65FB2Debc6c6CdF028'
token2 = 'fWU_G7outKU:APA91bF4BiMJt1eiknSKzThEx6Fs7u1ZkXDbDPGcYPcaS6Nm2pfegfaDKcaHxGmKMOK8vXEWp8bZD1Z8KmMgbpGQXaVsSNoG0BascdUZhDqcngvQGqHmByurg7ShVb6XYFc5YVxAhETT'
priv2 = bytes.fromhex(
'0a3c393c83a0c45d6509419980c2828bbb129ed2ff966abebda9d7157ffa8e9c')
address2 = '0x2865BE1F71ddA04FC9A596fA70a7Db4F82890343'
prefix = 'GNO'
v1, r1, s1, = utils.ecsign(utils.sha3(prefix + token1), priv1)
print("=== 1 ===")
print("R: %s" % r1)
print("S: %s" % s1)
print("V: %s" % v1)
v2, r2, s2, = utils.ecsign(utils.sha3(prefix + token2), priv2)
print("=== 2 ===")
print("R: %s" % r2)
print("S: %s" % s2)
print("V: %s" % v2)
print("=== Message ===")
v_mess2, r_mess2, s_mess2, = utils.ecsign(
utils.sha3(prefix + "{\"title\":\"Hello Patron\"}"), priv2)
print("R: %s" % r_mess2)
print("S: %s" % s_mess2)
def sign(hash, privkey):
assert len(privkey) == 32
v, r, s = ecsign(hash, privkey)
return encode_int32(v) + encode_int32(r) + encode_int32(s)
def make_withdrawal_signature(key):
h = sha3(b'withdrawwithdrawwithdrawwithdraw')
v, r, s = ecsign(h, key)
return encode_int32(v) + encode_int32(r) + encode_int32(s)
from ethereum.tools import tester as t
from ethereum import utils as u
c = t.Chain()
x = c.contract(open('utxos.v.py').read(), language='viper', sender=t.k0)
assert u.normalize_address(x.get_utxos__owner(u.encode_int32(1))) == t.a0
assert x.get_utxos__value(u.encode_int32(1)) == 2**32
sigdata = u.encode_int32(1) + u.encode_int32(0) + b'\x00' * 12 + t.a2 + \
u.encode_int32(2**30) + b'\x00' * 12 + t.a2 + u.encode_int32(3 * 2**30)
sighash = u.sha3(sigdata)
v, r, s = u.ecsign(sighash, t.k0)
assert x.tx(u.encode_int32(1), u.encode_int32(0), t.a2, 2**30, t.a2, 3 * 2**30,
v, r, s) == sighash
assert u.normalize_address(x.get_utxos__owner(sighash)) == t.a2
assert x.get_utxos__value(sighash) == 2**30
sigdata2 = sighash + u.encode_int32(0) + b'\x00' * 12 + t.a3 + \
u.encode_int32(2**29) + b'\x00' * 12 + t.a3 + u.encode_int32(2**29)
sighash2 = u.sha3(sigdata2)
v, r, s = u.ecsign(sighash2, t.k2)
assert x.tx(sighash, u.encode_int32(0), t.a3, 2**29, t.a3, 2**29, v, r,
s) == sighash2
print('Tests passed')
def sign(hash, key):
vrs = u.ecsign(hash, key)
rsv = vrs[1:] + vrs[:1]
vrs_bytes = [u.encode_int32(i) for i in rsv[:2]] + [u.int_to_bytes(rsv[2])]
return b''.join(vrs_bytes)
def sign(msg_hash, privkey):
v, r, s = utils.ecsign(msg_hash, privkey)
signature = utils.encode_int32(v) + utils.encode_int32(
r) + utils.encode_int32(s)
return signature
def sign(self, tx_hash: str):
msg_bytes = bytes.fromhex(tx_hash)
v, r, s = ecsign(msg_bytes, self.private_key)
return r, s, v
def sign(_hash, key):
v, r, s = utils.ecsign(_hash, key)
return utils.encode_int32(r) + utils.encode_int32(s) + utils.encode_int(v)
