我们从Python开源项目中，提取了以下19个代码示例，用于说明如何使用ecdsa.SigningKey()。
def prepare_key(self, key): if isinstance(key, ecdsa.SigningKey) or \ isinstance(key, ecdsa.VerifyingKey): return key if isinstance(key, string_types): if isinstance(key, text_type): key = key.encode('utf-8') # Attempt to load key. We don't know if it's # a Signing Key or a Verifying Key, so we try # the Verifying Key first. try: key = ecdsa.VerifyingKey.from_pem(key) except ecdsa.der.UnexpectedDER: key = ecdsa.SigningKey.from_pem(key) else: raise TypeError('Expecting a PEM-formatted key.') return key
def get_pubkeys_from_secret(secret): # public key private_key = ecdsa.SigningKey.from_string(secret, curve=SECP256k1) public_key = private_key.get_verifying_key() K = public_key.to_string() K_compressed = GetPubKey(public_key.pubkey, True) return K, K_compressed # Child private key derivation function (from master private key) # k = master private key (32 bytes) # c = master chain code (extra entropy for key derivation) (32 bytes) # n = the index of the key we want to derive. (only 32 bits will be used) # If n is negative (i.e. the 32nd bit is set), the resulting private key's # corresponding public key can NOT be determined without the master private key. # However, if n is positive, the resulting private key's corresponding # public key can be determined without the master private key.
def load_key(cls, wallet_name, key_type): if key_type == 'public_key': ecdsa_key = ecdsa.VerifyingKey extension = ".pk" elif key_type =='secret_key': ecdsa_key = ecdsa.SigningKey extension = ".sk" else: raise ValueError('Third argument key_type needs to be either public_key or secret_key.') key_path = os.path.join(settings.WALLETS_ABS_PATH, wallet_name + extension) with open(key_path, 'rb') as temp_file: hex_key = temp_file.read() bytes_key = unhexlify(hex_key) key = ecdsa_key.from_string(bytes_key, settings.bitcoin_curve) return key
def import_key(encoded, passphrase=None): # encoded, passphrase=None # extern_key, passphrase=None # key = Cryptodome.PublicKey.ECC.import_key(*args, **kwargs) # return to_ecdsakey(key, _from=Cryptodome.PublicKey.ECC, _to=ecdsa.SigningKey) if encoded.startswith('-----'): return ecdsa.SigningKey.from_pem(encoded) # OpenSSH # if encoded.startswith(b('ecdsa-sha2-')): # return _import_openssh(encoded) # DER if ord(encoded[0]) == 0x30: return ecdsa.SigningKey.from_der(encoded) raise Exception("Invalid Format")
def recover_nonce_reuse(self, other): sig2 = other.sig # rename it h2 = other.h # rename it # precalculate static values z = self.h - h2 r_inv = inverse_mod(self.sig.r, self.n) # # try all candidates # for candidate in (self.sig.s - sig2.s, self.sig.s + sig2.s, -self.sig.s - sig2.s, -self.sig.s + sig2.s): k = (z * inverse_mod(candidate, self.n)) % self.n d = (((self.sig.s * k - self.h) % self.n) * r_inv) % self.n signingkey = SigningKey.from_secret_exponent(d, curve=self.curve) if signingkey.get_verifying_key().pubkey.verifies(self.h, self.sig): self.signingkey = signingkey self.k = k self.x = d return self assert False # could not recover private key
def sign_number(self, number, entropy=None, k=None): curve = SECP256k1 G = curve.generator order = G.order() r, s = ecdsa.SigningKey.sign_number(self, number, entropy, k) if s > order / 2: s = order - s return r, s
def __init__(self, key, algorithm): if algorithm not in self.valid_hash_algs: raise JWKError('hash_alg: %s is not a valid hash algorithm' % algorithm) self.hash_alg = get_algorithm_object(algorithm) self.curve = self.curve_map.get(self.hash_alg) if isinstance(key, (ecdsa.SigningKey, ecdsa.VerifyingKey)): self.prepared_key = key return if isinstance(key, dict): self.prepared_key = self._process_jwk(key) return if isinstance(key, six.string_types): if isinstance(key, six.text_type): key = key.encode('utf-8') # Attempt to load key. We don't know if it's # a Signing Key or a Verifying Key, so we try # the Verifying Key first. try: key = ecdsa.VerifyingKey.from_pem(key) except ecdsa.der.UnexpectedDER: key = ecdsa.SigningKey.from_pem(key) except Exception as e: raise JWKError(e) self.prepared_key = key return raise JWKError('Unable to parse an ECKey from key: %s' % key)
def __init__(self, secret_key=None, public_key=None): if secret_key is None: self.secret_key = ecdsa.SigningKey.generate(settings.bitcoin_curve) self.public_key = self.secret_key.get_verifying_key() else: self.secret_key = secret_key self.public_key = public_key
def deprecated_load(cls, wallet_name): #cls stands for class, because the variable name class is taken with open(wallet_name, 'rb') as temp_file: temp_array = temp_file.read().splitlines() secret_key_hex, public_key_hex = temp_array secret_key_bytes, public_key_bytes = unhexlify(secret_key_hex), unhexlify(public_key_hex) secret_key, public_key = ecdsa.SigningKey.from_string(secret_key_bytes, settings.bitcoin_curve), ecdsa.VerifyingKey.from_string(public_key_bytes, settings.bitcoin_curve) print("Wallet loaded.") return Wallet(secret_key, public_key)
def signing_key_from_pem(cls, pem): return ecdsa.SigningKey.from_pem(pem, hashfunc=cls.HASHFUNC)
def signing_key_from_der(cls, der): return ecdsa.SigningKey.from_der(der, hashfunc=cls.HASHFUNC)
def validate_private_key(self, private_key): if not isinstance(private_key, ecdsa.SigningKey): raise TypeError("Not given a signing key, given a %s" % str(type(private_key))) return private_key.get_verifying_key().to_string() == self.public_key.to_string()
def load_pem(cls, pem_string): return cls(ecdsa.SigningKey.from_pem(pem_string, hashfunc=cls.HASHFUNC_NAME))
def generate(cls): return cls(ecdsa.SigningKey.generate(curve=cls.CURVE, hashfunc=cls.HASHFUNC_NAME))
def __init__(self, privkey, chain_code, n, depth, parent=None): super().__init__(chain_code, n, depth, parent) if isinstance(privkey, ecdsa.SigningKey): self.signing_key = privkey else: self.signing_key = self._signing_key_from_privkey(privkey)
def _signing_key_from_privkey(cls, privkey): '''Converts a 32-byte privkey into an ecdsa.SigningKey object.''' exponent = cls._privkey_secret_exponent(privkey) return ecdsa.SigningKey.from_secret_exponent(exponent, curve=cls.CURVE)
def to_ecdsakey(secret_key, _from=ecdsa.SigningKey, _to=Cryptodome.PublicKey.ECC): # pointx, pointy, d return _to.import_key(secret_key.to_der())
