b1248ff315
extended _multiaddr_from_socket to support UDP and IPv6 automatically changed TCPListener to use _ip4_or_6_from_multiaddr to get host, and not ip4 only enforced `from error` everywhere with raises added call braces to exceptions
69 lines
2.2 KiB
Python
69 lines
2.2 KiB
Python
from fastecdsa import curve as curve_types
|
|
from fastecdsa import keys, point
|
|
from fastecdsa.encoding.sec1 import SEC1Encoder
|
|
|
|
from libp2p.crypto.keys import KeyPair, KeyType, PrivateKey, PublicKey
|
|
|
|
|
|
def infer_local_type(curve: str) -> curve_types.Curve:
|
|
"""converts a ``str`` representation of some elliptic curve to a
|
|
representation understood by the backend of this module."""
|
|
if curve == "P-256":
|
|
return curve_types.P256
|
|
else:
|
|
raise NotImplementedError()
|
|
|
|
|
|
class ECCPublicKey(PublicKey):
|
|
def __init__(self, impl: point.Point, curve: curve_types.Curve) -> None:
|
|
self.impl = impl
|
|
self.curve = curve
|
|
|
|
def to_bytes(self) -> bytes:
|
|
return SEC1Encoder.encode_public_key(self.impl, compressed=False)
|
|
|
|
@classmethod
|
|
def from_bytes(cls, data: bytes, curve: str) -> "ECCPublicKey":
|
|
curve_type = infer_local_type(curve)
|
|
public_key_impl = SEC1Encoder.decode_public_key(data, curve_type)
|
|
return cls(public_key_impl, curve_type)
|
|
|
|
def get_type(self) -> KeyType:
|
|
return KeyType.ECC_P256
|
|
|
|
def verify(self, data: bytes, signature: bytes) -> bool:
|
|
raise NotImplementedError()
|
|
|
|
|
|
class ECCPrivateKey(PrivateKey):
|
|
def __init__(self, impl: int, curve: curve_types.Curve) -> None:
|
|
self.impl = impl
|
|
self.curve = curve
|
|
|
|
@classmethod
|
|
def new(cls, curve: str) -> "ECCPrivateKey":
|
|
curve_type = infer_local_type(curve)
|
|
private_key_impl = keys.gen_private_key(curve_type)
|
|
return cls(private_key_impl, curve_type)
|
|
|
|
def to_bytes(self) -> bytes:
|
|
return keys.export_key(self.impl, self.curve)
|
|
|
|
def get_type(self) -> KeyType:
|
|
return KeyType.ECC_P256
|
|
|
|
def sign(self, data: bytes) -> bytes:
|
|
raise NotImplementedError()
|
|
|
|
def get_public_key(self) -> PublicKey:
|
|
public_key_impl = keys.get_public_key(self.impl, self.curve)
|
|
return ECCPublicKey(public_key_impl, self.curve)
|
|
|
|
|
|
def create_new_key_pair(curve: str) -> KeyPair:
|
|
"""Return a new ECC keypair with the requested ``curve`` type, e.g.
|
|
"P-256"."""
|
|
private_key = ECCPrivateKey.new(curve)
|
|
public_key = private_key.get_public_key()
|
|
return KeyPair(private_key, public_key)
|