def build_vectors(fips_vectors):
vectors = defaultdict(list)
for vector in fips_vectors:
vectors[vector['digest_algorithm']].append(vector['message'])
for digest_algorithm, messages in vectors.items():
if digest_algorithm not in HASHLIB_HASH_TYPES:
continue
yield ""
yield "[K-256,{0}]".format(digest_algorithm)
yield ""
for message in messages:
# Make a hash context
hash_func = TruncatedHash(HASHLIB_HASH_TYPES[digest_algorithm]())
# Sign the message using warner/ecdsa
secret_key = SigningKey.generate(curve=SECP256k1)
public_key = secret_key.get_verifying_key()
signature = secret_key.sign(message, hashfunc=hash_func,
sigencode=sigencode_der)
r, s = sigdecode_der(signature, None)
yield "Msg = {0}".format(hexlify(message))
yield "d = {0:x}".format(secret_key.privkey.secret_multiplier)
yield "Qx = {0:x}".format(public_key.pubkey.point.x())
yield "Qy = {0:x}".format(public_key.pubkey.point.y())
yield "R = {0:x}".format(r)
yield "S = {0:x}".format(s)
yield ""
def test():
priv = SigningKey.generate(curve=NIST384p)
pub = priv.get_verifying_key()
print "Private key generated:"
generatedKey = priv.to_pem()
print generatedKey
txt1 = "Dedication"
txt2 = "Do you have it?"
#K chosen by a fair roll of a 1d10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
sig1 = priv.sign(txt1, k=4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444)
print "Signature 1: " + str(sig1.encode('hex'))
sig2 = priv.sign(txt2, k=4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444)
print "Signature 2: " + str(sig2.encode('hex'))
print "Signature 1 verification: " + str(pub.verify(sig1, txt1))
print "Signature 2 verification: " + str(pub.verify(sig2, txt2))
key = recover_key(txt1, sig1, txt2, sig2, pub)
print "Private key recovered:"
print key
print "Equality of generated & recovered keys: " + str(generatedKey == key)
def gen_key(self, filename):
"""
Generate a new Signing key using NIST P-256 curve
"""
self.sk = SigningKey.generate(curve=NIST256p)
with open(filename, "w") as sk_file:
sk_file.write(self.sk.to_pem())
def generate_pri_key():
seed = get_seed()
rng1 = PRNG(seed)
sk = SigningKey.generate(entropy=rng1, curve=NIST256p)
sk_string = sk.to_string()
sk_string_hex = binascii.hexlify(sk_string)
return sk_string_hex, sk
def generate(curve):
if curve not in _policy_.keys():
return False
sk = SigningKey.generate(curve=_policy_[curve][0])
vk = sk.get_verifying_key()
pubKey = vk.to_der()
prvKey = sk.to_der()
return (pubKey, prvKey)
def setUpClass(cls):
log.info('Generating ECDSA Keypairs for Testing')
cls.sender_sk = SigningKey.generate(curve=curves.SECP256k1)
cls.receiver_sk = SigningKey.generate(curve=curves.SECP256k1)
log.info('Setup IdObj for testid')
cls.test_id_obj = IdObject()
cls.test_id_obj.auth_public_key = cls.receiver_sk.get_verifying_key().to_der().encode('hex')
cls.test_id_obj.id = 'testid'
cls.test_id_obj.paymentprotocol_only = True
cls.resolver = PluginManager.get_plugin('RESOLVER', config.resolver_type)
cls.resolver.save(cls.test_id_obj)
log.info('Save testid IdObj')
log.info('Setup Class Identifier')
cls.identifier = None
def __init__(self, blockchain, id, penalty=1, selfish=False):
self.blockchain = blockchain
self.keypair = SigningKey.generate()
self.id = id + 1
self.balances = []
self.balance = {}
self.penalty = penalty
self.selfish = selfish
if selfish:
self.selfishchain = Blockchain()
self.privchainlen = 0
def generate_key():
# 공개키, 개인키 생성
pri_key = SigningKey.generate(curve=NIST256p)
pub_key = pri_key.get_verifying_key()
# 생성된 공인키, 개인키를 파일로 생성
open(KEY_PATH + "/private.pem", "w",
encoding='utf-8').write(pri_key.to_pem().decode('utf-8'))
open(KEY_PATH + "/public.pem", "w",
encoding='utf-8').write(pub_key.to_pem().decode('utf-8'))
log.write("New Keys are generated")
def addrs():
keccak = sha3.keccak_256()
priv = SigningKey.generate(curve=SECP256k1)
pub = priv.get_verifying_key().to_string()
keccak.update(pub)
address = keccak.hexdigest()[24:]
RPriv = priv.to_string()
Fpriv = RPriv.encode('hex')
#Fpub = '0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB'
Fpub = checksum_encode(address)
return Fpub,Fpriv;
def generate_keypair(to_str=True):
'''
Generates a keypair for a user.
By design, this keypair is separate from the node itself, which ensures that multiple users can all use the same node.
'''
sk = SigningKey.generate() # this is the signing/secret key
vk = sk.get_verifying_key() # this is the public/verifying key
if to_str:
return (sk.to_string(), vk.to_string())
else:
return (sk, vk)
def generate(curve=curves.NIST256p, progress_func=None):
"""
Generate a new private ECDSA key. This factory function can be used to
generate a new host key or authentication key.
:param function progress_func: Not used for this type of key.
:returns: A new private key (`.ECDSAKey`) object
"""
signing_key = SigningKey.generate(curve)
key = ECDSAKey(vals=(signing_key, signing_key.get_verifying_key()))
return key
def instantwallet():
sk = SigningKey.generate(curve=SECP256k1)
vk = sk.get_verifying_key() #public_key
public_key = vk.to_string().hex()
private_key = sk.to_string().hex()
keys = []
wallet_id = generate_wallet_from_pkey(public_key)
keys.append(private_key)
keys.append(wallet_id)
keys.append(public_key)
return keys
def __init__(self): self.privatekey = SigningKey.generate() self.publickey = self.privatekey.get_verifying_key() self.blockhead = None self.maxnumtrans = 1000 self.database = [[0] * 2 for i in range(self.maxnumtrans)] self.top = 0 self.currentblock = block.block(None) self.blockhead = Treenode() self.genesis = Treenode() # height will be zero for genesis block self.leafhead = self.genesis # head of the list of leaves, points to an empty node initially
def main():
keccak = sha3.keccak_256()
priv = SigningKey.generate(curve=SECP256k1)
pub = priv.get_verifying_key().to_string()
keccak.update(pub)
address = keccak.hexdigest()[24:]
save_privkey(binascii.hexlify(priv.to_string()))
save_pubkey(binascii.hexlify(pub))
save_address(address)
def generate(curve=curves.NIST256p, progress_func=None):
"""
Generate a new private ECDSA key. This factory function can be used to
generate a new host key or authentication key.
:param function progress_func: Not used for this type of key.
:returns: A new private key (`.ECDSAKey`) object
"""
signing_key = SigningKey.generate(curve)
key = ECDSAKey(vals=(signing_key, signing_key.get_verifying_key()))
return key
def test_ecdh_derive_shared_secret_random():
# Generate random keys for the two participating users
aliceSecretKey = SigningKey.generate(curve=NIST256p)
alice = ECDH(curve=NIST256p)
alice.load_private_key(aliceSecretKey)
alicePublicKey = alice.get_public_key()
bobSecretKey = SigningKey.generate(curve=NIST256p)
bob = ECDH(curve=NIST256p)
bob.load_private_key(bobSecretKey)
bobPublicKey = bob.get_public_key()
# Each user derives the same shared secret, independantly, using the other's public key which is exchanged
aliceSecret = derive_shared_secret_from_key(aliceSecretKey, bobPublicKey)
print("Alice secret: ", aliceSecret.hex())
bobSecret = derive_shared_secret_from_key(bobSecretKey, alicePublicKey)
print("Bob secret: ", bobSecret.hex())
assert aliceSecret == bobSecret, "Both parties should generate the same secret"
def __init__(self,
walletFileLocation,
initWallet=False,
walletName='default'):
if initWallet:
self.privKey = SigningKey.generate()
self.pubKey = self.privKey.verifying_key
self.walletName = walletName
self.dump_wallet(walletFileLocation)
else:
self.load_wallet(walletFileLocation)
def generate_eth_wallet():
from ecdsa import SigningKey, SECP256k1
privkey = SigningKey.generate(curve=SECP256k1)
public = privkey.get_verifying_key().to_string()
import sha3
keccak = sha3.keccak_256()
keccak.update(public)
address = keccak.hexdigest()[24:]
return {"address": f"0x{address}", "privkey": privkey.to_string().hex()}
def create_eth_address():
keccak = sha3.keccak_256()
priv = SigningKey.generate(curve=SECP256k1)
pub = priv.get_verifying_key().to_string()
keccak.update(pub)
address = keccak.hexdigest()[24:]
return {'private_key': priv.to_string().hex(),
'public_key': pub.hex(),
'address': checksum_encode(address)}
def setUpClass(cls):
log.info('Generating ECDSA Keypairs for Testing')
cls.sender_sk = SigningKey.generate(curve=curves.SECP256k1)
cls.receiver_sk = SigningKey.generate(curve=curves.SECP256k1)
log.info('Setup IdObj for testid')
cls.test_id_obj = IdObject()
cls.test_id_obj.auth_public_key = cls.receiver_sk.get_verifying_key(
).to_der().encode('hex')
cls.test_id_obj.id = 'testid'
cls.test_id_obj.paymentprotocol_only = True
cls.resolver = PluginManager.get_plugin('RESOLVER',
config.resolver_type)
cls.resolver.save(cls.test_id_obj)
log.info('Save testid IdObj')
log.info('Setup Class Identifier')
cls.identifier = None
def genETHAddr():
keccak = sha3.keccak_256()
priv = SigningKey.generate(curve=SECP256k1)
pub = priv.get_verifying_key().to_string()
keccak.update(pub)
address = keccak.hexdigest()[24:]
g_logger.info("Private key: %s" % priv.to_string().hex())
g_logger.info("Public key: %s" % pub.hex())
g_logger.info("Address: 0x%s" % address)
def create_key(dir):
#Generating Alice's private
if (os.path.isdir(dir) == False):
os.mkdir(dir)
sk = SigningKey.generate(curve=SECP256k1)
vk = sk.verifying_key
sha3_key = hashlib.sha3_256()
sha3_key.update(vk.to_string())
hash = sha3_key.digest()
with open(os.path.join(dir, uuid.uuid4().hex), "wb") as f:
f.write(sk.to_pem())
return hash, sk
def __init__(self, private_key: str = None, public_key: str = None):
if private_key is None:
self.private_key = SigningKey.generate(curve=SECP256k1)
else:
self.private_key = SigningKey.from_string(
bytes.fromhex(private_key), curve=SECP256k1)
if public_key is None:
self.public_key = self.private_key.get_verifying_key()
else:
self.public_key = VerifyingKey.from_string(
bytes.fromhex(public_key), curve=SECP256k1)
def generate_key():
# 공개키, 개인키 생성
pri_key = SigningKey.generate(curve=NIST256p)
pub_key = pri_key.get_verifying_key()
# 생성된 공인키 개인키를 파일로 생성
open(PRI_KEY_PATH, "w",
encoding='utf-8').write(pri_key.to_pem().decode('utf-8'))
open(PUB_KEY_PATH, "w",
encoding='utf-8').write(pub_key.to_pem().decode('utf-8'))
return pri_key, pub_key
def generate_keys():
try:
# uses NIST192p as the curve
private_key = SigningKey.generate()
public_key = private_key.verifying_key
private_key_string = private_key.to_string().hex()
public_key_string = public_key.to_string().hex()
return private_key_string, public_key_string
except Exception as e:
capture_exception(e)
def new_wallet():
keccak = sha3.keccak_256()
priv = SigningKey.generate(curve=SECP256k1)
pub = priv.get_verifying_key().to_string()
keccak.update(pub)
address = keccak.hexdigest()[24:]
privkey = priv.to_string().hex()
pubkey = pub.hex()
addr = checksum_encode(address)
data = [{'privkey': privkey, 'pubkey': pubkey, 'addr': addr}]
data_string = json.dumps(data)
return data_string
def generate_keypair(self):
""" Generate a ECDSA keypair """
# Private key generation
self.priv_key = SigningKey.generate(curve=self._key_curve)
priv_key_pem = self.priv_key.to_pem()
# Public Key name is the hash of the public key
self.pub_key = self.priv_key.get_verifying_key()
pub_key_pem = self.pub_key.to_pem()
return priv_key_pem, pub_key_pem
def get_new_ring_keys(ring_size: int, j: int):
keys = []
# Generate a bunch of keys
for i in range(ring_size):
k = SigningKey.generate(curve=ecdsa.SECP256k1)
if i == j:
keys.append((k.privkey.secret_multiplier,
k.get_verifying_key().pubkey.point))
else:
keys.append((None, k.get_verifying_key().pubkey.point))
return keys
def __init__(self, signing_key=None):
self.signing_key = signing_key or SigningKey.generate(curve=NIST256p)
pk_point = self.signing_key.verifying_key.pubkey.point
self.proof_field = {
'use': 'sig',
'alg': 'ES256',
'kty': 'EC',
'crv': 'P-256',
'x': self.__encode_ec_coord(pk_point.x()),
'y': self.__encode_ec_coord(pk_point.y())
}
def generate_keys():
""" Gets a new elliptic curve key pair using the SECP256K1 elliptic curve (the one used by Bitcoin).
:return: elliptic curve key pair.
:rtype: list
"""
# Generate the key pair from a SECP256K1 elliptic curve.
sk = SigningKey.generate(curve=SECP256k1)
pk = sk.get_verifying_key()
return sk, pk
def generate_new_key_pair():
# Private key
signing_key = SigningKey.generate(
curve=SECP256k1,
hashfunc=sha256,
)
# Public key
verifying_key = signing_key.get_verifying_key()
return signing_key, verifying_key
def generate_privateKey() -> bytes:
'''
Create a random number(32 bytes) as private key.
Returns
-------
bytes
The private key in 32 bytes format.
'''
while True:
_a = SigningKey.generate(curve=SECP256k1)
if _is_valid_private_key(_a.to_string()):
return _a.to_string()
def generate_key(self):
"""
create keypair, program_id and jid
"""
signingkey = SigningKey.generate(curve=NIST256p)
sk_text = "private-jid0-%s" % my_b32encode(signingkey.to_string())
verifyingkey = signingkey.get_verifying_key()
vk_text = "public-jid0-%s" % my_b32encode(verifyingkey.to_string())
self.jid = vk_to_jid(verifyingkey)
self.program_id = jid_to_programid(self.jid)
self.private_key = sk_text
self.public_key = vk_text
def generate_legal_key():
"""
Ensure that we don't have 0xFFFF in the hash of the public key of
the generated keypair.
:return: A key who's SHA256 digest does not contain 0xFFFF
"""
while True:
key = SigningKey.generate(curve=NIST256p)
digest = sha256(key.get_verifying_key().to_string()).digest()[:16]
if not (any([digest[n:n + 2] == b'\xff\xff'
for n in range(0, len(digest), 2)])):
return key
def generate_wallet() -> Dict[str, str]:
keccak = sha3.keccak_256()
priv = SigningKey.generate(curve=SECP256k1)
pub = priv.get_verifying_key().to_string()
keccak.update(pub)
address = keccak.hexdigest()[24:]
wallet = {
'private': priv.to_string().hex(),
'public': pub.hex(),
'address': w3.toChecksumAddress(address),
}
return wallet
def get_signing_key():
if not os.path.exists(private):
print('Creating private key %r' % private)
sk0 = SigningKey.generate(curve=curve)
with open(private, 'w') as f:
f.write(sk0.to_pem())
vk = sk0.get_verifying_key()
with open(public, 'w') as f:
f.write(vk.to_pem())
pem = open(private).read()
sk = SigningKey.from_pem(pem)
return sk
def __init__(self, key=None): self.secretKey = self.verifKey = None # Recuperation if key is not None: self.secretKey = SigningKey.from_string(key, curve=NIST384p) # Auto-generation else: self.secretKey = SigningKey.generate(curve=NIST384p) self.verifKey = self.secretKey.get_verifying_key()
def generateKeys():
# SECP256k1 is the Bitcoin elliptic curve
private_key = SigningKey.generate(curve=SECP256k1)
public_key = private_key.get_verifying_key()
file_out = open("private.pem", "wb")
file_out.write(private_key.to_pem())
file_out = open("public.pem", "wb")
file_out.write(public_key.to_pem())
print(base64.b64encode(private_key.to_string()))
print(str(base64.b64encode(public_key.to_string()), "utf-8"))
def generate_edsca_hexkeypair() -> HexKeyPair:
"""
Generates an EDSCA public private key pair.
The values are returned as strings for easy
serialization.
:return: A HexKeyPair tuple
"""
private = SigningKey.generate(curve=ECDSA_CURVE)
public = private.get_verifying_key()
private_string = (private.to_string()).hex()
public_string = (public.to_string()).hex()
return _hexkeypair(public_string, private_string)
def __init__(self, signing_key=None, signing_policy=None):
self.signing_key = signing_key or SigningKey.generate(curve=NIST256p)
self.signing_policy = signing_policy or DEFAULT_SIGNING_POLICY
pk_point = self.signing_key.verifying_key.pubkey.point
self.proof_field = {
"use": "sig",
"alg": self.signing_policy.supported_algorithms[0],
"kty": "EC",
"crv": "P-256",
"x": self.__encode_ec_coord(pk_point.x()),
"y": self.__encode_ec_coord(pk_point.y()),
}
def generate(curve=curves.NIST256p, progress_func=None):
"""
Generate a new private RSA key. This factory function can be used to
generate a new host key or authentication key.
:param function progress_func:
an optional function to call at key points in key generation (used
by ``pyCrypto.PublicKey``).
:returns: A new private key (`.RSAKey`) object
"""
signing_key = SigningKey.generate(curve)
key = ECDSAKey(vals=(signing_key, signing_key.get_verifying_key()))
return key
def generate_ECC_key(args):
'''
Generate an ECC keypair in PEM format
'''
from ecdsa import SigningKey
curve = getattr(__import__('ecdsa'), args.curve)
private_key = SigningKey.generate(curve=curve)
public_key = private_key.get_verifying_key()
with open('privateEC.pem', 'wb') as key_file:
key_file.write(private_key.to_pem())
with open('publicEC.pem', 'wb') as key_file:
key_file.write(public_key.to_pem())
def generate_key(self): """ create keypair, program_id and jid """ from ecdsa import SigningKey, NIST256p from cuddlefish.preflight import vk_to_jid, jid_to_programid, my_b32encode sk = SigningKey.generate(curve=NIST256p) sk_text = "private-jid0-%s" % my_b32encode(sk.to_string()) vk = sk.get_verifying_key() vk_text = "public-jid0-%s" % my_b32encode(vk.to_string()) self.jid = vk_to_jid(vk) self.program_id = jid_to_programid(self.jid) self.private_key = sk_text self.public_key = vk_text
def generateMN(self, nums):
global_list = {}
for i in range(nums):
utxoamount = 123
hashrate = 11.23
externalip = '192.168.1.7' + str(i)
g_ListIP[i] = externalip
#privkey = '121A23AFF0B9440C3BA4C7CA6E424DB7BD85FEC5F33010DDD96BEE45B4DBF482'
if USE_ECDSA == 1:
privkey = SigningKey.generate()
else:
privkey = get_random_str(64) # modi by zheng
txid = ''.join(random.choice('0123456789abcdef') for _ in range(32))
uptime = time.time() - random.randint(0, 100000)
global_list[txid] = ListNode(utxoamount, hashrate, externalip, privkey, txid, uptime)
return global_list
def generate_new_key_pair():
"""
Generate a new key pair.
Returns:
tuple(:py:class:`ecdsa.keys.SigningKey`,
:py:class:`ecdsa.keys.VerifyingKey`):
key pair (private, public).
"""
private_key = SigningKey.generate(
curve=SECP256k1,
hashfunc=sha256,
)
return private_key, private_key.get_verifying_key()
def main(args):
message = "Hello, P2PSP!" * 1024
sk = SigningKey.generate()
vk = sk.get_verifying_key()
# measure the sign time
start_time = time.time()
for _ in xrange(N):
sig = sign(message, sk)
print "key.sign x{0} times: {1}s".format(N, time.time() - start_time)
#measure the verify time
sig = sign(message, sk)
start_time = time.time()
for _ in xrange(N):
r = check(message, vk, sig)
print "key.verify x{0} times: {1}s".format(N, time.time() - start_time)
def generate(curve=curves.NIST256p, progress_func=None):
"""
Generate a new private RSA key. This factory function can be used to
generate a new host key or authentication key.
@param bits: number of bits the generated key should be.
@type bits: int
@param progress_func: an optional function to call at key points in
key generation (used by C{pyCrypto.PublicKey}).
@type progress_func: function
@return: new private key
@rtype: L{RSAKey}
"""
signing_key = SigningKey.generate(curve)
key = ECDSAKey(vals=(signing_key, signing_key.get_verifying_key()))
return key
def new(cls, string=None):
"""Returns a new Address object.
If a string is passed, the Address object will be
created using that string and will be deterministic.
If no string is passed, the Address object will
be generated randomly.
"""
# Generates warner ECDSA objects
if string:
# deterministic private key
ecdsaPrivkey = SigningKey.from_string(
string=string, curve=SECP256k1)
else:
# random private key
ecdsaPrivkey = SigningKey.generate(
curve=SECP256k1, entropy=None)
return cls.fromPrivkey(ecdsaPrivkey)
def create_key(keydir, name):
# return jid
from ecdsa import SigningKey, NIST256p
sk = SigningKey.generate(curve=NIST256p)
sk_text = "private-jid0-%s" % my_b32encode(sk.to_string())
vk = sk.get_verifying_key()
vk_text = "public-jid0-%s" % my_b32encode(vk.to_string())
jid = vk_to_jid(vk)
program_id = jid + "@jetpack"
# save privkey to ~/.jetpack-keys/$jid
f = open(os.path.join(keydir, jid), "w")
f.write("private-key: %s\n" % sk_text)
f.write("public-key: %s\n" % vk_text)
f.write("jid: %s\n" % jid)
f.write("program-id: %s\n" % program_id)
f.write("name: %s\n" % name)
f.close()
return jid
def __init__(self, public_key=None, private_key=None):
self.id = 0
if public_key is not None:
public_key = "#" + public_key
if private_key is not None:
private_key = "#" + private_key
self.public_key = auto_bytes(public_key)
self.private_key = private_key
self.addr_version = None
self.use_compression = 1
if private_key == "":
private_key = None
#Generate key pairs.
if self.public_key == None and private_key == None:
self.sign_key = SigningKey.generate(curve=SECP256k1)
self.verify_key = self.sign_key.get_verifying_key()
self.private_key = self.sign_key.to_string()
self.public_key = self.verify_key.to_string()
return
#Init public key.
self.old_verify_str = None
if self.public_key != None:
self.public_key = self.parse_public_key(self.public_key)
self.verify_key = VerifyingKey.from_string(self.public_key, SECP256k1)
self.sign_key = None
self.old_verify_str = self.verify_key.to_string()
#Init private key.
if self.private_key != None:
#Construct keys from private key.
self.private_key = self.parse_private_key(private_key)
self.sign_key = SigningKey.from_string(self.private_key, SECP256k1)
self.verify_key = self.sign_key.get_verifying_key()
#Check private key corrosponds to public key.
if self.old_verify_str != None:
if self.old_verify_str != self.verify_key.to_string():
raise Exception("Private key doesn't corrospond to stored public key.")
def setUp(self):
# Generate a signing key used for refund output retrieval in get_refund_addresses()
self.receiver_sk = SigningKey.generate(curve=curves.SECP256k1)
log.info('Setup IdObj for testid')
self.test_id_obj = IdObject()
self.test_id_obj.id = 'testid'
self.test_id_obj.bip70_enabled = True
self.test_id_obj.wallet_address = '1MSK1PMnDZN4SLDQ6gB4c6GKRExfGD6Gb3'
self.test_id_obj.x509_cert = TEST_CERT
self.test_id_obj.private_key = TEST_CERT_PRIVKEY
self.test_id_obj.auth_public_key = self.receiver_sk.get_verifying_key().to_string().encode('hex')
self.resolver = PluginManager.get_plugin('RESOLVER', config.resolver_type)
self.resolver.save(self.test_id_obj)
log.info('Save testid IdObj')
# Keep track of PaymentRequest meta data stored in Redis so it can be cleaned up later
self.redis_pr_store_cleanup = []
def generate(currency='btc', secret=None, compressed=False):
"""Generate address pair for currency. (Default: BTC)
:currency: string, 3 letter currency code
:secret: string, seed for private address
:compressed: bool, if key pair is on compresses format or not
:returns: tuple, (private_key, public_key) containing representation in hex and base58 format.
"""
from ecdsa import SigningKey, SECP256k1
if secret:
h = hashlib.sha256(secret).hexdigest()
secret_exp = int(h, 16)
sk = SigningKey.from_secret_exponent(secret_exp, curve=SECP256k1)
else:
sk = SigningKey.generate(curve=SECP256k1)
priv = sk.to_string()
pub = sk.get_verifying_key()
if compressed:
priv = priv + '\x01'
if pub.pubkey.point.y() % 2:
prefix = '\x03'
else:
prefix = '\x02'
pub = prefix + pub.to_string()[0:32]
else:
pub = '\x04' + pub.to_string()
priv_hex = priv.encode('hex')
priv_b58 = from_hash160(priv_hex, typ='priv', currency=currency)
pub_hex = sha256hash160(pub).encode('hex')
pub_b58 = from_hash160(pub_hex, currency=currency)
return Key(hex=priv_hex, b58=priv_b58), Key(hex=pub_hex, b58=pub_b58)
def identityCreation():
print art
print "\nIdentity Creation Script - Block SSL\n"
keybaseCheck()
ans1 = raw_input("Do you own a Keybase.io account? [Y]es [N]o, default: [Y]\n")
if ans1 == "Y" or ans1 == "y" or ans1 == "" or ans1 == " ":
os.system("keybase version") #check for keybase version
print "Checking for Updates...\n"
os.system("echo 3 | keybase update check >/dev/null 2>&1") #check for keybase updates without terminal output
os.system("keybase login") #login to keybase through terminal
else:
os.system("keybase version")
print "Checking for Updates...\n"
os.system('echo 3 | keybase update check >/dev/null 2>&1')
os.system("keybase signup") #signup to keybase through terminal
keccak = sha3.keccak_256()
ex = raw_input("Do you already own an Ethereum address that you want to use? [Y]es [N]o, default: [Y]")
if ex == "Y" or ex == "y" or ex == "" or ex == " ":
gen_priv = raw_input("Which is your private key? (in hexadecimal format)\n") #Private Key of the owner
gen_priv = BitcoinPrivateKey(gen_priv)
print "Saving to Generation_Private.pem file..."
open("Generation_Private.pem", "w").write(gen_priv.to_pem()) #Saving to file
print "Generating \"Generation\" Public Key..."
gen_pub = gen_priv.get_verifying_key() #Generate the "Generation" public key from gen_priv
print "Saving to Generation_Public.pem file..."
open("Generation_Public.pem", "w").write(gen_pub.to_pem()) #Saving to file
print "Public/Private key pair creation:"
print "Warning: This is a pseudo-random generation."
print "Warning: If you want complete randomness consider other ways of Public/Private key pair generation."
gen_pub = gen_pub.to_string()
keccak.update(gen_pub)
gen_address = keccak.hexdigest()[24:]
open("Gen_Address.txt", "w").write("0x" + gen_address)
else:
print "Public/Private key pair creation:"
print "Warning: This is a pseudo-random generation."
print "Warning: If you want complete randomness consider other ways of Public/Private key pair generation.\n"
print "Generating \"Generation\" Private Key..."
gen_priv = SigningKey.generate(curve=SECP256k1) #Generate the "Generation" private key
print "Saving to Generation_Private.pem file..."
open("Generation_Private.pem", "w").write(gen_priv.to_pem()) #Saving to file
print "Generating \"Generation\" Public Key..."
gen_pub = gen_priv.get_verifying_key() #Generate the "Generation" public key from gen_priv
print "Saving to Generation_Public.pem file..."
open("Generation_Public.pem", "w").write(gen_pub.to_pem()) #Saving to file
gen_pub = gen_pub.to_string()
keccak.update(gen_pub)
gen_address = keccak.hexdigest()[24:]
open("Gen_Address.txt", "w").write("0x" + gen_address)
print "Generating \"Certificate\" Private Key..."
cert_priv = SigningKey.generate(curve=SECP256k1) #Generate the "Certificate" private key
print "Saving to Certificate_Private.pem file..."
open("Certificate_Private.pem", "w").write(cert_priv.to_pem()) #Saving to file
print "Generating \"Certificate\" Public Key..."
cert_pub = cert_priv.get_verifying_key() #Generate the "Certificate" public key from cert_priv
print "Saving to Certificate_Public.pem file..."
open("Certificate_Public.pem", "w").write(cert_pub.to_pem()) #Saving to file
cert_pub = cert_pub.to_string()
keccak.update(cert_pub)
cert_address = keccak.hexdigest()[24:]
open("Cert_Address.txt", "w").write("0x" + cert_address)
print "Generating \"Revocation\" Private Key..."
rev_priv = SigningKey.generate(curve=SECP256k1) #Generate the "Revocation" private key
print "Saving to Revocation_Private.pem file..."
open("Revocation_Private.pem", "w").write(rev_priv.to_pem()) #Saving to file
print "Generating \"Revocation\" Public Key..."
rev_pub = rev_priv.get_verifying_key() #Generate the "Revocation" public key from rev_priv
print "Saving to Revocation_Public.pem file..."
open("Revocation_Public.pem", "w").write(rev_pub.to_pem()) #Saving to file
rev_pub = rev_pub.to_string()
keccak.update(rev_pub)
rev_address = keccak.hexdigest()[24:]
open("Rev_Address.txt", "w").write("0x" + rev_address)
print "\nYour addresses are:"
print "\nGeneration Address: 0x" + gen_address
print "\nCertificate Address: 0x" + cert_address
print "\nRevocation Address: 0x" + rev_address
os.system("echo 3 | keybase currency add --force " + cert_address + " >/dev/null 2>&1") #add cert address to keybase account - (todo)
print "\nCertificate address added to your keybase.io account.\n"
print "\nPlease load your Generation and Revocation addresses with some ether."
print "\nWarning: Please keep your Revocation address secret!"
ans = raw_input("Do you want to encrypt your private key files? [Y]es [N]o, default: [Y]")
if ans == "Y" or ans == "y" or ans == "" or ans == " ":
password = getpass.getpass("Give a strong password: "******"Generation_Private.pem")
os.remove("Generation_Private.pem")
encrypt_file(key, "Certificate_Private.pem")
os.remove("Certificate_Private.pem")
encrypt_file(key, "Revocation_Private.pem")
os.remove("Revocation_Private.pem")
sys.exit()
else:
sys.exit()
from ecdsa import SigningKey, NIST384p, VerifyingKey, BadSignatureError
from ecdsa.util import randrange_from_seed__trytryagain, PRNG
import os
# sk = SigningKey.generate() -> uses NIST192p
sk = SigningKey.generate(curve=NIST384p)
vk = sk.get_verifying_key()
signature = sk.sign(b"MANAN PAL")
print(vk.verify(signature, b"MANAN PAL"))
print(sk.to_string())
sk_pem = sk.to_pem()
vk_pem = vk.to_pem()
'''
def make_key(seed):
secexp = randrange_from_seed__trytryagain(seed, NIST384p.order)
return SigningKey.from_secret_exponent(secexp, curve=NIST384p)
seed = os.urandom(NIST384p.baselen) # or other starting point
sk1a = make_key(seed)
sk1b = make_key(seed)
# note: sk1a and sk1b are the same key
sk2 = make_key(b"2-"+seed) # different key
'''
'''
#entropy (produces a strong pseudo-random stream)
rng1 = PRNG("seed")
sk1 = SigningKey.generate(entropy=rng1)
def gen_private_ecdsa():
from ecdsa import SigningKey
sk = SigningKey.generate()
return sk.to_pem()
def test():
initialise_database('test_database_file')
private_keys = [SigningKey.generate() for _ in range(3)]
public_keys = [PublicKey.from_signing_key(private_key) for private_key in private_keys]
uuids = [uuid4() for _ in range(3)]
# BUILD
# blocks = add_blocks()
#
# for block in blocks:
# block.put()
#
# block_chain = BlockChain()
#
# block_chain_records_pattern = [
# BlockChain.Record(1, b'\x00'*32, [blocks[1].id]),
# BlockChain.Record(2, blocks[0].id, [blocks[2].id]),
# BlockChain.Record(3, blocks[1].id, sorted([blocks[3].id, blocks[4].id])),
# BlockChain.Record(4, blocks[2].id, [blocks[5].id]),
# BlockChain.Record(4, blocks[2].id, [blocks[6].id]),
# BlockChain.Record(5, blocks[3].id, []),
# BlockChain.Record(5, blocks[4].id, [])
# ]
#
# for i in range(6):
# assertEqual(block_chain.get(blocks[i].id), block_chain_records_pattern[i])
# UPDATE BLOCKS
# blocks = add_blocks()
# bc = get_blockchain()
#
# with patch.object(BlockChain, '_get_new_blocks', return_value=blocks):
# bc.update_blocks()
#
# assertEqual(bc.max_depth, 5)
# assertEqual(bc.head, blocks[5].id)
#
# for block in blocks:
# assertEqual(bc.get(block.id).previous_id, block.previous_block_rev.id)
# MULTIPLE UPDATE BLOCKS
# blocks = add_blocks()
# bc = get_blockchain()
#
# def patched_update_blocks(block_list):
# with patch.object(BlockChain, '_get_new_blocks', return_value=block_list):
# bc.update_blocks()
#
# for blocks_to_add, max_depth, head in (
# (blocks[0:2], 2, blocks[1].id),
# (blocks[2:3], 3, blocks[2].id),
# (blocks[4:5], 4, blocks[4].id),
# (blocks[3:4], 4, blocks[4].id),
# (blocks[5:6], 5, blocks[5].id),
# (blocks[6:7], 5, blocks[5].id)
# ):
# patched_update_blocks(blocks_to_add)
# assertEqual(bc.max_depth, max_depth)
# assertEqual(bc.head, head)
# DELETE
blocks = add_blocks(uuids, private_keys, public_keys)
bc = get_blockchain()
with patch.object(BlockChain, '_get_new_blocks', return_value=blocks):
bc.update_blocks()
try:
blocks[4].remove()
raise AssertionError
except Block.ChainOperationBlockedError:
pass
assert bc.max_depth == 5
assert bc.head == blocks[5].id
for block_to_remove, max_depth, heads in (
(blocks[5], 5, [blocks[6].id]),
(blocks[6], 4, [blocks[3].id, blocks[4].id]),
(blocks[4], 4, [blocks[3].id]),
(blocks[3], 3, [blocks[2].id]),
(blocks[2], 2, [blocks[1].id]),
(blocks[1], 1, [blocks[0].id]),
(blocks[0], 0, [BlockRev().id])
):
block_to_remove.remove()
assert bc.max_depth == max_depth
assert bc.head in heads
with patch.object(BlockChain, '_get_new_blocks', return_value=blocks):
bc.update_blocks()
assert bc.max_depth == 5
assert bc.head == blocks[5].id
assert sorted([op.uuid for op in blocks[0].operations + blocks[2].operations[1:2]]) == sorted(
Identifier.get_uuid_list())
close_database()
os.remove('test_database_file')
def generate():
return ECDSA256P1(SigningKey.generate(curve=NIST256p))
def generate_keypair(cls):
sk = SigningKey.generate(curve=NIST384p)
vk = sk.get_verifying_key()
return sk.to_pem(), vk.to_pem()
#coding:utf-8
import sha3
import binascii
from ecdsa import SigningKey, SECP256k1
priv = SigningKey.generate(curve=SECP256k1) #生成私钥
pub = priv.get_verifying_key() #生成公钥
keccak = sha3.keccak_256()
keccak.update( pub.to_string()) #keccak_256哈希运算
address = "0x" + keccak.hexdigest()[24:]
priv_key = binascii.hexlify( priv.to_string())
pub_key = binascii.hexlify( pub.to_string())
print("Private key: " + priv_key.decode() )
print("Public key: " + pub_key.decode() )
print("Address: " + address)
print "#############################"
_openssl_pub_key = "04d061e9c5891f579fd548cfd22ff29f5c642714cc7e7a9215f0071ef5a5723f691757b28e31be71f09f24673eed52348e58d53bcfd26f4d96ec6bf1489eab429d"
_pub_key = _openssl_pub_key[2:]
_pub_hex = binascii.unhexlify(_pub_key)
keccak = sha3.keccak_256()
keccak.update(_pub_hex)
address = "0x" + keccak.hexdigest()[24:]
