[tests] add tests for bls/tz4

test/common.py

@@ -50,6 +50,13 @@
     2
 )
 
+TZ4_ACCOUNT = Account(
+    "m/44'/1729'/0'/0'",
+    SigScheme.BLS,
+    "BLsk2Q1AdMSKNJbM1fLqHEWgaEDUz2odGrgPuCV1bxtzAedVEC2RSz",
+    3
+)
+
 LONG_TZ1_ACCOUNT = Account(
     "m/9'/12'/13'/8'/78'",
     SigScheme.ED25519,
@@ -75,13 +82,18 @@
     TZ3_ACCOUNT,
 ]
 
-ACCOUNTS = TZ1_ACCOUNTS + TZ2_ACCOUNTS + TZ3_ACCOUNTS
+TZ4_ACCOUNTS = [
+    TZ4_ACCOUNT,
+]
+
+ACCOUNTS = TZ1_ACCOUNTS + TZ2_ACCOUNTS + TZ3_ACCOUNTS + TZ4_ACCOUNTS
 
 ZEBRA_ACCOUNTS = [
     TZ1_ACCOUNT,
     TZ2_ACCOUNT,
     TZ3_ACCOUNT,
     BIP32_TZ1_ACCOUNT,
+    TZ4_ACCOUNT,
 ]
 
 EMPTY_PATH = BipPath.from_string("m")

test/conftest.py

@@ -15,11 +15,14 @@
 
 """Pytest configuration file."""
 
+from functools import wraps
 import pytest
+
 from ragger.backend import BackendInterface
 from ragger.conftest import configuration
 from ragger.firmware import Firmware
 from ragger.navigator import Navigator
+from utils.account import SigScheme
 from utils.client import TezosClient
 from utils.navigator import TezosNavigator
 from common import DEFAULT_SEED
@@ -44,3 +47,17 @@ def tezos_navigator(
         test_name: str) -> TezosNavigator:
     """Get a tezos navigator."""
     return TezosNavigator(backend, firmware, client, navigator, golden_run, test_name)
+
+def skip_nanos_bls(func):
+    """Allows to skip tests with BLS `account` on NanoS device"""
+    @wraps(func)
+    def wrap(*args, **kwargs):
+        account = kwargs.get("account", None)
+        firmware = kwargs.get("firmware", None)
+        if firmware is not None \
+           and firmware.name == "nanos" \
+           and account is not None \
+           and account.sig_scheme == SigScheme.BLS:
+            pytest.skip("NanoS does not support BLS")
+        return func(*args, **kwargs)
+    return wrap

test/test_instructions.py

@@ -22,12 +22,14 @@
 import hmac
 import time
 
+from functools import wraps
 import pytest
+from conftest import skip_nanos_bls
 
 from ragger.backend import BackendInterface
 from ragger.firmware import Firmware
 from utils.client import TezosClient, Version, Hwm, StatusCode
