fast-cipher 0.1.0__tar.gz

fast_cipher-0.1.0/PKG-INFO

@@ -0,0 +1,207 @@
+Metadata-Version: 2.3
+Name: fast-cipher
+Version: 0.1.0
+Summary: FAST format-preserving encryption cipher in pure Python
+Requires-Dist: cryptography>=46.0.5
+Requires-Dist: pytest>=9.0.2 ; extra == 'dev'
+Requires-Python: >=3.14
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# FAST format-preserving cipher for Python
+
+A pure Python implementation of the [FAST cipher](https://github.com/jedisct1/fast),
+a format-preserving encryption (FPE) scheme designed for tokenizing API keys, credentials, and other structured secrets.
+
+For prefix-based tokens (GitHub, AWS, Stripe, etc.), encrypted output keeps the exact same format
+(length, prefix, character set) as the originals, so they pass through systems that validate token formats.
+Heuristic tokens (Fastly, AWS secret keys) are wrapped in a tagged marker since they have no distinguishing prefix.
+
+Fully interoperable with the [C](https://github.com/jedisct1/c-fast),
+[Zig](https://github.com/jedisct1/zig-fast),
+[Go](https://github.com/jedisct1/go-fast), and
+[JavaScript](https://github.com/nickvdyck/js-fast) implementations.
+
+## Installation
+
+```bash
+pip install fast-cipher
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add fast-cipher
+```
+
+## Quick start
+
+The most common use case is encrypting tokens and API keys found inside a block of text.
+`TokenEncryptor` handles scanning, encrypting, and decrypting automatically:
+
+```python
+import os
+from fast_cipher.tokens import TokenEncryptor
+
+key = os.urandom(32)  # AES-128, AES-192, or AES-256
+encryptor = TokenEncryptor(key)
+
+text = """
+Here are the credentials for the staging environment:
+GitHub token: ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghij
+AWS access key: AKIAIOSFODNN7EXAMPLE
+Stripe key: sk_live_ABCDEFGHIJKLMNOPQRSTUVWXab
+"""
+
+encrypted = encryptor.encrypt(text)
+```
+
+For prefix-based tokens the result still looks like valid tokens: same prefixes, same lengths, same
+character sets, but the secret parts have been replaced with ciphertext. Decryption restores the original
+text exactly:
+
+```python
+decrypted = encryptor.decrypt(encrypted)
+assert decrypted == text
+```
+
+## Tweaks
+
+A tweak is optional context data that gets mixed into the encryption.
+The same plaintext encrypted with different tweaks produces different ciphertext,
+which is useful for binding tokens to a specific user, session, or tenant:
+
+```python
+enc_alice = encryptor.encrypt(text, tweak=b"user-alice")
+enc_bob = encryptor.encrypt(text, tweak=b"user-bob")
+
+assert enc_alice != enc_bob
+
+# Each can only be decrypted with the matching tweak
+assert encryptor.decrypt(enc_alice, tweak=b"user-alice") == text
+assert encryptor.decrypt(enc_bob, tweak=b"user-bob") == text
+```
+
+## Filtering by token type
+
+If you only want to encrypt certain kinds of tokens and leave the rest as-is,
+pass a `types` list with the pattern names you care about:
+
+```python
+text = "ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghij and AKIAIOSFODNN7EXAMPLE"
+
+encrypted = encryptor.encrypt(text, types=["github-pat"])
+# The GitHub token is encrypted, but the AWS key is untouched
+```
+
+## Supported token types
+
+The following patterns are detected and encrypted out of the box:
+
+| Provider       | Pattern name(s)                                                                          | Prefix                                         |
+| -------------- | ---------------------------------------------------------------------------------------- | ---------------------------------------------- |
+| Anthropic      | `anthropic`                                                                              | `sk-ant-api03-`                                |
+| AWS            | `aws-access-key`                                                                         | `AKIA`                                         |
+| Datadog        | `datadog`                                                                                | `ddapi_`                                       |
+| GitHub         | `github-pat`, `github-oauth`, `github-user`, `github-server`, `github-refresh`           | `ghp_`, `gho_`, `ghu_`, `ghs_`, `ghr_`         |
+| GitLab         | `gitlab`                                                                                 | `glpat-`                                       |
+| Google         | `google-api`                                                                             | `AIza`                                         |
+| Grafana        | `grafana`                                                                                | `glc_`                                         |
+| HuggingFace    | `huggingface`                                                                            | `hf_`                                          |
+| npm            | `npm`                                                                                    | `npm_`                                         |
+| OpenAI         | `openai`, `openai-legacy`                                                                | `sk-proj-`, `sk-`                              |
+| PyPI           | `pypi`                                                                                   | `pypi-`                                        |
+| SendGrid       | `sendgrid`                                                                               | `SG.`                                          |
+| Slack          | `slack-bot`, `slack-user`                                                                | `xoxb-`, `xoxp-`                               |
+| Stripe         | `stripe-secret-live`, `stripe-publish-live`, `stripe-secret-test`, `stripe-publish-test` | `sk_live_`, `pk_live_`, `sk_test_`, `pk_test_` |
+| Supabase       | `supabase`                                                                               | `sbp_`                                         |
+| Twilio         | `twilio`                                                                                 | `SK`                                           |
+| Vercel         | `vercel`                                                                                 | `vercel_`                                      |
+| Fastly         | `fastly`                                                                                 | *(heuristic, no prefix)*                       |
+| AWS Secret Key | `aws-secret-key`                                                                         | *(heuristic, no prefix)*                       |
+
+Heuristic patterns don't rely on a prefix. They look for strings with high entropy and mixed character classes, which is how secrets like Fastly tokens and AWS secret keys are typically formatted. Because there is no distinguishing prefix, encrypted output is wrapped in an `[ENCRYPTED:<name>]` marker. `decrypt()` will attempt to unwrap anything matching that marker pattern, so avoid feeding text containing literal `[ENCRYPTED:...]` strings that were not produced by `encrypt()`.
+
+## Custom token patterns
+
+You can register your own patterns for tokens that aren't covered by the built-in set.
+A `SimpleTokenPattern` works for anything that has a fixed prefix followed by a body with a known alphabet:
+
+```python
+from fast_cipher.tokens import ALPHANUMERIC, TokenEncryptor
+from fast_cipher.tokens.types import SimpleTokenPattern
+
+my_pattern = SimpleTokenPattern(
+    name="myapp-api-key",
+    prefix="myapp_",
+    body_regex="[A-Za-z0-9]{32}",
+    body_alphabet=ALPHANUMERIC,
+    min_body_length=32,
+)
+
+key = os.urandom(32)
+encryptor = TokenEncryptor(key)
+encryptor.register(my_pattern)
+
+text = "key: myapp_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef"
+encrypted = encryptor.encrypt(text)
+decrypted = encryptor.decrypt(encrypted)
+assert decrypted == text
+```
+
+Registered patterns take priority over built-in ones.
+
+The available alphabets are `DIGITS`, `HEX_LOWER`, `ALPHANUMERIC_UPPER`, `ALPHANUMERIC_LOWER`, `ALPHANUMERIC`, `BASE64`, and `BASE64URL`.
+You can also create your own with `Alphabet(name="my-abc", chars="abc...")`.
+
+## Low-level cipher
+
+`TokenEncryptor` is built on top of `FastCipher`, which you can use directly when you need format-preserving encryption for arbitrary data. It works on sequences of integers in a given radix (base).
+
+For example, to encrypt an 8-digit decimal number:
+
+```python
+from fast_cipher import FastCipher, calculate_recommended_params
+
+params = calculate_recommended_params(radix=10, word_length=8)
+key = os.urandom(32)
+cipher = FastCipher(params, key)
+
+plaintext = [1, 2, 3, 4, 5, 6, 7, 8]
+ciphertext = cipher.encrypt(plaintext)
+
+# Result is still 8 digits, each between 0 and 9
+assert len(ciphertext) == 8
+assert all(0 <= d < 10 for d in ciphertext)
+
+decrypted = cipher.decrypt(ciphertext)
+assert decrypted == plaintext
+```
+
+For raw bytes, use radix 256 with the `encrypt_bytes`/`decrypt_bytes` convenience methods:
+
+```python
+params = calculate_recommended_params(radix=256, word_length=16)
+cipher = FastCipher(params, key)
+
+ciphertext = cipher.encrypt_bytes(b"sensitive data!!")
+plaintext = cipher.decrypt_bytes(ciphertext)
+assert plaintext == b"sensitive data!!"
+```
+
+## Cleanup
+
+When you're done with an encryptor or cipher, call `destroy()` to invalidate the instance:
+
+```python
+encryptor.destroy()
+```
+
+After `destroy()`, any further calls to `encrypt()` or `decrypt()` will raise a `RuntimeError`.
+The method overwrites key references with zero-filled placeholders and clears internal state,
+but Python's garbage collector may retain copies of the original key bytes in memory.
+For applications that require guaranteed memory scrubbing, use a C-level implementation instead.
+
+## Cross-implementation compatibility
+
+Ciphertext produced by any FAST implementation (C, Zig, Go, JavaScript, Python) can be decrypted by any other, as long as the key, radix, word length, and tweak match. This library is tested against the Go test vectors and cross-validated against the JavaScript implementation.

fast_cipher-0.1.0/README.md

@@ -0,0 +1,197 @@
+# FAST format-preserving cipher for Python
+
+A pure Python implementation of the [FAST cipher](https://github.com/jedisct1/fast),
+a format-preserving encryption (FPE) scheme designed for tokenizing API keys, credentials, and other structured secrets.
+
+For prefix-based tokens (GitHub, AWS, Stripe, etc.), encrypted output keeps the exact same format
+(length, prefix, character set) as the originals, so they pass through systems that validate token formats.
+Heuristic tokens (Fastly, AWS secret keys) are wrapped in a tagged marker since they have no distinguishing prefix.
+
+Fully interoperable with the [C](https://github.com/jedisct1/c-fast),
+[Zig](https://github.com/jedisct1/zig-fast),
+[Go](https://github.com/jedisct1/go-fast), and
+[JavaScript](https://github.com/nickvdyck/js-fast) implementations.
+
+## Installation
+
+```bash
+pip install fast-cipher
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add fast-cipher
+```
+
+## Quick start
+
+The most common use case is encrypting tokens and API keys found inside a block of text.
+`TokenEncryptor` handles scanning, encrypting, and decrypting automatically:
+
+```python
+import os
+from fast_cipher.tokens import TokenEncryptor
+
+key = os.urandom(32)  # AES-128, AES-192, or AES-256
+encryptor = TokenEncryptor(key)
+
+text = """
+Here are the credentials for the staging environment:
+GitHub token: ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghij
+AWS access key: AKIAIOSFODNN7EXAMPLE
+Stripe key: sk_live_ABCDEFGHIJKLMNOPQRSTUVWXab
+"""
+
+encrypted = encryptor.encrypt(text)
+```
+
+For prefix-based tokens the result still looks like valid tokens: same prefixes, same lengths, same
+character sets, but the secret parts have been replaced with ciphertext. Decryption restores the original
+text exactly:
+
+```python
+decrypted = encryptor.decrypt(encrypted)
+assert decrypted == text
+```
+
+## Tweaks
+
+A tweak is optional context data that gets mixed into the encryption.
+The same plaintext encrypted with different tweaks produces different ciphertext,
+which is useful for binding tokens to a specific user, session, or tenant:
+
+```python
+enc_alice = encryptor.encrypt(text, tweak=b"user-alice")
+enc_bob = encryptor.encrypt(text, tweak=b"user-bob")
+
+assert enc_alice != enc_bob
+
+# Each can only be decrypted with the matching tweak
+assert encryptor.decrypt(enc_alice, tweak=b"user-alice") == text
+assert encryptor.decrypt(enc_bob, tweak=b"user-bob") == text
+```
+
+## Filtering by token type
+
+If you only want to encrypt certain kinds of tokens and leave the rest as-is,
+pass a `types` list with the pattern names you care about:
+
+```python
+text = "ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghij and AKIAIOSFODNN7EXAMPLE"
+
+encrypted = encryptor.encrypt(text, types=["github-pat"])
+# The GitHub token is encrypted, but the AWS key is untouched
+```
+
+## Supported token types
+
+The following patterns are detected and encrypted out of the box:
+
+| Provider       | Pattern name(s)                                                                          | Prefix                                         |
+| -------------- | ---------------------------------------------------------------------------------------- | ---------------------------------------------- |
+| Anthropic      | `anthropic`                                                                              | `sk-ant-api03-`                                |
+| AWS            | `aws-access-key`                                                                         | `AKIA`                                         |
+| Datadog        | `datadog`                                                                                | `ddapi_`                                       |
+| GitHub         | `github-pat`, `github-oauth`, `github-user`, `github-server`, `github-refresh`           | `ghp_`, `gho_`, `ghu_`, `ghs_`, `ghr_`         |
+| GitLab         | `gitlab`                                                                                 | `glpat-`                                       |
+| Google         | `google-api`                                                                             | `AIza`                                         |
+| Grafana        | `grafana`                                                                                | `glc_`                                         |
+| HuggingFace    | `huggingface`                                                                            | `hf_`                                          |
+| npm            | `npm`                                                                                    | `npm_`                                         |
+| OpenAI         | `openai`, `openai-legacy`                                                                | `sk-proj-`, `sk-`                              |
+| PyPI           | `pypi`                                                                                   | `pypi-`                                        |
+| SendGrid       | `sendgrid`                                                                               | `SG.`                                          |
+| Slack          | `slack-bot`, `slack-user`                                                                | `xoxb-`, `xoxp-`                               |
+| Stripe         | `stripe-secret-live`, `stripe-publish-live`, `stripe-secret-test`, `stripe-publish-test` | `sk_live_`, `pk_live_`, `sk_test_`, `pk_test_` |
+| Supabase       | `supabase`                                                                               | `sbp_`                                         |
+| Twilio         | `twilio`                                                                                 | `SK`                                           |
+| Vercel         | `vercel`                                                                                 | `vercel_`                                      |
+| Fastly         | `fastly`                                                                                 | *(heuristic, no prefix)*                       |
+| AWS Secret Key | `aws-secret-key`                                                                         | *(heuristic, no prefix)*                       |
+
+Heuristic patterns don't rely on a prefix. They look for strings with high entropy and mixed character classes, which is how secrets like Fastly tokens and AWS secret keys are typically formatted. Because there is no distinguishing prefix, encrypted output is wrapped in an `[ENCRYPTED:<name>]` marker. `decrypt()` will attempt to unwrap anything matching that marker pattern, so avoid feeding text containing literal `[ENCRYPTED:...]` strings that were not produced by `encrypt()`.
+
+## Custom token patterns
+
+You can register your own patterns for tokens that aren't covered by the built-in set.
+A `SimpleTokenPattern` works for anything that has a fixed prefix followed by a body with a known alphabet:
+
+```python
+from fast_cipher.tokens import ALPHANUMERIC, TokenEncryptor
+from fast_cipher.tokens.types import SimpleTokenPattern
+
+my_pattern = SimpleTokenPattern(
+    name="myapp-api-key",
+    prefix="myapp_",
+    body_regex="[A-Za-z0-9]{32}",
+    body_alphabet=ALPHANUMERIC,
+    min_body_length=32,
+)
+
+key = os.urandom(32)
+encryptor = TokenEncryptor(key)
+encryptor.register(my_pattern)
+
+text = "key: myapp_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef"
+encrypted = encryptor.encrypt(text)
+decrypted = encryptor.decrypt(encrypted)
+assert decrypted == text
+```
+
+Registered patterns take priority over built-in ones.
+
+The available alphabets are `DIGITS`, `HEX_LOWER`, `ALPHANUMERIC_UPPER`, `ALPHANUMERIC_LOWER`, `ALPHANUMERIC`, `BASE64`, and `BASE64URL`.
+You can also create your own with `Alphabet(name="my-abc", chars="abc...")`.
+
+## Low-level cipher
+
+`TokenEncryptor` is built on top of `FastCipher`, which you can use directly when you need format-preserving encryption for arbitrary data. It works on sequences of integers in a given radix (base).
+
+For example, to encrypt an 8-digit decimal number:
+
+```python
+from fast_cipher import FastCipher, calculate_recommended_params
+
+params = calculate_recommended_params(radix=10, word_length=8)
+key = os.urandom(32)
+cipher = FastCipher(params, key)
+
+plaintext = [1, 2, 3, 4, 5, 6, 7, 8]
+ciphertext = cipher.encrypt(plaintext)
+
+# Result is still 8 digits, each between 0 and 9
+assert len(ciphertext) == 8
+assert all(0 <= d < 10 for d in ciphertext)
+
+decrypted = cipher.decrypt(ciphertext)
+assert decrypted == plaintext
+```
+
+For raw bytes, use radix 256 with the `encrypt_bytes`/`decrypt_bytes` convenience methods:
+
+```python
+params = calculate_recommended_params(radix=256, word_length=16)
+cipher = FastCipher(params, key)
+
+ciphertext = cipher.encrypt_bytes(b"sensitive data!!")
+plaintext = cipher.decrypt_bytes(ciphertext)
+assert plaintext == b"sensitive data!!"
+```
+
+## Cleanup
+
+When you're done with an encryptor or cipher, call `destroy()` to invalidate the instance:
+
+```python
+encryptor.destroy()
+```
+
+After `destroy()`, any further calls to `encrypt()` or `decrypt()` will raise a `RuntimeError`.
+The method overwrites key references with zero-filled placeholders and clears internal state,
+but Python's garbage collector may retain copies of the original key bytes in memory.
+For applications that require guaranteed memory scrubbing, use a C-level implementation instead.
+
+## Cross-implementation compatibility
+
+Ciphertext produced by any FAST implementation (C, Zig, Go, JavaScript, Python) can be decrypted by any other, as long as the key, radix, word length, and tweak match. This library is tested against the Go test vectors and cross-validated against the JavaScript implementation.

fast_cipher-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "fast-cipher"
+version = "0.1.0"
+description = "FAST format-preserving encryption cipher in pure Python"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "cryptography>=46.0.5",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=9.0.2"]
+
+[build-system]
+requires = ["uv_build>=0.10.10,<0.11.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+    "ruff>=0.15.6",
+]

fast_cipher-0.1.0/src/fast_cipher/__init__.py

@@ -0,0 +1,29 @@
+from .cipher import FastCipher
+from .params import calculate_recommended_params
+from .types import (
+    FastError,
+    FastParams,
+    InvalidBranchDistError,
+    InvalidKeyError,
+    InvalidLengthError,
+    InvalidParametersError,
+    InvalidRadixError,
+    InvalidSBoxCountError,
+    InvalidValueError,
+    InvalidWordLengthError,
+)
+
+__all__ = [
+    "FastCipher",
+    "FastError",
+    "FastParams",
+    "InvalidBranchDistError",
+    "InvalidKeyError",
+    "InvalidLengthError",
+    "InvalidParametersError",
+    "InvalidRadixError",
+    "InvalidSBoxCountError",
+    "InvalidValueError",
+    "InvalidWordLengthError",
+    "calculate_recommended_params",
+]

fast_cipher-0.1.0/src/fast_cipher/cipher.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from .core import cdec, cenc
+from .encoding import build_setup1_input, build_setup2_input
+from .prf import derive_key
+from .prng import generate_sequence
+from .sbox import generate_sbox_pool
+from .types import (
+    FastParams,
+    InvalidBranchDistError,
+    InvalidKeyError,
+    InvalidLengthError,
+    InvalidRadixError,
+    InvalidSBoxCountError,
+    InvalidValueError,
+    InvalidWordLengthError,
+)
+
+DERIVED_KEY_SIZE = 32
+
+
+class FastCipher:
+    """FAST format-preserving encryption cipher."""
+
+    def __init__(self, params: FastParams, key: bytes) -> None:
+        _validate_params(params, key)
+        self.params = params
+        self._master_key = bytes(key)
+
+        pool_key_material = derive_key(
+            key, build_setup1_input(params), DERIVED_KEY_SIZE
+        )
+        self._sboxes = generate_sbox_pool(
+            params.radix, params.sbox_count, bytes(pool_key_material)
+        )
+
+        self._cached_tweak: bytes | None = None
+        self._cached_seq: list[int] | None = None
+        self._destroyed = False
+
+    def _ensure_sequence(self, tweak: bytes) -> list[int]:
+        if self._cached_seq is not None and self._cached_tweak == tweak:
+            return self._cached_seq
+
+        seq_key_material = derive_key(
+            self._master_key,
+            build_setup2_input(self.params, tweak),
+            DERIVED_KEY_SIZE,
+        )
+        seq = generate_sequence(
+            self.params.num_layers,
+            self.params.sbox_count,
+            bytes(seq_key_material),
+        )
+        self._cached_tweak = tweak
+        self._cached_seq = seq
+        return seq
+
+    def _assert_alive(self) -> None:
+        if self._destroyed:
+            raise RuntimeError("FastCipher has been destroyed")
+
+    def _validate_input(self, data: bytes | list[int]) -> list[int]:
+        values = list(data)
+        if len(values) != self.params.word_length:
+            raise InvalidLengthError(
+                f"Expected {self.params.word_length} elements, got {len(values)}"
+            )
+        for v in values:
+            if not (0 <= v < self.params.radix):
+                raise InvalidValueError(
+                    f"Value {v} out of range [0, {self.params.radix})"
+                )
+        return values
+
+    def encrypt(self, plaintext: bytes | list[int], tweak: bytes = b"") -> list[int]:
+        self._assert_alive()
+        values = self._validate_input(plaintext)
+        seq = self._ensure_sequence(tweak)
+        return cenc(self.params, self._sboxes, seq, values)
+
+    def decrypt(self, ciphertext: bytes | list[int], tweak: bytes = b"") -> list[int]:
+        self._assert_alive()
+        values = self._validate_input(ciphertext)
+        seq = self._ensure_sequence(tweak)
+        return cdec(self.params, self._sboxes, seq, values)
+
+    def encrypt_bytes(self, plaintext: bytes, tweak: bytes = b"") -> bytes:
+        return bytes(self.encrypt(plaintext, tweak))
+
+    def decrypt_bytes(self, ciphertext: bytes, tweak: bytes = b"") -> bytes:
+        return bytes(self.decrypt(ciphertext, tweak))
+
+    def destroy(self) -> None:
+        self._destroyed = True
+        self._master_key = b"\x00" * len(self._master_key)
+        self._sboxes = []
+        self._cached_seq = None
+        self._cached_tweak = None
+
+
+def _validate_params(params: FastParams, key: bytes) -> None:
+    if params.radix < 4 or params.radix > 256:
+        raise InvalidRadixError("Radix must be between 4 and 256")
+
+    if params.word_length < 1:
+        raise InvalidWordLengthError("Word length must be >= 1")
+
+    if params.num_layers < 1:
+        raise InvalidWordLengthError("num_layers must be >= 1")
+
+    if params.word_length > 1 and params.num_layers % params.word_length != 0:
+        raise InvalidWordLengthError("num_layers must be a multiple of word_length")
+
+    if params.sbox_count < 1:
+        raise InvalidSBoxCountError("S-box count must be >= 1")
+
+    if params.branch_dist1 < 0:
+        raise InvalidBranchDistError("branch_dist1 must be >= 0")
+
+    if params.branch_dist2 < 0:
+        raise InvalidBranchDistError("branch_dist2 must be >= 0")
+
+    if params.word_length > 1:
+        if params.branch_dist1 > params.word_length - 2:
+            raise InvalidBranchDistError("branch_dist1 must be <= word_length - 2")
+        if params.branch_dist2 == 0 or params.branch_dist2 > params.word_length - 1:
+            raise InvalidBranchDistError("branch_dist2 is out of valid range")
+
+    if len(key) not in (16, 24, 32):
+        raise InvalidKeyError("Key must be 16, 24, or 32 bytes")

fast_cipher-0.1.0/src/fast_cipher/core.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from .layers import ds_layer, es_layer
+from .sbox import SBox
+from .types import FastParams
+
+
+def cenc(
+    params: FastParams,
+    sboxes: list[SBox],
+    seq: list[int],
+    plaintext: list[int],
+) -> list[int]:
+    """Component encryption: apply all ES layers in forward order."""
+    data = list(plaintext)
+    if params.word_length == 1:
+        for layer in range(params.num_layers):
+            data[0] = sboxes[seq[layer]].perm[data[0]]
+        return data
+    for layer in range(params.num_layers):
+        es_layer(params, sboxes[seq[layer]], data)
+    return data
+
+
+def cdec(
+    params: FastParams,
+    sboxes: list[SBox],
+    seq: list[int],
+    ciphertext: list[int],
+) -> list[int]:
+    """Component decryption: apply all DS layers in reverse order."""
+    data = list(ciphertext)
+    if params.word_length == 1:
+        for layer in range(params.num_layers - 1, -1, -1):
+            data[0] = sboxes[seq[layer]].inv[data[0]]
+        return data
+    for layer in range(params.num_layers - 1, -1, -1):
+        ds_layer(params, sboxes[seq[layer]], data)
+    return data

fast_cipher-0.1.0/src/fast_cipher/encoding.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import struct
+
+from .types import FastParams
+
+_LABEL_INSTANCE1 = b"instance1"
+_LABEL_INSTANCE2 = b"instance2"
+_LABEL_FPE_POOL = b"FPE Pool"
+_LABEL_FPE_SEQ = b"FPE SEQ"
+_LABEL_TWEAK = b"tweak"
+
+
+def _u32be(value: int) -> bytes:
+    return struct.pack(">I", value)
+
+
+def encode_parts(parts: list[bytes]) -> bytes:
+    buf = bytearray(_u32be(len(parts)))
+    for part in parts:
+        buf.extend(_u32be(len(part)))
+        buf.extend(part)
+    return bytes(buf)
+
+
+def build_setup1_input(params: FastParams) -> bytes:
+    return encode_parts(
+        [
+            _LABEL_INSTANCE1,
+            _u32be(params.radix),
+            _u32be(params.sbox_count),
+            _LABEL_FPE_POOL,
+        ]
+    )
+
+
+def build_setup2_input(params: FastParams, tweak: bytes) -> bytes:
+    return encode_parts(
+        [
+            _LABEL_INSTANCE1,
+            _u32be(params.radix),
+            _u32be(params.sbox_count),
+            _LABEL_INSTANCE2,
+            _u32be(params.word_length),
+            _u32be(params.num_layers),
+            _u32be(params.branch_dist1),
+            _u32be(params.branch_dist2),
+            _LABEL_FPE_SEQ,
+            _LABEL_TWEAK,
+            tweak,
+        ]
+    )