class Wallet:
def __init__(self, address, private_key):
self._address = address
self._private_key = private_key
self._pk = PrivateKey(bytes(bytearray.fromhex(private_key)))
self._public_key = self._pk.pubkey.serialize(compressed=True)
@property
def address(self):
return self._address
@property
def private_key(self):
return self._private_key
@property
def public_key(self):
return self._public_key
def sign_message(self, msg_bytes):
sig = self._pk.ecdsa_sign(msg_bytes)
return self._pk.ecdsa_serialize_compact(sig)
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 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 sign(wfi, trx, raw=True):
pri = get_private_ket_by_wif(wfi)
if not raw:
trx = hashlib.sha256(trx).digest()
privkey = PrivateKey(bytes(pri), raw=True)
count = 0
i = 0
for j in range(0, 10, 1):
count += 1
sig2, rec_id = privkey.ecdsa_sign(trx, raw=True, count=count)
dsig = privkey.ecdsa_serialize(sig2)
lenR = dsig[3]
lenS = dsig[5 + lenR]
if (lenR == 32 and lenS == 32):
i = rec_id[0]
i += 4
# compressed
i += 27
# compact // 24 or 27 :( forcing odd-y 2nd key candidate)
break
R = dsig[4:36]
S = dsig[38:]
data = bytes([i]) + R + S + b'K1'
h = RIPEMD.new()
h.update(data)
p = h.digest()
checksum = p[0:4]
data = bytes([i]) + R + S + checksum
return "SIG_K1_" + base58.b58encode(data)
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 sign_data(cls, pri_key, digest_bytes):
privkey = PrivateKey(pri_key, raw=True) # we expect to have a private key as bytes. unhexlify it before passing.
item = cls()
item.pub_key = privkey.pubkey.serialize()
item.digest_bytes = digest_bytes
sig_check = privkey.ecdsa_sign(digest_bytes, raw=True)
item.sig_ser = privkey.ecdsa_serialize(sig_check)
return item
def sign(self, msg):
"""
Sign a message with private key, Return signature
"""
priv = PrivateKey(self.key.private_byte, raw=True)
sig = priv.ecdsa_sign(msg)
h = priv.ecdsa_serialize_compact(sig)
return self.key.public_hex, encoding.to_hexstring(h)
def sign_message(pri_key, message):
privkey = PrivateKey(
pri_key, raw=True
) # we expect to have a private key as bytes. unhexlify it before passing.
sig_check = privkey.ecdsa_sign(MESSAGE_TEMPLATE.format(message))
sig_ser, recid = privkey.ecdsa_recoverable_serialize(sig_check)
return (sig_ser, recid)
def sign_message(cls, pri_key, message):
# we expect to have a private key as bytes. unhexlify it before passing
privkey = PrivateKey(pri_key, raw=True)
item = cls()
message = VarInt(len(message)).encode() + message
item.pub_key = privkey.pubkey.serialize()
# item.digest_bytes = digest_bytes
sig_check = privkey.ecdsa_sign(MESSAGE_TEMPLATE % message)
item.sig_ser = privkey.ecdsa_serialize(sig_check)
return item
def sign_message(cls, pri_key, message):
privkey = PrivateKey(
pri_key, raw=True
) # we expect to have a private key as bytes. unhexlify it before passing.
item = cls()
item.pub_key = privkey.pubkey.serialize()
item.digest_bytes = digest_bytes
sig_check = privkey.ecdsa_sign(MESSAGE_TEMPLATE.format(message))
item.sig_ser = privkey.ecdsa_serialize(sig_check)
return item
class TmpSigner:
def __init__(self, data=None, raw=True):
self._private_key = PrivateKey(data, raw)
def sign(self, msg_hash):
signature = self._private_key.ecdsa_sign(msg_hash, raw=True)
return self._private_key.ecdsa_serialize(signature)
@property
def public_key(self):
return self._private_key.pubkey.serialize(compressed=False)
def sign(t, p_smh, root_t):
with open('server_crypto') as f:
content = f.readlines()
content = [x.strip() for x in content]
priv = content[0]
pub = content[1].split(': ')[1]
privkey = PrivateKey(bytes(bytearray.fromhex(priv)), raw=True)
msg = t + p_smh + root_t
sig = privkey.ecdsa_sign(msg)
sig_der = privkey.ecdsa_serialize(sig)
return sig_der
def _sign(self) -> str:
message_str = json.dumps(self._get_sign_message(),
separators=(",", ":"),
sort_keys=True)
message_bytes = message_str.encode("utf-8")
privkey = PrivateKey(bytes.fromhex(self.privkey))
signature = privkey.ecdsa_sign(message_bytes)
signature_compact = privkey.ecdsa_serialize_compact(signature)
signature_base64_str = base64.b64encode(signature_compact).decode(
"utf-8")
return signature_base64_str
def _test_signature(public_key, private_key, msg):
print('uncompressed pub key %i bytes: %s' %
(len(public_key), public_key.hex()))
comp_pubkey = Key.from_sec(public_key)
print('compressed pub key: %s' %
comp_pubkey.sec_as_hex(use_uncompressed=False))
secp_pubkey = PublicKey(public_key, raw=True)
secp_privkey = PrivateKey(private_key, raw=True)
print('checking signature')
signature = secp_privkey.ecdsa_sign(msg)
if (secp_pubkey.ecdsa_verify(msg, signature)):
print('signature OK')
else:
raise Exception('signature test failed')
def generate_sig(secret, hash_digest):
"""
Given a secret (privkey) scalar and hash_digets,
returns a valid signature (64-bytes compact)
inputs:
privkey: a hex-string private key scalar
hash_digest: a hex-string hash message to sign
returns: 64-byte compact ecdsa sig
"""
privkey = PrivateKey(bytes(bytearray.fromhex(secret)), raw=True)
sig = privkey.ecdsa_sign(bytes(bytearray.fromhex(hash_digest)), raw=True)
return privkey.ecdsa_serialize_compact(sig)
def getDeployedSecret(dongle, masterPrivate, targetid):
testMaster = PrivateKey(bytes(masterPrivate))
testMasterPublic = bytearray(testMaster.pubkey.serialize(compressed=False))
targetid = bytearray(struct.pack('>I', targetid))
# identify
apdu = bytearray([0xe0, 0x04, 0x00, 0x00]) + bytearray([len(targetid)]) + targetid
dongle.exchange(apdu)
# walk the chain
batch_info = bytearray(dongle.exchange(bytearray.fromhex('E050000000')))
cardKey = batch_info[5:5 + batch_info[4]]
# if not found, get another pair
#if cardKey <> testMasterPublic:
# raise Exception("Invalid batch public key")
# provide the ephemeral certificate
ephemeralPrivate = PrivateKey()
ephemeralPublic = bytearray(ephemeralPrivate.pubkey.serialize(compressed=False))
print "Using ephemeral key " + str(ephemeralPublic).encode('hex')
signature = testMaster.ecdsa_sign(bytes(ephemeralPublic))
signature = testMaster.ecdsa_serialize(signature)
certificate = bytearray([len(ephemeralPublic)]) + ephemeralPublic + bytearray([len(signature)]) + signature
apdu = bytearray([0xE0, 0x51, 0x00, 0x00]) + bytearray([len(certificate)]) + certificate
dongle.exchange(apdu)
# walk the device certificates to retrieve the public key to use for authentication
index = 0
last_pub_key = PublicKey(bytes(testMasterPublic), raw=True)
while True:
certificate = bytearray(dongle.exchange(bytearray.fromhex('E052000000')))
if len(certificate) == 0:
break
certificatePublic = certificate[1 : 1 + certificate[0]]
certificateSignature = last_pub_key.ecdsa_deserialize(bytes(certificate[2 + certificate[0] :]))
if not last_pub_key.ecdsa_verify(bytes(certificatePublic), certificateSignature):
if index == 0:
# Not an error if loading from user key
print "Broken certificate chain - loading from user key"
else:
raise Exception("Broken certificate chain")
last_pub_key = PublicKey(bytes(certificatePublic), raw=True)
index = index + 1
# Commit device ECDH channel
dongle.exchange(bytearray.fromhex('E053000000'))
secret = last_pub_key.ecdh(bytes(ephemeralPrivate.serialize().decode('hex')))
return str(secret[0:16])
class Wallet(BaseWallet):
HD_PATH = "44'/714'/0'/0/0"
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)
@classmethod
def create_random_wallet(
cls,
language: MnemonicLanguage = MnemonicLanguage.ENGLISH,
env: Optional[BinanceEnvironment] = None):
"""Create wallet with random mnemonic code
:return:
"""
m = Mnemonic(language.value)
phrase = m.generate()
return cls.create_wallet_from_mnemonic(phrase, env=env)
@classmethod
def create_wallet_from_mnemonic(cls,
mnemonic: str,
env: Optional[BinanceEnvironment] = None):
"""Create wallet with random mnemonic code
:return:
"""
seed = Mnemonic.to_seed(mnemonic)
parent_wallet = network.keys.bip32_seed(seed)
child_wallet = parent_wallet.subkey_for_path(Wallet.HD_PATH)
# convert secret exponent (private key) int to hex
key_hex = format(child_wallet.secret_exponent(), 'x')
return cls(key_hex, env=env)
@property
def private_key(self):
return self._private_key
def sign_message(self, msg_bytes):
# check if ledger wallet
sig = self._pk.ecdsa_sign(msg_bytes)
return self._pk.ecdsa_serialize_compact(sig)
def filecoin_sign(ft, pri_key, pub_key):
digest_cbor = hashlib.blake2b(digest_size=32,
key=b"",
salt=b"",
person=b"")
digest_cbor.update(ft.cbor_serial())
digest_sign = hashlib.blake2b(digest_size=32,
key=b"",
salt=b"",
person=b"")
digest_sign.update(cid_prefix.__add__(digest_cbor.digest()))
tx_decode = binascii.hexlify(digest_sign.digest()).decode()
privkey = PrivateKey(bytes(bytearray.fromhex(pri_key)), raw=True)
sig_check = privkey.ecdsa_sign(bytes(bytearray.fromhex(tx_decode)),
raw=True)
sig_ser = privkey.ecdsa_serialize(sig_check)
sign_str = sig_ser.hex()
v, r, s = get_signature(sign_str, tx_decode, pub_key)
sign_str_h = handle_vrs(v, r, s)
sign_msg = ft.signed_tx(sign_str_h)
return sign_msg
raise Exception("Missing hex filename to sign")
if args.signedHex == None:
raise Exception("Missing output signed hex filename")
if args.sigAddr == None:
raise Exception("Missing signature start address")
# parse
parser = IntelHexParser(args.hex)
printer = IntelHexPrinter(parser)
# prepare data
dataToHash = ""
# consider areas are ordered by ascending address and non-overlaped
for a in parser.getAreas():
dataToHash += a.data
m = hashlib.sha256()
m.update(dataToHash)
dataToSign = m.digest()
print "Hash: " + dataToSign.encode('hex')
# sign
signKey = PrivateKey(bytes(bytearray.fromhex(args.key)))
sign = signKey.ecdsa_sign(bytes(dataToSign), raw=True)
sign = signKey.ecdsa_serialize(sign)
#append sign and print out
printer.addArea(args.sigAddr, sign + "FFFFFFFF".decode('hex'))
printer.writeTo(args.signedHex)
def sign_content(self, content):
"""签名消息"""
ecc_prikey = PrivateKey(bytes(bytearray.fromhex(self.__ecc_prikey)))
sign = ecc_prikey.ecdsa_sign(binascii.unhexlify(content))
readable_sign = binascii.hexlify(ecc_prikey.ecdsa_serialize(sign)).decode('utf-8')
return readable_sign
class Wallet(BaseWallet):
"""
Usage example:
m = Wallet.create_random_mnemonic() # 12 words
p = 'my secret passphrase' # bip39 passphrase
# Store <m> and <p> somewhere safe
wallet1 = Wallet.create_wallet_from_mnemonic(m, passphrase=p, child=0, env=testnet_env)
wallet2 = Wallet.create_wallet_from_mnemonic(m, passphrase=p, child=1, env=testnet_env)
...
"""
HD_PATH = "44'/714'/0'/0/{id}"
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)
@classmethod
def create_random_wallet(
cls,
language: MnemonicLanguage = MnemonicLanguage.ENGLISH,
env: Optional[BinanceEnvironment] = None):
"""Create wallet with random mnemonic code
:return: initialised Wallet
"""
phrase = cls.create_random_mnemonic(language)
return cls.create_wallet_from_mnemonic(phrase, env=env)
@classmethod
def create_wallet_from_mnemonic(cls,
mnemonic: str,
passphrase: Optional[str] = '',
child: Optional[int] = 0,
env: Optional[BinanceEnvironment] = None):
"""Create wallet from mnemonic, passphrase and child wallet id
:return: initialised Wallet
"""
if type(child) != int:
raise TypeError("Child wallet id should be of type int")
seed = Mnemonic.to_seed(mnemonic, passphrase)
new_wallet = network.keys.bip32_seed(seed)
child_wallet = new_wallet.subkey_for_path(Wallet.HD_PATH)
# convert secret exponent (private key) int to hex
key_hex = format(child_wallet.secret_exponent(), 'x')
return cls(key_hex, env=env)
@classmethod
def create_random_mnemonic(
cls, language: MnemonicLanguage = MnemonicLanguage.ENGLISH):
"""Create random mnemonic code
:return: str, mnemonic phrase
"""
m = Mnemonic(language.value)
phrase = m.generate()
return phrase
@property
def private_key(self):
return self._private_key
def sign_message(self, msg_bytes):
# check if ledger wallet
sig = self._pk.ecdsa_sign(msg_bytes)
return self._pk.ecdsa_serialize_compact(sig)
# GET Sign PK from Env
key=os.environ['VISIONLEDGER_SIGN']
privkey = PrivateKey(bytes(bytearray.fromhex(key)), raw=True)
print(str(privkey.pubkey.serialize(compressed=False).hex()))
f= open("signedList_VRC10.txt","w+")
f.write('ID,SIG,MESSAGE\n')
fJS= open("tokens10.js","w+")
fJS.write('var tokenList = [\n');
# VS
MESSAGE = b'VS' + b'VS' + bytes([6])
print(MESSAGE)
sig_check = privkey.ecdsa_sign(MESSAGE)
sig_ser = privkey.ecdsa_serialize(sig_check)
datab = bytes([(1<<3)+2]) + bytes([3]) + b'VS' +\
bytes([(2<<3)+0]) + bytes([6]) +\
bytes([(3<<3)+2]) + bytes([len(sig_ser)]) + sig_ser
print('RET:{},{},{}'.format('0',sig_ser.hex(), binascii.hexlify(datab).decode("utf-8") ))
f.write('{},{},{}\n'.format('0',sig_ser.hex(), binascii.hexlify(datab).decode("utf-8") ))
fJS.write("{{ id: {} , message: '{}'}},\n".format('0', binascii.hexlify(datab).decode("utf-8") ))
toread = 100
start = 0
IDField = 'id'
ItemsFields = 'assetIssue'
items = []
if args.signedHex == None:
raise Exception("Missing output signed hex filename")
if args.sigAddr == None:
raise Exception("Missing signature start address")
# parse
parser = IntelHexParser(args.hex)
printer = IntelHexPrinter(parser)
# prepare data
dataToHash = ""
# consider areas are ordered by ascending address and non-overlaped
for a in parser.getAreas():
dataToHash += a.data
m = hashlib.sha256()
m.update(dataToHash)
dataToSign = m.digest()
print "Hash: " + dataToSign.encode('hex')
# sign
signKey = PrivateKey(bytes(bytearray.fromhex(args.key)))
sign = signKey.ecdsa_sign(bytes(dataToSign), raw=True)
sign = signKey.ecdsa_serialize(sign)
#append sign and print out
printer.addArea(args.sigAddr, sign + "FFFFFFFF".decode('hex'))
printer.writeTo(args.signedHex)
