我们从Python开源项目中，提取了以下13个代码示例，用于说明如何使用ecdsa.VerifyingKey()。
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 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 _verifying_key_from_pubkey(cls, pubkey): '''Converts a 33-byte compressed pubkey into an ecdsa.VerifyingKey object''' if not isinstance(pubkey, (bytes, bytearray)): raise TypeError('pubkey must be raw bytes') if len(pubkey) != 33: raise ValueError('pubkey must be 33 bytes') if pubkey[0] not in (2, 3): raise ValueError('invalid pubkey prefix byte') curve = cls.CURVE.curve is_odd = pubkey[0] == 3 x = bytes_to_int(pubkey[1:]) # p is the finite field order a, b, p = curve.a(), curve.b(), curve.p() y2 = pow(x, 3, p) + b assert a == 0 # Otherwise y2 += a * pow(x, 2, p) y = NT.square_root_mod_prime(y2 % p, p) if bool(y & 1) != is_odd: y = p - y point = EC.Point(curve, x, y) return ecdsa.VerifyingKey.from_public_point(point, curve=cls.CURVE)
def child(self, n): '''Return the derived child extended pubkey at index N.''' if not 0 <= n < (1 << 31): raise ValueError('invalid BIP32 public key child number') msg = self.pubkey_bytes + struct.pack('>I', n) L, R = self._hmac_sha512(msg) curve = self.CURVE L = bytes_to_int(L) if L >= curve.order: raise DerivationError point = curve.generator * L + self.ec_point() if point == EC.INFINITY: raise DerivationError verkey = ecdsa.VerifyingKey.from_public_point(point, curve=curve) return PubKey(verkey, R, n, self.depth + 1, self)
def _CKD_pub(cK, c, s): order = generator_secp256k1.order() I = hmac.new(c, cK + s, hashlib.sha512).digest() curve = SECP256k1 pubkey_point = string_to_number(I[0:32]) * curve.generator + ser_to_point(cK) public_key = ecdsa.VerifyingKey.from_public_point(pubkey_point, curve=SECP256k1) c_n = I[32:] cK_n = GetPubKey(public_key.pubkey, True) return cK_n, c_n
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 _process_jwk(self, jwk_dict): if not jwk_dict.get('kty') == 'EC': raise JWKError("Incorrect key type. Expected: 'EC', Recieved: %s" % jwk_dict.get('kty')) x = base64_to_long(jwk_dict.get('x')) y = base64_to_long(jwk_dict.get('y')) if not ecdsa.ecdsa.point_is_valid(self.curve.generator, x, y): raise JWKError("Point: %s, %s is not a valid point" % (x, y)) point = ecdsa.ellipticcurve.Point(self.curve.curve, x, y, self.curve.order) verifying_key = ecdsa.keys.VerifyingKey.from_public_point(point, self.curve) return verifying_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 __init__(self, public_key, certificate_claim_id): if not isinstance(public_key, ecdsa.VerifyingKey): raise Exception("Key is not type needed for verification") if not self.CURVE_NAME == public_key.curve.name: raise Exception("Curve mismatch") validate_claim_id(certificate_claim_id) self._public_key = public_key self._certificate_claim_id = certificate_claim_id
def verifying_key_from_der(der): return ecdsa.VerifyingKey.from_der(der)
def __init__(self, pubkey, chain_code, n, depth, parent=None): super().__init__(chain_code, n, depth, parent) if isinstance(pubkey, ecdsa.VerifyingKey): self.verifying_key = pubkey else: self.verifying_key = self._verifying_key_from_pubkey(pubkey) self.addresses = {}
