mirror of
https://github.com/varun-r-mallya/py-libp2p.git
synced 2025-12-31 20:36:24 +00:00
135 lines
4.0 KiB
Python
135 lines
4.0 KiB
Python
import sys
|
|
|
|
from libp2p.crypto.keys import (
|
|
KeyPair,
|
|
KeyType,
|
|
PrivateKey,
|
|
PublicKey,
|
|
)
|
|
|
|
if sys.platform != "win32":
|
|
from fastecdsa import (
|
|
keys,
|
|
point,
|
|
)
|
|
from fastecdsa import curve as curve_types
|
|
from fastecdsa.encoding.sec1 import (
|
|
SEC1Encoder,
|
|
)
|
|
else:
|
|
from coincurve import PrivateKey as CPrivateKey
|
|
from coincurve import PublicKey as CPublicKey
|
|
|
|
|
|
def infer_local_type(curve: str) -> object:
|
|
"""
|
|
Convert a str representation of some elliptic curve to a
|
|
representation understood by the backend of this module.
|
|
"""
|
|
if curve != "P-256":
|
|
raise NotImplementedError("Only P-256 curve is supported")
|
|
|
|
if sys.platform != "win32":
|
|
return curve_types.P256
|
|
return "P-256" # coincurve only supports P-256
|
|
|
|
|
|
if sys.platform != "win32":
|
|
|
|
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)
|
|
|
|
else:
|
|
|
|
class ECCPublicKey(PublicKey):
|
|
def __init__(self, impl: CPublicKey, curve: str) -> None:
|
|
self.impl = impl
|
|
self.curve = curve
|
|
|
|
def to_bytes(self) -> bytes:
|
|
return self.impl.format(compressed=False)
|
|
|
|
@classmethod
|
|
def from_bytes(cls, data: bytes, curve: str) -> "ECCPublicKey":
|
|
curve_type = infer_local_type(curve)
|
|
return cls(CPublicKey(data), curve_type) # type: ignore[arg-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: CPrivateKey, curve: str) -> None:
|
|
self.impl = impl
|
|
self.curve = curve
|
|
|
|
@classmethod
|
|
def new(cls, curve: str) -> "ECCPrivateKey":
|
|
curve_type = infer_local_type(curve)
|
|
return cls(CPrivateKey(), curve_type) # type: ignore[arg-type]
|
|
|
|
def to_bytes(self) -> bytes:
|
|
return self.impl.secret
|
|
|
|
def get_type(self) -> KeyType:
|
|
return KeyType.ECC_P256
|
|
|
|
def sign(self, data: bytes) -> bytes:
|
|
raise NotImplementedError()
|
|
|
|
def get_public_key(self) -> PublicKey:
|
|
return ECCPublicKey(self.impl.public_key, 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)
|