本文整理汇总了Python中ecdsa.SigningKey.from_string方法的典型用法代码示例。如果您正苦于以下问题:Python SigningKey.from_string方法的具体用法?Python SigningKey.from_string怎么用?Python SigningKey.from_string使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类ecdsa.SigningKey
的用法示例。
在下文中一共展示了SigningKey.from_string方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: test
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test(self):
for data in priv_pub_hash_addr_p2pkh_segwit:
priv = PrivateKey.from_wif(data['privkey'])
pub = PublicKey.unhexlify(data['pubkey'])
pubhash = bytearray(unhexlify(data['pubkeyhash']))
address = Address.from_string(data['address'], strict=False)
p2pkhhex = data['scriptpubkey']
segwit_addr = data['segwit']
self.assertEqual(priv.pub(), pub)
self.assertEqual(pub.hash(), pubhash)
self.assertEqual(address.hash, pubhash)
self.assertEqual(P2pkhScript(pub).hexlify(), p2pkhhex)
self.assertEqual(P2pkhScript(address).hexlify(), p2pkhhex)
self.assertEqual(P2pkhScript(pubhash).hexlify(), p2pkhhex)
self.assertEqual(str(P2shScript(P2wpkhV0Script(pub)).address()), segwit_addr)
self.assertEqual(str(P2shScript(P2wpkhV0Script(pubhash)).address()), segwit_addr)
self.assertEqual(P2shScript(P2wpkhV0Script(pub)).scripthash, Address.from_string(segwit_addr).hash)
self.assertEqual(P2shScript(P2wpkhV0Script(pubhash)).scripthash, Address.from_string(segwit_addr).hash)
示例2: ec_get_public_key_by_private_key
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def ec_get_public_key_by_private_key(private_key: bytes, curve_name) -> bytes:
if curve_name == Curve.P256:
private_key = SigningKey.from_string(string=private_key, curve=curves.NIST256p)
verifying_key = private_key.get_verifying_key()
order = verifying_key.pubkey.order
x_int = verifying_key.pubkey.point.x()
y_int = verifying_key.pubkey.point.y()
x_str = util.number_to_string(x_int, order)
if y_int % 2 == 0:
point_str = util.b('\x02') + x_str
else:
point_str = util.b('\x03') + x_str
elif curve_name == Curve.P224:
raise SDKException(ErrorCode.unsupported_key_type)
elif curve_name == Curve.P384:
raise SDKException(ErrorCode.unsupported_key_type)
elif curve_name == Curve.P521:
raise SDKException(ErrorCode.unsupported_key_type)
else:
raise SDKException(ErrorCode.unsupported_key_type)
return point_str
示例3: from_parent
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def from_parent(parent_key, i):
if i & HARDENED_INDEX:
raise ValueError("Can't generate a hardened child key from a parent public key.")
child = hmac.new(parent_key.chain_code,
parent_key.compressed_key + i.to_bytes(length=4, byteorder='big'),
hashlib.sha512).digest()
child_left, child_right = child[:32], child[32:]
if int.from_bytes(child_left, 'big') >= ecdsa.generator_256.order():
return None
temp_pri_key = SigningKey.from_string(string=child_left, curve=curves.NIST256p)
ki = temp_pri_key.verifying_key.pubkey.point + parent_key.key.pubkey.point
if ki == ellipticcurve.INFINITY:
return None
return HDPublicKey(public_key=VerifyingKey.from_public_point(point=ki, curve=curves.NIST256p),
chain_code=child_right,
index=i,
depth=parent_key.depth + 1,
parent_fingerprint=parent_key.fingerprint)
示例4: validate_tx_in
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def validate_tx_in(tx_in, transaction, a_unspent_tx_outs):
referenced_utxo = [utxo for utxo in a_unspent_tx_outs if utxo.tx_out_id == tx_in.tx_out_id and utxo.tx_out_index == tx_in.tx_out_index][0]
if referenced_utxo == []:
print('referenced txOut not found: ' + json.dumps(tx_in))
return False
address = referenced_utxo.address
vk = VerifyingKey.from_string(bytes.fromhex(address), curve=SECP256k1)
try:
vk.verify(bytes.fromhex(tx_in.signature), transaction.id.encode())
except Exception as e:
# change the exception
print('invalid tx_in signature: %s txId: %s address: %s' % (tx_in.signature, transaction.id, referenced_utxo.address))
return False
return True
示例5: sign_tx_in
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def sign_tx_in(transaction, tx_in_index,
private_key, a_unspent_tx_outs):
tx_in = transaction.tx_ins[tx_in_index]
data_to_sign = str(transaction.id)
referenced_utxo = find_unspent_tx_out(tx_in.tx_out_id, tx_in.tx_out_index, a_unspent_tx_outs)
if referenced_utxo is None:
print('could not find referenced txOut')
# throw Error()
return False
referenced_address = referenced_utxo.address
if get_public_key(private_key) != referenced_address:
print('trying to sign an input with private' +
' key that does not match the address that is referenced in tx_in')
# throw Error()
return False
# key = ec.keyFromPrivate(private_key, 'hex')
sk = SigningKey.from_string(private_key, curve=SECP256k1)
signature = binascii.b2a_hex(sk.sign(data_to_sign.encode())).decode()
return signature
示例6: pub
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def pub(self, compressed=None):
if compressed is None:
compressed = self.public_compressed
raw_pubkey = bytearray(SigningKey.from_string(self.key, curve=SECP256k1).get_verifying_key().to_string())
uncompressed = PublicKey(bytearray([0x04]) + raw_pubkey)
if compressed:
return PublicKey(uncompressed.compressed)
else:
return uncompressed
示例7: raw_sign
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def raw_sign(self, data, deterministic=True):
sig_key = SigningKey.from_string(self.key, curve=SECP256k1)
sig_func = partial(sig_key.sign_digest_deterministic, hashfunc=sha256) if deterministic else sig_key.sign_digest
r, s, order = sig_func(data, sigencode=lambda *x: x)
if s < 0x01:
raise ValueError('Too low s value for signature: {}'.format(s))
# ref: https://github.com/bitcoin/bips/blob/master/bip-0062.mediawiki#Low_S_values_in_signatures
if s > PrivateKey.highest_s:
s = order - s
if s.to_bytes(32, 'big')[0] > 0x7f:
s = int.from_bytes(b'\x00' + s.to_bytes(32, 'big'), 'big')
if r.to_bytes(32, 'big')[0] > 0x7f:
r = int.from_bytes(b'\x00' + r.to_bytes(32, 'big'), 'big')
return r, s, order
示例8: test_valid
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test_valid(self):
for data in segwit_valid_addresses:
address = SegWitAddress.from_string(data['address'], strict=False)
script = ScriptBuilder.identify(data['script'])
self.assertEqual(address.hash, script.address().hash)
if len(data['script']) == 44:
self.assertEqual(P2wpkhV0Script(address), script)
elif len(data['script']) == 68:
self.assertEqual(P2wshV0Script(address), script)
示例9: test_priv_to_pubhash
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test_priv_to_pubhash(self):
for priv, addr, _ in privk['derivations']:
self.assertEqual(str(PrivateKey.from_wif(priv).pub().to_address(mainnet=False)),
addr)
self.assertEqual(PrivateKey.from_wif(priv).pub().hash(),
Address.from_string(addr, strict=False).hash)
示例10: __init__
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.pubk = PublicKey.unhexlify('0384478d41e71dc6c3f9edde0f928a47d1b724c05984ebfb4e7d0422e80abe95ff')
self.pubkh = self.pubk.hash()
self.address = Address.from_string('mquvJWnJJwTDUcdneQkUbrfN2wm9uiXd1p')
示例11: test_success_addresses
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test_success_addresses(self):
for script_hex, address in p2sh.items():
script = ScriptBuilder.identify(bytearray(unhexlify(script_hex)))
from_addr = P2shScript(Address.from_string(address))
from_script = P2shScript(script)
self.assertTrue(str(from_addr.address()) == address)
self.assertTrue(str(P2shAddress.from_script(script)) == address)
self.assertTrue(str(from_script.address()) == address)
script = P2shScript(self.address)
self.assertTrue(script.decompile() ==
'OP_HASH160 {} OP_EQUAL'.format(self.as_data))
self.assertTrue(script.hexlify() == 'a9{:02x}{}87'.format(len(self.as_data), self.as_data))
示例12: test_success
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test_success(self):
for net, addr_type, address, hashed_data in self.good_addresses:
from_string = Address.from_string(address, strict=False)
self.assertTrue(address == str(from_string))
self.assertTrue(from_string.__class__ == addr_type)
self.assertTrue(from_string.network == net)
self.assertTrue(from_string.hash == hashed_data)
示例13: test_conversions
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test_conversions(self):
for address, pkh in addresses:
self.assertEqual(hexlify(Address.from_string(address, strict=False).hash).decode(), pkh)
self.assertEqual(str(P2pkhScript(bytearray(unhexlify(pkh))).address(mainnet=True)), address)
self.assertEqual(P2pkhScript(Address.from_string(address, strict=False)).pubkeyhash,
bytearray(unhexlify(pkh)))
self.assertEqual(P2pkhAddress(bytearray(unhexlify(pkh)), mainnet=True).hash, bytearray(unhexlify(pkh)))
示例14: test_to_script
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def test_to_script(self):
data = {}
for addr, pkh in addresses:
data[addr] = P2pkhScript(bytearray(unhexlify(pkh)))
for script, addr in p2sh.items():
data[addr] = P2shScript(ScriptBuilder.identify(script))
for dic in segwit_valid_addresses:
data[dic['address']] = ScriptBuilder.identify(dic['script'])
for addr, script in data.items():
self.assertTrue(Address.from_string(addr, strict=False).to_script().hexlify(),
script.hexlify())
示例15: from_bytes
# 需要导入模块: from ecdsa import SigningKey [as 别名]
# 或者: from ecdsa.SigningKey import from_string [as 别名]
def from_bytes(cls, data: bytes):
""" Generates either a HDPublicKey from the underlying bytes.
The serialization must conform to the description in:
https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#serialization-format
"""
if len(data) < 78:
raise ValueError("b must be at least 78 bytes long.")
version = int.from_bytes(data[:4], 'big')
depth = data[4]
parent_fingerprint = data[5:9]
index = int.from_bytes(data[9:13], 'big')
chain_code = data[13:45]
key_bytes = data[45:78]
if version != HDPublicKey.__VERSION:
raise ValueError('invalid HD Public Key.')
if key_bytes[0] != 0x02 and key_bytes[0] != 0x03:
raise ValueError("First byte of public key must be 0x02 or 0x03!")
# The curve of points satisfying y^2 = x^3 + a*x + b (mod p).
curve = ecdsa.curve_256
x = util.string_to_number(key_bytes[1:])
y = (x * x * x + curve.a() * x + curve.b()) % curve.p()
y = numbertheory.square_root_mod_prime(y, curve.p())
if (key_bytes[0] == 0x03 and y % 2 == 0) or (key_bytes[0] == 0x02 and y % 2 != 0):
y = (y * -1) % curve.p()
order = curves.NIST256p.order
s_key = util.number_to_string(x, order) + util.number_to_string(y, order)
public_key = VerifyingKey.from_string(string=s_key, curve=curves.NIST256p)
rv = cls(
public_key=public_key,
chain_code=chain_code,
index=index,
depth=depth,
parent_fingerprint=parent_fingerprint)
return rv