def CreateKeyPairFromPrivateKey(self, private_key):
keypair = KeyPair(private_key=private_key)
self._keys[keypair.PublicKeyHash] = keypair
return keypair
def create_wallet(request):
try:
body = json.loads(request.content.read().decode("utf-8"))
except JSONDecodeError as e:
request.setResponseCode(400)
return build_error(STATUS_ERROR_JSON, "JSON Error: %s" % str(e))
# Fail if not a password
if not "password" in body:
request.setResponseCode(400)
return build_error(STATUS_ERROR_JSON, "No password in request body.")
# Fail if no good password
pwd = body["password"]
if len(pwd) < 8:
request.setResponseCode(400)
return build_error(STATUS_ERROR_JSON, "Password needs a minimum length of 8 characters.")
private_key = bytes(Random.get_random_bytes(32))
key = KeyPair(priv_key=private_key)
return {
"address": key.GetAddress(),
"nep2_key": key.ExportNEP2(pwd)
}
def CreateKey(self):
private_key = bytes(Random.get_random_bytes(32))
# self.__log.debug("private key %s " % private_key)
key = KeyPair(priv_key=private_key)
self._keys[key.PublicKeyHash.ToBytes()] = key
self.__log.debug("keys %s " % self._keys.items())
return key
def test_fail_to_determine_plublic_key(self, patched_priv_to_pubkey):
# https://github.com/vbuterin/pybitcointools/blob/aeb0a2bbb8bbfe421432d776c649650eaeb882a5/bitcoin/main.py#L291
patched_priv_to_pubkey.side_effect = Exception("Invalid privkey")
with self.assertRaises(Exception) as context:
KeyPair(bytes(32 * 'A', 'utf8'))
self.assertEqual('Could not determine public key', str(context.exception))
def test_neon_sig(self):
key = KeyPair(priv_key=self.nmpk)
hhex = hashlib.sha256(binascii.unhexlify(self.nmsg)).hexdigest()
self.assertEqual(hhex, self.hashhex)
sig = Crypto.Sign(self.nmsg, key.PrivateKey, key.PublicKey)
self.assertEqual(sig.hex(), self.neon_sig)
def test_should_export_valid_nep2_key_with_emoji_pwd(self):
pwd = "hellö♥️"
privkey = "03eb20a711f93c04459000c62cc235f9e9da82382206b812b07fd2f81779aa42"
# expected outputs
target_address = "AXQUduANGZF4e7wDazVAtyRLHwMounaUMA"
target_encrypted_key = "6PYWdv8bP9vbfGsNnjzDawCoXCYpk4rnWG8xTZrvdzx6FjB6jv4H9MM586"
kp = KeyPair(binascii.unhexlify(privkey))
nep2_key = kp.ExportNEP2(pwd)
self.assertEqual(nep2_key, target_encrypted_key)
self.assertEqual(kp.GetAddress(), target_address)
def test_b(self):
key = KeyPair(priv_key=self.pk)
contract = Contract.CreateSignatureContract(key.PublicKey)
self.assertEqual(binascii.unhexlify(contract.Script), self.contract_script)
self.assertEqual(contract.ScriptHash.ToBytes(), self.contract_script_hash)
self.assertEqual(contract.Address, self.contract_address)
self.assertEqual(contract.PublicKeyHash, key.PublicKeyHash)
self.assertEqual(contract.PublicKeyHash.ToBytes(), self.pubkeyhash)
def CreateKey(self, private_key=None):
"""
Create a KeyPair
Args:
private_key (iterable_of_ints): (optional) 32 byte private key
Returns:
KeyPair: a KeyPair instance
"""
if private_key is None:
private_key = bytes(Random.get_random_bytes(32))
key = KeyPair(priv_key=private_key)
self._keys[key.PublicKeyHash.ToBytes()] = key
return key
def test_c(self):
key = KeyPair(priv_key=self.decrypted_pk)
self.assertEqual(key.PublicKey.x, self.pubkey_x)
self.assertEqual(key.PublicKey.y, self.pubkey_y)
self.assertEqual(key.PublicKey.encode_point(True), self.pubkey_encoded)
self.assertEqual(key.PublicKey.encode_point(False), self.pubkey_not_comp)
self.assertIsInstance(key.PublicKeyHash, UInt160)
self.assertEqual(key.PublicKeyHash.ToBytes(), self.pubkeyhash)
self.assertEqual(key.Export(), self.wif)
private_key_from_wif = KeyPair.PrivateKeyFromWIF(self.wif)
self.assertEqual(private_key_from_wif, self.pk)
def test_neon_sig(self):
key = KeyPair(priv_key=self.nmpk)
hhex = hashlib.sha256(binascii.unhexlify(self.nmsg)).hexdigest()
self.assertEqual(hhex, self.hashhex)
sig = Crypto.Sign(self.nmsg, key.PrivateKey, key.PublicKey)
self.assertEqual(sig.hex(), self.neon_sig)
# def test_sig_verify(self):
# key = KeyPair(priv_key=self.nmpk)
# sig = Crypto.Sign(self.nmsg, key.PrivateKey, key.PublicKey)
# self.assertEqual(sig.hex(), self.neon_sig)
# verify = Crypto.VerifySignature(self.nmsg, sig, key.PublicKey)
# print("verify? " % verify)
def test_should_throw_error_on_too_short_passphrase(self):
kp = KeyPair(binascii.unhexlify("cbf4b9f70470856bb4f40f80b87edb90865997ffee6df315ab166d713af433a5"))
with self.assertRaises(ValueError) as context:
kp.ExportNEP2("x")
self.assertIn('Passphrase must have a minimum', str(context.exception))
def test_should_return_valid_address(self):
kp = KeyPair(binascii.unhexlify("cbf4b9f70470856bb4f40f80b87edb90865997ffee6df315ab166d713af433a5"))
self.assertEqual(kp.GetAddress(), "AStZHy8E6StCqYQbzMqi4poH7YNDHQKxvt")
def test_wrong_private_key_length(self):
priv_key = b'\xDE\xAD\xBE\xEF'
with self.assertRaises(ValueError) as context:
KeyPair(priv_key)
self.assertEqual('Invalid private key', str(context.exception))
def test_should_export_valid_wif_key(self):
kp = KeyPair(binascii.unhexlify("cbf4b9f70470856bb4f40f80b87edb90865997ffee6df315ab166d713af433a5"))
wif = kp.Export()
self.assertEqual(wif, "L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP")
def test_should_export_valid_nep2_key(self):
kp = KeyPair(binascii.unhexlify("cbf4b9f70470856bb4f40f80b87edb90865997ffee6df315ab166d713af433a5"))
nep2_key = kp.ExportNEP2("TestingOneTwoThree")
self.assertEqual(nep2_key, "6PYVPVe1fQznphjbUxXP9KZJqPMVnVwCx5s5pr5axRJ8uHkMtZg97eT5kL")
def test_get_contains_key_should_not_be_found(self):
wallet = Wallet("fakepath", "123", True)
wallet.CreateKey()
keypair = KeyPair(priv_key=self.pk)
self.assertFalse(wallet.ContainsKey(keypair.PublicKey))