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(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 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_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 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])
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
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 = [] while (toread>0):
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
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)