varun-r-mallya/py-libp2p
1
0
Fork 0
mirror of https://github.com/varun-r-mallya/py-libp2p.git synced 2026-02-11 15:40:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use a different ECC backend with a compatible serializer

Browse Source 
This library has the ``SEC1`` encoder which is compatible
with the serialization of ECC keys/points used in the Go libp2p impl
This commit is contained in:
Alex Stokes
2019-09-03 13:21:07 -07:00
parent eaeb36c1d9
commit 30456f8018
4 changed files with 39 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
libp2p/crypto/ecc.py
View File

@ -1,22 +1,34 @@
from typing import cast
from Crypto.PublicKey import ECC
from Crypto.PublicKey.ECC import EccKey
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: EccKey) -> None:
def __init__(self, impl: point.Point, curve: curve_types.Curve) -> None:
self.impl = impl
self.curve = curve
def to_bytes(self) -> bytes:
return cast(bytes, self.impl.export_key(format="DER"))
return SEC1Encoder.encode_public_key(self.impl, compressed=False)
@classmethod
def from_bytes(cls, data: bytes) -> "ECCPublicKey":
public_key_impl = ECC.import_key(data)
return cls(public_key_impl)
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
@ -26,16 +38,18 @@ class ECCPublicKey(PublicKey):
class ECCPrivateKey(PrivateKey):
def __init__(self, impl: EccKey) -> None:
def __init__(self, impl: int, curve: curve_types.Curve) -> None:
self.impl = impl
self.curve = curve
@classmethod
def new(cls, curve: str) -> "ECCPrivateKey":
private_key_impl = ECC.generate(curve=curve)
return cls(private_key_impl)
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 cast(bytes, self.impl.export_key(format="DER"))
return keys.export_key(self.impl, self.curve)
def get_type(self) -> KeyType:
return KeyType.ECC_P256
@ -44,7 +58,8 @@ class ECCPrivateKey(PrivateKey):
raise NotImplementedError
def get_public_key(self) -> PublicKey:
return ECCPublicKey(self.impl.public_key())
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: