def testBcrypto410Schnorr(self, benchmark):
msg = secp256k1.hash_sha256("message to sign".encode())
pr_key = secp256k1.hash_sha256("secret".encode())
pu_key = secp256k1.encoded_from_point(secp256k1.G *
secp256k1.int_from_bytes(pr_key))
sig = benchmark(schnorr.bcrypto410_sign, msg, pr_key)
assert schnorr.bcrypto410_verify(msg, pu_key, sig)
def testSecp256k1Rfc6979Ecdsa(self, benchmark):
msg = secp256k1.hash_sha256("message to sign".encode())
pr_key = secp256k1.hash_sha256("secret".encode())
pu_key = secp256k1.encoded_from_point(secp256k1.G *
secp256k1.int_from_bytes(pr_key))
sig = benchmark(ecdsa.rfc6979_sign, msg, pr_key)
assert ecdsa.verify(msg, pu_key, sig)
assert ecdsa.verify(msg, pu_key,
ecdsa.rfc6979_sign(msg, pr_key, canonical=False))
def remoteSignWithSecret(network, ms_publicKey, txid, secret=None):
return remoteSignWithKey(
network, ms_publicKey, txid,
hexlify(
secp256k1.hash_sha256(
secret if secret is not None else
getpass.getpass("secret > ")
)
)
)
def getIdFromBytes(data):
"""
Generate data id.
Args:
data (bytes): data as bytes sequence
Returns:
id as hex string
"""
return hexlify(secp256k1.hash_sha256(data))
def ecdsa_verify(self, message, publicKey):
"""
Check if public key match message signature according to `ECDSA`
scheme.
Args:
message (str): message to verify
publicKey (str): public key
Returns:
True if match
"""
return ecdsa.verify(secp256k1.hash_sha256(message), puk(publicKey),
self.der)
def b410_schnorr_verify(self, message, publicKey):
"""
Check if public key match message signature according to
[Bcrypto 4.10 schnorr](
https://github.com/bcoin-org/bcrypto/blob/v4.1.0/lib/js/schnorr.js
) scheme.
Args:
message (str): message to verify
publicKey (str): public key
Returns:
True if match
"""
return schnorr.bcrypto410_verify(secp256k1.hash_sha256(message),
puk(publicKey), self.raw)
def schnorr_sign(message, privateKey):
"""
Generate message signature according to
[BIP schnorr](
https://github.com/sipa/bips/blob/bip-schnorr/bip-schnorr.mediawiki
) scheme.
Args:
message (str): message to verify
privateKey (str): private key
Returns:
`secp256k1.sig.Signature`
"""
return Signature.from_raw(
schnorr.sign(secp256k1.hash_sha256(message),
_unhexlify(privateKey)))
def b410_schnorr_sign(message, privateKey):
"""
Generate message signature according to
[Bcrypto 4.10 schnorr](
https://github.com/bcoin-org/bcrypto/blob/v4.1.0/lib/js/schnorr.js
) scheme.
Args:
message (str): message to verify
privateKey (str): private key
Returns:
`secp256k1.sig.Signature`
"""
return Signature.from_raw(
schnorr.bcrypto410_sign(secp256k1.hash_sha256(message),
_unhexlify(privateKey)))
def ecdsa_rfc6979_sign(message, privateKey, canonical=True):
"""
Generate message signature according to `ECDSA` scheme using a
deterministic nonce (RFC-6976).
Args:
message (str): message to verify
privateKey (str): private key
canonical (bool): canonalize signature
Returns:
`secp256k1.sig.Signature`
"""
return Signature.from_der(
ecdsa.rfc6979_sign(secp256k1.hash_sha256(message),
_unhexlify(privateKey),
canonical=canonical))
def getSignatureFromBytes(data, privateKey):
"""
Generate signature from data using private key.
Args:
data (bytes): bytes sequence
privateKey (str): private key as hex string
Returns:
signature as hex string
"""
secret0 = unhexlify(privateKey)
msg = secp256k1.hash_sha256(data)
if bytearray(data)[0] == 0xff:
return hexlify(schnorr.bcrypto410_sign(msg, secret0))
else:
return hexlify(ecdsa.rfc6979_sign(msg, secret0, canonical=True))
def schnorr_verify(self, message, publicKey):
"""
Check if public key match message signature according to
[BIP schnorr](
https://github.com/sipa/bips/blob/bip-schnorr/bip-schnorr.mediawiki
) scheme.
Args:
message (str): message to verify
publicKey (str): public key
Returns:
True if match
"""
return schnorr.verify(
secp256k1.hash_sha256(message),
schnorr.bytes_from_point(secp256k1.Point.decode(puk(publicKey))),
self.raw)
def verifySignatureFromBytes(data, publicKey, signature):
"""
Verify signature.
Args:
data (bytes): data
publicKey (str): public key as hex string
signature (str): signature as hex string
Returns:
True if signature matches the public key
"""
pubkey = unhexlify(publicKey)
msg = secp256k1.hash_sha256(data)
sig = unhexlify(signature)
if len(signature) == 128:
return schnorr.bcrypto410_verify(msg, pubkey, sig)
else:
return ecdsa.verify(msg, pubkey, sig)
def setUpClass(self):
prikey0 = secp256k1.hash_sha256("secret")
self.publicKey = hexlify(
secp256k1.PublicKey.from_seed(prikey0).encode())
self.privateKey = hexlify(prikey0)
self.msg_der = "00993c0b0003a02b9d5fdd1307c2ee4652ba54d492d1fd11a7d1b"\
"b3f3a44c4a05e79f19de9331eb8dd0e799b69714269474be623ce"\
"b3309020dff5756e69746573743a20747820776974682073696d7"\
"06c65207369676e61747572650000000000000000000000000000"\
"000000000000000000000000000000000000e1f50500000000c04"\
"b030000000000"
self.msg_raw = "ff0217010000000000010000000000000003a02b9d5fdd1307c2e"\
"e4652ba54d492d1fd11a7d1bb3f3a44c4a05e79f19de933809698"\
"000000000000a08601000000000000000000171dfc69b54c7fe90"\
"1e91d5a9ab78388645e2427ea"
self.der = "304402200ee92c78a690844eaabf6833ed4fe9c66db1476bcfaad1754"\
"aec780116aa16b0022045e8fda963191c1df485ff18966df509679d8d"\
"dd47e6fd51f2645309227fc5c9"
self.raw = "4f01bd21828a633a3c821b9984fe642deab87237b99e62a543ca6948f"\
"f1d6d32f2475ada1f933da0591c40603693614afa69fcb4caa2b4be01"\
"8788de9f10c42a"
def getKeys(secret):
"""
Generate keyring containing secp256k1 keys-pair and wallet import format
(WIF).
Args:
secret (str, bytes or int): anything that could issue a private key on
secp256k1 curve
Returns:
public, private and WIF keys
"""
if isinstance(secret, (str, bytes, unicode)):
try:
seed = unhexlify(secret)
except Exception:
seed = secp256k1.hash_sha256(secret)
else:
seed = secp256k1.bytes_from_int(secret)
publicKey = secp256k1.PublicKey.from_seed(seed)
return {
"publicKey": hexlify(publicKey.encode()),
"privateKey": hexlify(seed),
"wif": getWIF(seed)
}
