30456f8018
This library has the ``SEC1`` encoder which is compatible with the serialization of ECC keys/points used in the Go libp2p impl
72 lines
2.2 KiB
Python
72 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)
|