Make eth-keys optional (#392)

Author: kigawas

.coveragerc

@@ -28,14 +28,15 @@ jobs:
       - run: brew install automake
         if: matrix.os == 'macos-latest'
 
-      - run: poetry install --with test
+      - run: poetry install --with test -E eth
 
       - name: Run test
         run: poetry run pytest -s --cov=ecies tests --cov-report xml
 
       - run: ./scripts/ci.sh
 
       - uses: codecov/codecov-action@v4
+        if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13'
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
 

.github/workflows/ci.yml

@@ -4,6 +4,7 @@
 
 from .config import ECIES_CONFIG, Config
 from .utils import (
+    compat_eth_public_key,
     decapsulate,
     encapsulate,
     generate_key,
@@ -16,7 +17,9 @@
 __all__ = ["encrypt", "decrypt", "ECIES_CONFIG"]
 
 
-def encrypt(receiver_pk: Union[str, bytes], msg: bytes, config: Config = ECIES_CONFIG) -> bytes:
+def encrypt(
+    receiver_pk: Union[str, bytes], msg: bytes, config: Config = ECIES_CONFIG
+) -> bytes:
     """
     Encrypt with receiver's secp256k1 public key
 
@@ -35,21 +38,21 @@ def encrypt(receiver_pk: Union[str, bytes], msg: bytes, config: Config = ECIES_C
     if isinstance(receiver_pk, str):
         pk = hex2pk(receiver_pk)
     elif isinstance(receiver_pk, bytes):
-        pk = PublicKey(receiver_pk)
+        pk = PublicKey(compat_eth_public_key(receiver_pk))
     else:
         raise TypeError("Invalid public key type")
 
     ephemeral_sk = generate_key()
-    ephemeral_pk = ephemeral_sk.public_key.format(
-        config.is_ephemeral_key_compressed
-    )
+    ephemeral_pk = ephemeral_sk.public_key.format(config.is_ephemeral_key_compressed)
 
     sym_key = encapsulate(ephemeral_sk, pk, config)
     encrypted = sym_encrypt(sym_key, msg, config)
     return ephemeral_pk + encrypted
 
 
-def decrypt(receiver_sk: Union[str, bytes], msg: bytes, config: Config = ECIES_CONFIG) -> bytes:
+def decrypt(
+    receiver_sk: Union[str, bytes], msg: bytes, config: Config = ECIES_CONFIG
+) -> bytes:
     """
     Decrypt with receiver's secp256k1 private key
 

ecies/__init__.py

@@ -69,12 +69,12 @@ def main():
     args = parser.parse_args()
     if args.generate:
         k = generate_eth_key()
-        sk, pub, addr = (
+        sk, pk, addr = (
             k.to_hex(),
             k.public_key.to_hex(),
             k.public_key.to_checksum_address(),
         )
-        print("Private: {}\nPublic: {}\nAddress: {}".format(sk, pub, addr))
+        print("Private: {}\nPublic: {}\nAddress: {}".format(sk, pk, addr))
         return
 
     if args.encrypt == args.decrypt:

ecies/__main__.py

@@ -1,4 +1,5 @@
 from .elliptic import (
+    compat_eth_public_key,
     decapsulate,
     encapsulate,
     generate_eth_key,
@@ -20,4 +21,5 @@
     "hex2pk",
     "decapsulate",
     "encapsulate",
+    "compat_eth_public_key",
 ]

ecies/utils/__init__.py

@@ -1,6 +1,5 @@
 from coincurve import PrivateKey, PublicKey
 from coincurve.utils import get_valid_secret
-from eth_keys import keys
 
 from ..config import ECIES_CONFIG, Config
 from .hex import decode_hex
@@ -30,8 +29,9 @@ def generate_eth_key():
     eth_keys.keys.PrivateKey
         An ethereum key
 
-    >>> k = generate_eth_key()
     """
+    from eth_keys import keys
+
     return keys.PrivateKey(get_valid_secret())
 
 
@@ -51,23 +51,14 @@ def hex2pk(pk_hex: str) -> PublicKey:
     coincurve.PublicKey
         A secp256k1 public key
 
-    >>> from ecies.utils import sha256
-    >>> data = b'0' * 32
-    >>> data_hash = sha256(data)
-    >>> eth_sk = generate_eth_key()
-    >>> cc_sk = hex2sk(eth_sk.to_hex())
-    >>> eth_sk.sign_msg_hash(data_hash).to_bytes() == cc_sk.sign_recoverable(data)
-    True
-    >>> pk_hex = eth_sk.public_key.to_hex()
-    >>> computed_pk = hex2pk(pk_hex)
-    >>> computed_pk == cc_sk.public_key
-    True
     """
-    uncompressed = decode_hex(pk_hex)
-    if len(uncompressed) == 64:  # eth public key format
-        uncompressed = b"\x04" + uncompressed
+    return PublicKey(compat_eth_public_key(decode_hex(pk_hex)))
+
 
-    return PublicKey(uncompressed)
+def compat_eth_public_key(data: bytes):
+    if len(data) == 64:  # eth public key format
+        data = b"\x04" + data
+    return data
 
 
 def hex2sk(sk_hex: str) -> PrivateKey:
@@ -84,18 +75,14 @@ def hex2sk(sk_hex: str) -> PrivateKey:
     coincurve.PrivateKey
         A secp256k1 private key
 
-    >>> k = generate_eth_key()
-    >>> sk_hex = k.to_hex()
-    >>> pk_hex = k.public_key.to_hex()
-    >>> computed_sk = hex2sk(sk_hex)
-    >>> computed_sk.to_int() == int(k.to_hex(), 16)
-    True
     """
     return PrivateKey(decode_hex(sk_hex))
 
 
 # private below
-def encapsulate(private_key: PrivateKey, peer_public_key: PublicKey, config: Config = ECIES_CONFIG) -> bytes:
+def encapsulate(
+    private_key: PrivateKey, peer_public_key: PublicKey, config: Config = ECIES_CONFIG
+) -> bytes:
     is_compressed = config.is_hkdf_key_compressed
     shared_point = peer_public_key.multiply(private_key.secret)
     master = private_key.public_key.format(is_compressed) + shared_point.format(
@@ -104,7 +91,9 @@ def encapsulate(private_key: PrivateKey, peer_public_key: PublicKey, config: Con
     return derive_key(master)
 
 
-def decapsulate(public_key: PublicKey, peer_private_key: PrivateKey, config: Config = ECIES_CONFIG) -> bytes:
+def decapsulate(
+    public_key: PublicKey, peer_private_key: PrivateKey, config: Config = ECIES_CONFIG
+) -> bytes:
     is_compressed = config.is_hkdf_key_compressed
     shared_point = public_key.multiply(peer_private_key.secret)
     master = public_key.format(is_compressed) + shared_point.format(is_compressed)