Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
print("master secret:", end="")
h = input()
if h:
h = unhexlify(h).encode("ascii")
else:
h = hashlib.sha256(os.urandom(1024)).digest()
print()
print("master secret:", hexlify(h))
print()
for i in range(1, 6):
se = hashlib.sha256(h + chr(i).encode("ascii")).hexdigest()
print("seckey", i, ":", se)
sk = ecdsa.SigningKey.from_secret_exponent(
secexp=int(se, 16), curve=ecdsa.curves.SECP256k1, hashfunc=hashlib.sha256
)
print(
"pubkey",
i,
":",
(b"04" + hexlify(sk.get_verifying_key().to_string())).decode("ascii"),
)
print(sk.to_pem().decode("ascii"))
p = subprocess.Popen("ssss-split -t 3 -n 5 -x".split(" "), stdin=subprocess.PIPE)
p.communicate(input=hexlify(h) + "\n")
def import_key(self, keypair, password):
address, key = keypair.split(':')
if not self.is_valid(address):
raise BaseException('Invalid Bitcoin address')
if address in self.all_addresses():
raise BaseException('Address already in wallet')
b = ASecretToSecret( key )
if not b:
raise BaseException('Unsupported key format')
secexp = int( b.encode('hex'), 16)
private_key = ecdsa.SigningKey.from_secret_exponent( secexp, curve=SECP256k1 )
# sanity check
public_key = private_key.get_verifying_key()
if not address == public_key_to_bc_address( '04'.decode('hex') + public_key.to_string() ):
raise BaseException('Address does not match private key')
self.imported_keys[address] = self.pw_encode( key, password )
def sign_message(self, message, compressed, address):
private_key = ecdsa.SigningKey.from_secret_exponent( self.secret, curve = SECP256k1 )
public_key = private_key.get_verifying_key()
signature = private_key.sign_digest_deterministic( Hash( msg_magic(message) ), hashfunc=hashlib.sha256, sigencode = ecdsa.util.sigencode_string )
assert public_key.verify_digest( signature, Hash( msg_magic(message) ), sigdecode = ecdsa.util.sigdecode_string)
for i in range(4):
sig = base64.b64encode( from_int_to_byte(27 + i + (4 if compressed else 0)) + signature )
try:
self.verify_message( address, sig, message)
return sig
except Exception:
continue
else:
raise Exception("error: cannot sign message")
def init_mpk(self,seed):
# public key
curve = SECP256k1
secexp = self.stretch_key(seed)
master_private_key = ecdsa.SigningKey.from_secret_exponent( secexp, curve = SECP256k1 )
self.master_public_key = master_private_key.get_verifying_key().to_string()
def privnum2pubhex(numpriv,compressed=False):
pko = ecdsa.SigningKey.from_secret_exponent(numpriv,_secp256k1)
# pubkey = 32-byte X coord + 32-byte Y coord (unsigned big-endian)
pubkey = hexlify(pko.get_verifying_key().to_string())
if compressed: # discard Y coord, replace with appropriate version byte
# even Y: <0, odd Y: >0 -- https://bitcointalk.org/index.php?topic=129652.0
p = ('03','02')[pubkey[-1] in '02468ace']
return p+pubkey[:64]
else:
return '04'+pubkey
def init_master_private_key(cls, secexp):
private_key = ecdsa.SigningKey.from_secret_exponent(secexp, curve=SECP256k1)
return private_key
pubkeys[x] = ecdsa.SigningKey.from_secret_exponent(x, curve=ecdsa.SECP256k1).verifying_key.to_string()
if header[5:].startswith(pubkeys[x]):
return "Found Bitcoin private key: %064X" % x
elif header[200:].startswith(pubkeys[x]):
return "Found AES private key: b'\\x" + '\\x'.join([('%064x' % x)[i:i+2] for i in xrange(0, 64, 2)]) + "' (%064X)" % x
i += 1
i = 1
while i < 1<
def _genkey(seed):
hex_string = sha256(seed.encode()).hexdigest()
integ = int(hex_string,16)
priv_key = ecdsa.SigningKey.from_secret_exponent(curve=ecdsa.SECP256k1,secexp=integ)
eoskey = keys.EOSKey()
eoskey._sk = priv_key
eoskey._vk = eoskey._sk.get_verifying_key()
return eoskey.to_public(),eoskey.to_wif()
def sign(private_key, message):
curve = SECP256k1.curve
G = SECP256k1.G
order = SECP256k1.order
secret, compressed = private_key_to_secret_check_compressed(private_key)
if secret == None:
return None
h = double_sha256(format_message_for_signing(message))
signing_key = ecdsa.SigningKey.from_secret_exponent(secret, curve=SECP256k1.ecdsa_curve)
ecdsa_signature = signing_key.sign_digest(h, sigencode=ecdsa.util.sigencode_string)
public_point = signing_key.get_verifying_key().pubkey.point
e = ecdsa.util.string_to_number(h)
r, s = ecdsa.util.sigdecode_string(ecdsa_signature, order)
# Okay, now we have to guess and check parameters for j and yp
found = False
for j in range(SECP256k1.h + 1):
x = r + j * order
alpha = ((x * x * x) + (curve.a() * x) + curve.b()) % curve.p()
beta = ecdsa.numbertheory.square_root_mod_prime(alpha, curve.p())
for yp in range(2):
if (beta - yp) % 2 == 0:
y = beta
def bank_private_key(id):
assert isinstance(id, int)
assert id >= 0
base = 1000 # So bank keys don't collide with user keys ...
return SigningKey.from_secret_exponent(base + id, curve=SECP256k1)