def ecsign(rawhash, key):
if coincurve and hasattr(coincurve, 'PrivateKey'):
pk = coincurve.PrivateKey(key)
signature = pk.sign_recoverable(rawhash, hasher=None)
v = safe_ord(signature[64]) + 27
r = big_endian_to_int(signature[0:32])
s = big_endian_to_int(signature[32:64])
else:
v, r, s = ecdsa_raw_sign(rawhash, key)
return v, r, s
def main(lines):
for i in range(0, n * 2, 2):
private_key_str = lines[i]
private_key_bytes = int(private_key_str, base=16).to_bytes(32, 'big')
message = lines[i + 1]
message_bytes = message.encode()
message_hash = keccak(message_bytes)
v, r, s = ecdsa_raw_sign(message_hash, private_key_bytes)
print(*map(lambda j: hex(j)[2:], [v, r, s]), sep='\n')
def ecdsa_sign(msghash: bytes, privkey: bytes) -> Tuple[int]:
"""
Accepts a hashed message and signs it with the private key given.
:param msghash: Hashed message to sign
:param privkey: Private key to sign with
:return: Tuple(v, r, s)
"""
v, r, s = ecdsa_raw_sign(msghash, privkey)
return (v, r, s)
def ecdsa_sign(rawhash, key):
# type: (bytes, bytes) -> EcdsaSignature
if coincurve and hasattr(coincurve, 'PrivateKey'):
pk = coincurve.PrivateKey(key)
signature = pk.sign_recoverable(rawhash, hasher=None)
v = safe_ord(signature[64]) + 27
r = signature[0:32]
s = signature[32:64]
else:
v, r, s = ecdsa_raw_sign(rawhash, key)
r = u256be(r)
s = u256be(s)
return EcdsaSignature(v, r, s)
def get_battery_info() -> None:
charges = open_data_base(f"firmware/{get_db_name()}")['Charge cycles']
time = int(dt.datetime.utcnow().timestamp())
_private_key = int(private_key, base=16).to_bytes(32, byteorder='big')
message = (charges * (1 << 32) + time).to_bytes(32, byteorder='big')
data = keccak_256(message).digest()
battery_id = ecdsa_raw_sign(data, _private_key)
v = battery_id[0]
r = '0' * (64 - len(hex(battery_id[1])[2:])) + hex(battery_id[1])[2:]
s = '0' * (64 - len(hex(battery_id[2])[2:])) + hex(battery_id[2])[2:]
data = {'v': v, 'r': r, 's': s, 'charges': charges, 'time': time}
write_data_base(data,
f"firmware/{os.path.basename(__file__)[:-3]}_data.json")
def ecsign(rawhash, key): return ecdsa_raw_sign(rawhash, key)
def test_ecdsa_raw_sign():
v, r, s = ecdsa_raw_sign(b'\x35' * 32, priv)
assert ecdsa_raw_recover(b'\x35' * 32, (v, r, s)) == pub
from eth_keyfile import load_keyfile, decode_keyfile_json
directory = "C:/Users/alegr/OneDrive/Documents/GitHub/ethereum/StealthAddresses/py/"
keystore_file = "Keystore--975fbcbaeb9b3852b096ec0242aa2d96400406af.json"
address = 0x975fbcbaeb9b3852b096ec0242aa2d96400406af
tokens = 70000000000000000
nonce = 1
tx_data = address.to_bytes(20, 'big')
tx_data += tokens.to_bytes(32, 'big')
tx_data += nonce.to_bytes(32, 'big')
message = keccak_256(tx_data).digest()
#Import Scan and Spend Key
password = getpass()
priv_key = decode_keyfile_json(load_keyfile(directory + keystore_file),
bytes(password, 'utf'))
#Create Signature
from py_ecc import secp256k1
sig = secp256k1.ecdsa_raw_sign(message, priv_key)
print("data:")
print(hex(int.from_bytes(tx_data, 'big')))
print()
print("sig:")
print(sig[0])
print(hex(sig[1]))
print(hex(sig[2]))
def ec_sign(raw_hash, key):
v, r, s = ecdsa_raw_sign(raw_hash, key)
return v, r, s
from py_ecc.secp256k1 import privtopub, ecdsa_raw_sign, ecdsa_raw_recover
import binascii
priv = binascii.unhexlify(
'792eca682b890b31356247f2b04662bff448b6bb19ea1c8ab48da222c894ef9b')
pub = (
20033694065814990006010338153307081985267967222430278129327181081381512401190L,
72089573118161052907088366229362685603474623289048716349537937839432544970413L
)
assert privtopub(priv) == pub
v, r, s = ecdsa_raw_sign(b'\x35' * 32, priv)
assert ecdsa_raw_recover(b'\x35' * 32, (v, r, s)) == pub
print('secp256k1 tests passed')