-from utils.account import Account, PublicKey
+from utils.account import Account, PublicKey, SigScheme
 from utils.helper import get_current_commit
 from utils.message import (
     Message,
@@ -57,6 +59,7 @@
     ZEBRA_ACCOUNTS,
 )
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", [None, *ACCOUNTS])
 def test_review_home(account: Optional[Account],
                      backend: BackendInterface,
@@ -502,6 +505,7 @@ def test_ledger_screensaver(firmware: Firmware,
         assert (res.find("y") != -1), "Ledger screensaver should have activated"
 
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ZEBRA_ACCOUNTS)
 def test_benchmark_attestation_time(account: Account,
                                     client: TezosClient,
@@ -549,6 +553,7 @@ def test_benchmark_attestation_time(account: Account,
         )
 
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 def test_authorize_baking(account: Account, tezos_navigator: TezosNavigator) -> None:
     """Test the AUTHORIZE_BAKING instruction."""
@@ -599,6 +604,7 @@ def test_deauthorize(firmware: Firmware,
         test_hwm=Hwm(0, 0)
     )
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 def test_get_auth_key(
         account: Account,
@@ -613,6 +619,7 @@ def test_get_auth_key(
     assert path == account.path, \
         f"Expected {account.path} but got {path}"
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 def test_get_auth_key_with_curve(
         account: Account,
@@ -630,6 +637,7 @@ def test_get_auth_key_with_curve(
     assert sig_scheme == account.sig_scheme, \
         f"Expected {account.sig_scheme.name} but got {sig_scheme.name}"
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 def test_get_public_key_baking(account: Account, tezos_navigator: TezosNavigator) -> None:
     """Test the AUTHORIZE_BAKING instruction."""
@@ -644,6 +652,7 @@ def test_get_public_key_baking(account: Account, tezos_navigator: TezosNavigator
         f"Expected public key {account.public_key} but got {public_key}"
 
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 def test_get_public_key_silent(account: Account, client: TezosClient) -> None:
     """Test the GET_PUBLIC_KEY instruction."""
@@ -654,6 +663,7 @@ def test_get_public_key_silent(account: Account, client: TezosClient) -> None:
         f"Expected public key {account.public_key} but got {public_key}"
 
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 def test_get_public_key_prompt(account: Account, tezos_navigator: TezosNavigator) -> None:
     """Test the PROMPT_PUBLIC_KEY instruction."""
@@ -679,6 +689,7 @@ def test_reset_app_context(tezos_navigator: TezosNavigator) -> None:
     )
 
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 def test_setup_app_context(account: Account, tezos_navigator: TezosNavigator) -> None:
     """Test the SETUP instruction."""
@@ -707,6 +718,7 @@ def test_setup_app_context(account: Account, tezos_navigator: TezosNavigator) ->
     )
 
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 def test_get_main_hwm(
         account: Account,
@@ -731,6 +743,7 @@ def test_get_main_hwm(
         f"Expected main hmw {main_hwm} but got {received_main_hwm}"
 
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 def test_get_all_hwm(
         account: Account,
@@ -797,6 +810,7 @@ def build_block(level, current_round, chain_id):
     )
 
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 @pytest.mark.parametrize("with_hash", [False, True])
 def test_sign_preattestation(
@@ -854,6 +868,7 @@ def test_sign_preattestation(
     )
 
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 @pytest.mark.parametrize("with_hash", [False, True])
 def test_sign_attestation(
@@ -911,6 +926,7 @@ def test_sign_attestation(
     )
 
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 @pytest.mark.parametrize("with_hash", [False, True])
 def test_sign_attestation_dal(
@@ -968,6 +984,7 @@ def test_sign_attestation_dal(
     )
 
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 @pytest.mark.parametrize("with_hash", [False, True])
 def test_sign_block(
@@ -1126,11 +1143,13 @@ def test_sign_level_authorized(
             client.sign_message(account, message_2)
 
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 @pytest.mark.parametrize("with_hash", [False, True])
 def test_sign_delegation(
         account: Account,
         with_hash: bool,
+        firmware: Firmware,
         tezos_navigator: TezosNavigator) -> None:
     """Test the SIGN(_WITH_HASH) instruction on delegation."""
     snap_path = Path(f"{account}")
@@ -1261,11 +1280,13 @@ def test_sign_delegation_constraints(
         )
 
 
+@skip_nanos_bls
 @pytest.mark.parametrize("account", ACCOUNTS)
 @pytest.mark.parametrize("with_hash", [False, True])
 def test_sign_reveal(
         account: Account,
         with_hash: bool,
+        firmware: Firmware,
         client: TezosClient,
         tezos_navigator: TezosNavigator) -> None:
     """Test the SIGN(_WITH_HASH) instruction on reveal."""
@@ -1778,7 +1799,7 @@ def get_hmac_key(account):
     ("0123456789abcdef0123456789abcdef0123456789abcdef")
 ]
 
-# This HMAC test don't pass with tz2 and tz3
+# This HMAC test don't pass with tz2, tz3 and tz4
 @pytest.mark.parametrize("account", TZ1_ACCOUNTS)
 @pytest.mark.parametrize("message_hex", HMAC_TEST_SET)
 def test_hmac(

test/utils/account.py

@@ -18,10 +18,12 @@
 from enum import IntEnum
 from typing import Union
 
+from hashlib import blake2b
 import base58
 import pysodium
 import secp256k1
 import fastecdsa
+from py_ecc.bls import G2MessageAugmentation as bls
 
 import pytezos
 from pytezos.crypto.encoding import base58_encode
@@ -36,6 +38,7 @@ class SigScheme(IntEnum):
     SECP256K1     = 0x01
     SECP256R1     = 0x02
     BIP32_ED25519 = 0x03
+    BLS           = 0x04
     DEFAULT       = ED25519
 
 class BipPath:
@@ -127,6 +130,8 @@ def from_bytes(cls, data: bytes, sig_scheme: SigScheme) -> str:
             prefix = bytes([13, 115, 101, 19, 63]) if sig_scheme == SigScheme.SECP256K1 \
                 else bytes([54, 240, 44, 52])
             data = Signature.from_secp256_tlv(data)
+        elif sig_scheme == SigScheme.BLS:
+            prefix = bytes([40, 171, 64, 207])
         else:
             assert False, f"Wrong signature type: {sig_scheme}"
 
@@ -180,11 +185,25 @@ def from_bytes(data: bytes, sig_scheme: SigScheme) -> str:
             data = bytes(kind) + data[:32]
             return base58_encode(data, prefix).decode()
 
+        # BLS
+        if sig_scheme == SigScheme.BLS:
+            assert kind == PublicKey.CompressionKind.UNCOMPRESSED, \
+                f"Wrong BLS public key compression kind: {kind}"
+            assert len(data) == 2 * 48, \
+                f"Wrong BLS public key length: {len(data)}"
+            return base58.b58encode_check(bytes([6, 149, 135, 204]) + data[:48]).decode()
+
         assert False, f"Wrong signature type: {sig_scheme}"
 
 class Account:
     """Class representing account."""
 
+    path: BipPath
+    sig_scheme: SigScheme
+    # key: str == BLS.sk since pytezos do not support BLS for now
+    key: Union[pytezos.Key, str]
+    nanos_screens: int
+
     def __init__(self,
                  path: Union[BipPath, str, bytes],
                  sig_scheme: SigScheme,
@@ -195,31 +214,44 @@ def __init__(self,
             BipPath.from_bytes(path) if isinstance(path, bytes) else \
             path
         self.sig_scheme: SigScheme = sig_scheme
-        self.key: pytezos.Key = pytezos.pytezos.using(key=key).key
+        if self.sig_scheme == SigScheme.BLS:
+            self.key: str = key
+        else:
+            self.key: pytezos.Key = pytezos.pytezos.using(key=key).key
         self.nanos_screens: int = nanos_screens
 
     @property
     def public_key_hash(self) -> str:
         """public_key_hash of the account."""
+        if isinstance(self.key, str):
+            pk_raw = base58.b58decode_check(self.public_key.encode())[4:]
+            pkh_raw = blake2b(pk_raw, digest_size=20).digest()
+            return base58.b58encode_check(bytes([6, 161, 166]) + pkh_raw).decode()
+
         return self.key.public_key_hash()
 
     @property
     def public_key(self) -> str:
         """public_key of the account."""
+        if isinstance(self.key, str):
+            sk_raw = base58.b58decode_check(self.secret_key.encode())[4:]
+            sk_int = int.from_bytes(sk_raw, 'little')
+            pk_raw = bls.SkToPk(sk_int)
+            return base58.b58encode_check(bytes([6, 149, 135, 204]) + pk_raw).decode()
+
         return self.key.public_key()
 
     @property
     def secret_key(self) -> str:
         """secret_key of the account."""
+        if isinstance(self.key, str):
+            return self.key
+
         return self.key.secret_key()
 
     def __repr__(self) -> str:
         return f"{self.sig_scheme.name}_{self.public_key_hash}"
 
-    def sign(self, message: Union[str, bytes], generic: bool = False) -> bytes:
-        """Sign a raw sequence of bytes."""
-        return self.key.sign(message, generic)
-
     def sign_prehashed_message(self, prehashed_message: bytes) -> bytes:
         """Sign a raw sequence of bytes already hashed."""
         if self.sig_scheme in [
@@ -245,6 +277,11 @@ def sign_prehashed_message(self, prehashed_message: bytes) -> bytes:
                 prehashed=True
             )
             return r.to_bytes(32, 'big') + s.to_bytes(32, 'big')
+        if self.sig_scheme == SigScheme.BLS:
+            sk_raw = base58.b58decode_check(self.secret_key.encode())[4:]
+            sk_int = int.from_bytes(sk_raw, 'little') # Tezos encode it in 'little'
+            return bls.Sign(sk_int, prehashed_message)
+
         raise ValueError(f"Account do not have a right signature type: {self.sig_scheme}")
 
     def check_signature(self,
@@ -255,7 +292,15 @@ def check_signature(self,
             message = bytes.fromhex(message)
         if isinstance(signature, bytes):
             signature = Signature.from_bytes(signature, self.sig_scheme)
-        assert self.key.verify(signature.encode(), message), \
-            f"Fail to verify signature {signature}, \n\
-            with account {self} \n\
-            and message {message.hex()}"
+        if isinstance(self.key, str):
+            pk_raw = base58.b58decode_check(self.public_key.encode())[4:]
+            signature_raw = base58.b58decode_check(signature.encode())[4:]
+            assert bls.Verify(pk_raw, message, signature_raw), \
+                f"Fail to verify signature {signature}, \n\
+                with account {self} \n\
+                and message {message.hex()}"
+        else:
+            assert self.key.verify(signature.encode(), message), \
+                f"Fail to verify signature {signature}, \n\
+                with account {self} \n\
+                and message {message.hex()}"

test/utils/client.py

@@ -169,6 +169,7 @@ class StatusCode(IntEnum):
     HID_REQUIRED              = 0x6983
     CLASS                     = 0x6e00
     MEMORY_ERROR              = 0x9200
+    CX_ERR                    = 0x9001
 
     @contextmanager
     def expected(self) -> Generator[None, None, None]: