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)
