def sign_raw_data(raw_data, privatekey):
"""
Sign a string of data.
Returns signature as a base64 string
"""
data_hash = get_data_hash(raw_data)
pk = ECPrivateKey(privatekey)
pk_hex = pk.to_hex()
# force uncompressed
if len(pk_hex) > 64:
pk = ECPrivateKey(privkey[:64])
priv = pk.to_hex()
pub = pk.public_key().to_hex()
assert len(pub[2:].decode('hex')) == ecdsa.SECP256k1.verifying_key_length, "BUG: Invalid key decoding"
sk = ecdsa.SigningKey.from_string(priv.decode('hex'), curve=ecdsa.SECP256k1)
sig_bin = sk.sign_digest(data_hash.decode('hex'), sigencode=ecdsa.util.sigencode_der)
# enforce low-s
sig_r, sig_s = ecdsa.util.sigdecode_der( sig_bin, ecdsa.SECP256k1.order )
if sig_s * 2 >= ecdsa.SECP256k1.order:
log.debug("High-S to low-S")
sig_s = ecdsa.SECP256k1.order - sig_s
sig_bin = ecdsa.util.sigencode_der( sig_r, sig_s, ecdsa.SECP256k1.order )
# sanity check
vk = ecdsa.VerifyingKey.from_string(pub[2:].decode('hex'), curve=ecdsa.SECP256k1)
assert vk.verify_digest(sig_bin, data_hash.decode('hex'), sigdecode=ecdsa.util.sigdecode_der), "Failed to verify signature ({}, {})".format(sig_r, sig_s)
return base64.b64encode( bitcoin.encode_sig( None, sig_r, sig_s ).decode('hex') )
def ecdsa_sign_bin(msgbin, priv):
v, r, s = ecdsa_raw_sign(msgbin, priv)
sig = encode_sig(v, r, s)
pubkey = privkey_to_pubkey(wif_to_privkey(priv))
ok = ecdsa_raw_verify(msgbin, decode_sig(sig), pubkey)
if not ok:
raise Exception('Bad signature!')
return sig
def sign_raw_data( raw_data, privatekey ): """ Sign a string of data. Return a base64-encoded signature. """ data_hash = get_data_hash( raw_data ) data_sig_bin = pybitcointools.ecdsa_raw_sign( data_hash, privatekey ) return pybitcointools.encode_sig( data_sig_bin[0], data_sig_bin[1], data_sig_bin[2] )
def sign_raw_data( raw_data, privatekey ): """ Sign a string of data. Return a base64-encoded signature. """ data_hash = get_data_hash( raw_data ) data_sig_bin = pybitcointools.ecdsa_raw_sign( data_hash, privatekey ) return pybitcointools.encode_sig( data_sig_bin[0], data_sig_bin[1], data_sig_bin[2] )
def ecdsa_sign(msg: str, wif_priv_key: str, dash_network: str):
"""Signs a message with the Elliptic Curve algorithm."""
v, r, s = bitcoin.ecdsa_raw_sign(electrum_sig_hash(msg), wif_priv_key)
sig = bitcoin.encode_sig(v, r, s)
pubkey = bitcoin.privkey_to_pubkey(wif_to_privkey(wif_priv_key, dash_network))
ok = bitcoin.ecdsa_raw_verify(electrum_sig_hash(msg), bitcoin.decode_sig(sig), pubkey)
if not ok:
raise Exception('Bad signature!')
return sig
def ecdsa_sign_raw(msg_raw: bytes, wif_priv_key: str, dash_network: str):
"""Signs raw bytes (a message hash) with the Elliptic Curve algorithm.
"""
v, r, s = bitcoin.ecdsa_raw_sign(msg_raw, wif_priv_key)
sig = bitcoin.encode_sig(v, r, s)
pubkey = bitcoin.privkey_to_pubkey(wif_to_privkey(wif_priv_key, dash_network))
ok = bitcoin.ecdsa_raw_verify(msg_raw, bitcoin.decode_sig(sig), pubkey)
if not ok:
raise Exception('Bad signature!')
return sig
def ecdsa_sign(msg, priv):
"""
Based on project: https://github.com/chaeplin/dashmnb.
"""
v, r, s = ecdsa_raw_sign(electrum_sig_hash(msg), priv)
sig = encode_sig(v, r, s)
pubkey = privkey_to_pubkey(wif_to_privkey(priv))
ok = ecdsa_raw_verify(electrum_sig_hash(msg), decode_sig(sig), pubkey)
if not ok:
raise Exception('Bad signature!')
return sig
def ecdsa_sign(msg, priv):
"""
Based on project: https://github.com/chaeplin/dashmnb with some changes related to usage of bitcoin library.
"""
v, r, s = bitcoin.ecdsa_raw_sign(electrum_sig_hash(msg), priv)
sig = bitcoin.encode_sig(v, r, s)
pubkey = bitcoin.privkey_to_pubkey(wif_to_privkey(priv))
ok = bitcoin.ecdsa_raw_verify(electrum_sig_hash(msg),
bitcoin.decode_sig(sig), pubkey)
if not ok:
raise Exception('Bad signature!')
return sig
def ecdsa_sign(msg: str, wif_priv_key: str, dash_network: str):
"""Signs a message with the Elliptic Curve algorithm.
Note: Dash core uses uncompressed public keys, so if the private key passed as an argument
is of compressed format, convert it to an uncompressed
"""
# wif_priv_key = wif_privkey_to_uncompressed(wif_priv_key)
v, r, s = bitcoin.ecdsa_raw_sign(electrum_sig_hash(msg), wif_priv_key)
sig = bitcoin.encode_sig(v, r, s)
pubkey = bitcoin.privkey_to_pubkey(wif_to_privkey(wif_priv_key, dash_network))
ok = bitcoin.ecdsa_raw_verify(electrum_sig_hash(msg), bitcoin.decode_sig(sig), pubkey)
if not ok:
raise Exception('Bad signature!')
return sig
def make_sigs(self, outfile, shash):
""" Make and write signatures to the given output file. """
for priv in self.privs:
sig = bitcoin.encode_sig(*bitcoin.ecdsa_raw_sign(shash, priv))
outfile.write(("SIG " + sig + "\n").encode("ascii"))
msgHash = sha3_256Hash(msg)
valid = verify(generator_secp256k1, public_key, msgHash, signature)
return valid
private_key = bitcoin.random_key()
decoded_private_key = bitcoin.decode_privkey(private_key, 'hex')
print("Private Key (hex) is: ", private_key)
# Multiply the EC generator point G with the private key to get a public key point
public_key = bitcoin.fast_multiply(bitcoin.G, decoded_private_key)
# Compress public key, adjust prefix depending on whether y is even or odd
(public_key_x, public_key_y) = public_key
compressed_prefix = '02' if (public_key_y % 2) == 0 else '03'
hex_compressed_public_key = compressed_prefix + \
(bitcoin.encode(public_key_x, 16).zfill(64))
print("Compressed Public Key (hex) is:", hex_compressed_public_key)
msg = "my name is nabin"
signature = signECDSAsecp256k1(msg, decoded_private_key)
print(signature)
print("Message:", msg)
hex_encoded_signature = bitcoin.encode_sig(23, signature[0], signature[1])
print("Signature(Hex):", hex_encoded_signature)
# ECDSA verify signature (using the curve secp256k1 + SHA3-256)
valid = verifyECDSAsecp256k1("123", signature, public_key)
print("Signature valid?", valid)
