def create_demo_users():
"""create demo users"""
try:
store = JsonStore(default_path)
for name in demo_user_names:
# RSA keys
key = RSA.generate(default_key_size)
rsa_prikey = key.exportKey('PEM')
rsa_pubkey = key.publickey().exportKey('PEM')
readable_rsa_prikey = rsa_prikey.decode('utf-8')
readable_rsa_pubkey = rsa_pubkey.decode('utf-8')
# ECC keys
h = hash256(rsa_prikey)
ecc_prikey = PrivateKey(bytes(bytearray.fromhex(h)))
ecc_pubkey = ecc_prikey.pubkey
readable_ecc_prikey = ecc_prikey.serialize()
readable_ecc_pubkey = binascii.hexlify(
ecc_pubkey.serialize()).decode('utf-8')
# AES key & iv
h = hash256(binascii.unhexlify(ecc_prikey.serialize()))
aes_key = h[0:32]
aes_iv = h[32:]
# address
address = pubkey2address(readable_ecc_pubkey)
# save keys
store.put(name,
address=address,
rsa_prikey=readable_rsa_prikey,
rsa_pubkey=readable_rsa_pubkey,
ecc_prikey=readable_ecc_prikey,
ecc_pubkey=readable_ecc_pubkey,
aes_key=aes_key,
aes_iv=aes_iv)
except Exception as e:
print(str(e))
def get(self, request):
private_key = PrivateKey()
private_key_hex = private_key.serialize()
public_key_hex = private_key.pubkey.serialize().hex()
result = {
'private_key': private_key_hex,
'public_key': public_key_hex,
}
return JsonResponse(result)
def test_new_character_creation(fx_test_client, fx_session):
privkey = PrivateKey()
fx_test_client.post('/login',
data={
'private_key': privkey.serialize(),
},
follow_redirects=True)
assert fx_session.query(Move).filter_by(
user_address=get_address(privkey.pubkey),
user_public_key=privkey.pubkey.serialize(compressed=True),
name='create_novice').first()
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 mk_signer_keys_addr():
if len(sys.argv) == 2:
path = sys.argv[1]
else:
path = os.path.join(sys.argv[1], "node" + sys.argv[2])
dump_path = os.path.join(path, "signer_privkey")
privkey = PrivateKey()
sec_key = privkey.serialize()
f = open(dump_path, "w")
f.write(sec_key)
f.close()
auth_path = os.path.join(sys.argv[1], "signer_authorities")
authority = encode_hex(privtopub(decode_hex(sec_key)))[2:]
auth_file = open(auth_path, "a")
auth_file.write(authority + "\n")
auth_file.close()
def proxyDeleteApp(dongle, args):
args.targetId = auto_int(args.targetId)
if args.appName == None:
raise Exception("Missing appName")
if args.targetId == None:
args.targetId = 0x31000002
if args.rootPrivateKey == None:
privateKey = PrivateKey()
publicKey = str(
privateKey.pubkey.serialize(compressed=False)).encode('hex')
print "Generated random root public key : " + publicKey
args.rootPrivateKey = privateKey.serialize().encode('ascii')
if args.deployLegacy:
secret = getDeployedSecretV1(dongle,
bytearray.fromhex(args.rootPrivateKey),
args.targetId)
else:
secret = getDeployedSecretV2(dongle,
bytearray.fromhex(args.rootPrivateKey),
args.targetId)
loader = HexLoader(dongle, 0xe0, True, secret)
loader.deleteApp(args.appName)
def main():
# Generate keypair which we will use for signing block header
privkey = PrivateKey()
pubkey = privkey.pubkey
print('Private key: {}'.format(privkey.serialize()))
print('Public key: {}'.format(pubkey.serialize().hex()))
# Execure Proof-of-Work for block header
# For sake of simplicity this example uses sha256d as PoW function
raw_header, signature = miner({
'version': 1,
'prev_block': "0000000000000000000000000000000000000000000000000000000000000000",
'merkle_root': "4e9a7450cf706f05c9f7cf6b6f4c4c267e911c0d8d5066df1da4deb318637fd3",
'timestamp': 1568015489,
'bits': 524287999,
'nonce': 0,
'miner_pubkey': pubkey.serialize().hex()
}, privkey)
mined_hash = sha256d(raw_header + signature)
mined_header = header_deserialize(raw_header)
print('Block hash:', mined_hash[::-1].hex())
print('Block nonce:', mined_header['nonce'])
# Validate Proof-of-Work
pow_validation = validate_target(mined_hash, mined_header['bits'])
print('PoW validation: {}'.format(pow_validation))
# Validate header signature
sighash = ripemd160(raw_header)
miner_pubkey = bytes(bytearray.fromhex(mined_header['miner_pubkey']))
header_signature = signature[::-1]
signature_validation = validate_signature(sighash, header_signature, miner_pubkey)
print('Signature validation: {}'.format(signature_validation))
import threading
from server import Endpoint, PingMsg, CrawlServer
from secp256k1 import PrivateKey
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
#read threadcount from args
threadcount = 1
if len(sys.argv) == 2:
threadcount = int(sys.argv[1])
#generate private key
k = PrivateKey(None)
with open("priv_key", 'w') as f:
f.write(k.serialize())
#init queue and fill it with bootstraps
q = queue.Queue()
qset = queue.Queue()
q.put(Endpoint(u'52.16.188.185', 30303, 30303, bytes.fromhex("a979fb575495b8d6db44f750317d0f4622bf4c2aa3365d6af7c284339968eef29b69ad0dce72a4d8db5ebb4968de0e3bec910127f134779fbcb0cb6d3331163c"))) #geth
q.put(Endpoint(u'13.93.211.84', 30303, 30303, bytes.fromhex("3f1d12044546b76342d59d4a05532c14b85aa669704bfe1f864fe079415aa2c02d743e03218e57a33fb94523adb54032871a6c51b2cc5514cb7c7e35b3ed0a99")))
q.put(Endpoint(u'191.235.84.50', 30303, 30303, bytes.fromhex("78de8a0916848093c73790ead81d1928bec737d565119932b98c6b100d944b7a95e94f847f689fc723399d2e31129d182f7ef3863f2b4c820abbf3ab2722344d")))
q.put(Endpoint(u'13.75.154.138', 30303, 30303, bytes.fromhex("158f8aab45f6d19c6cbf4a089c2670541a8da11978a2f90dbf6a502a4a3bab80d288afdbeb7ec0ef6d92de563767f3b1ea9e8e334ca711e9f8e2df5a0385e8e6")))
q.put(Endpoint(u'174.112.32.157', 30303, 30303, bytes.fromhex("e809c4a2fec7daed400e5e28564e23693b23b2cc5a019b612505631bbe7b9ccf709c1796d2a3d29ef2b045f210caf51e3c4f5b6d3587d43ad5d6397526fa6179"))) #parity
q.put(Endpoint(u'144.76.62.101', 30303, 30303, bytes.fromhex("2676755dd8477ad3beea32b4e5a144fa10444b70dfa3e05effb0fdfa75683ebd4f75709e1f8126cb5317c5a35cae823d503744e790a3a038ae5dd60f51ee9101"))) #pyethapp
#fill queue set also
for point in list(q.queue):
qset.put(point)
out = queue.Queue()
from secp256k1 import PrivateKey, PublicKey import binascii import sha3 N_ADDRESS_BYTES = 20 N_PUB_KEY_BYTES = 64 address = 0x6e5ab887860e199b91b92d81f418c95d9ffd32cb key = "40dad29726f7e1b56359d2f1cc5a5365cb105b410e1108b3da65c1d97bfe6f8e" # b = long_to_bytes(key) privkey = PrivateKey(bytes(bytearray.fromhex(key)), raw=True) privkey_der = privkey.serialize() assert privkey.deserialize(privkey_der) == privkey.private_key print "privkey", privkey.serialize() pubkey = privkey.pubkey pub = pubkey.serialize(compressed=False) print "pubkey", binascii.hexlify(pub[1:]) print "pubkey", sha3.keccak_256(pub[1:]).hexdigest()[-2 * N_ADDRESS_BYTES:]
from ledgerblue.deployed import getDeployedSecret
from ledgerblue.hexLoader import HexLoader
import argparse
def auto_int(x):
return int(x, 0)
parser = argparse.ArgumentParser()
parser.add_argument("--targetId", help="Set the chip target ID", type=auto_int)
parser.add_argument("--appName", help="Set the application name")
parser.add_argument("--rootPrivateKey", help="Set the root private key")
parser.add_argument("--apdu", help="Display APDU log", action='store_true')
args = parser.parse_args()
if args.appName == None:
raise Exception("Missing appName")
if args.targetId == None:
args.targetId = 0x31000001
if args.rootPrivateKey == None:
privateKey = PrivateKey()
publicKey = str(privateKey.pubkey.serialize(compressed=False)).encode('hex')
print "Generated random root public key : " + publicKey
args.rootPrivateKey = privateKey.serialize().encode('ascii')
dongle = getDongle(args.apdu)
secret = getDeployedSecret(dongle, bytearray.fromhex(args.rootPrivateKey), args.targetId)
loader = HexLoader(dongle, 0xe0, True, secret)
loader.deleteApp(args.appName)
from secp256k1 import PrivateKey
k = PrivateKey(None)
f = open("priv_key", 'w')
f.write(k.serialize())
f.close()
