Reject non-ASCII normalized input

Reject non-ASCII identifiers and indices before lowercasing so Unicode
characters cannot normalize into valid Bech32 symbols. Keep ASCII
case-insensitive behavior and whitespace-tolerant card confirmation unchanged.

Security: closes a validation and confirmation boundary where a non-parseable
recovery card could alias valid ASCII text.

Validation: python -m pytest -q; python -O -m pytest -q; Ruff check and format;
strict mypy.

Author: BenWestgate

src/codex32/bip93.py

@@ -51,11 +51,15 @@ def __post_init__(self) -> None:
             raise InvalidThreshold("threshold must be 0 or an integer from 2 through 9")
         if not isinstance(self.identifier, str):
             raise InvalidIdentifier("identifier must be str")
+        if not self.identifier.isascii():
+            raise InvalidIdentifier("identifier must contain only ASCII Bech32 symbols")
         identifier = self.identifier.lower()
         if len(identifier) != 4 or any(character not in CHARSET for character in identifier):
             raise InvalidIdentifier("identifier must be exactly four Bech32 symbols")
         if not isinstance(self.index, str):
             raise InvalidShareIndex("share index must be str")
+        if not self.index.isascii():
+            raise InvalidShareIndex("share index must be an ASCII Bech32 symbol")
         index = self.index.lower()
         if len(index) != 1 or index not in CHARSET:
             raise InvalidShareIndex("share index must be one Bech32 symbol")
@@ -333,6 +337,8 @@ def recover_secret(shares: Sequence[Share]) -> Secret:
 def _normalize_target(value: object, *, label: str) -> str:
     if not isinstance(value, str):
         raise InvalidTargetIndex(f"{label} must be one Bech32 symbol")
+    if not value.isascii():
+        raise InvalidTargetIndex(f"{label} must be an ASCII Bech32 symbol")
     normalized = value.lower()
     if len(normalized) != 1 or normalized not in CHARSET or normalized == "s":
         raise InvalidTargetIndex(f"{label} must be one of {IDX_SORT[1:].upper()}")

src/codex32/generation.py

@@ -68,6 +68,8 @@ def _threshold(value: object, *, allow_zero: bool = True) -> int:
 def _identifier(value: object) -> str:
     if not isinstance(value, str):
         raise InvalidIdentifier("identifier must be str")
+    if not value.isascii():
+        raise InvalidIdentifier("identifier must contain only ASCII Bech32 symbols")
     value = value.lower()
     if len(value) != 4 or any(character not in CHARSET for character in value):
         raise InvalidIdentifier("identifier must be four Bech32 symbols")
@@ -77,6 +79,8 @@ def _identifier(value: object) -> str:
 def _index(value: object) -> str:
     if not isinstance(value, str) or len(value) != 1:
         raise InvalidShareSelection("each output index must be one Bech32 symbol")
+    if not value.isascii():
+        raise InvalidShareSelection("each output index must be an ASCII Bech32 symbol")
     value = value.lower()
     if value not in ORDINARY_INDICES:
         raise InvalidShareSelection("output indices must be ordinary non-S symbols")
@@ -352,7 +356,9 @@ def confirm(self, text: str) -> ConfirmationResult:
             raise CeremonyStateError("request a card before confirming it")
         if not isinstance(text, str):
             raise TypeError("confirmation text must be str")
-        observed = "".join(text.split()).lower()
+        observed = "".join(text.split())
+        if observed.isascii():
+            observed = observed.lower()
         expected = self._pending.text.lower()
         mismatched = tuple(
             group + 1

tests/test_generation.py

@@ -137,6 +137,20 @@ def test_raw_bytes_accept_random_or_explicit_identifiers() -> None:
     secret = generate_master_seed(raw, identifier="TEST")
     assert len(random_secret.header.identifier) == 4
     assert secret.header.identifier == "test"
+    with pytest.raises(InvalidIdentifier):
+        generate_master_seed(raw, identifier="tesK")
+
+
+def test_confirmation_rejects_unicode_that_lowercases_to_bech32(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    value = bytes([generation_module.CHARSET.index("k")]) * 26
+    monkeypatch.setattr(generation_module.secrets, "token_bytes", lambda _length: value)
+    ceremony = CreationCeremony.master_seed(threshold=2, indices="ac", identifier="test")
+    pending = ceremony.next_share()
+    invalid = pending.text.replace("k", "K", 1)
+    assert invalid != pending.text
+    assert not ceremony.confirm(invalid).accepted
 
 
 def test_explicit_and_random_output_order_contracts() -> None:

tests/test_public_api.py

@@ -95,7 +95,9 @@ def test_master_seed_factory_can_only_construct_index_s() -> None:
     (
         ((1, "test", "s"), InvalidThreshold),
         ((2, "bad", "a"), InvalidIdentifier),
+        ((2, "tesK", "a"), InvalidIdentifier),
         ((0, "test", "a"), InvalidShareIndex),
+        ((2, "test", "K"), InvalidShareIndex),
     ),
 )
 def test_header_invariants(arguments: tuple[object, ...], error: type[Exception]) -> None:

tests/test_sharing.py

@@ -153,7 +153,7 @@ def __getitem__(self, _position: int) -> Share:
         recover_secret(OversizedSequence())  # type: ignore[arg-type]
 
 
-@pytest.mark.parametrize("target", ("s", "i", "b", "?", "aa", "", 3))
+@pytest.mark.parametrize("target", ("s", "i", "b", "?", "aa", "", "K", 3))
 def test_invalid_targets_are_rejected(target: object) -> None:
     secret, masks = _ms_basis()
     with pytest.raises(InvalidTargetIndex):