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)