From c47c208889493c02b28b23c8646a8e91db59a8f2 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Fri, 20 Feb 2026 10:04:30 +0200 Subject: [PATCH 01/47] Scaffolding for the rust python package --- .github/workflows/CI.yml | 185 +++++++++++++++++++++++++++++++++++++++ .gitignore | 2 + Cargo.lock | 172 ++++++++++++++++++++++++++++++++++++ Cargo.toml | 12 +++ pyproject.toml | 13 +++ src/lib.rs | 13 +++ 6 files changed, 397 insertions(+) create mode 100644 .github/workflows/CI.yml create mode 100644 .gitignore create mode 100644 Cargo.lock create mode 100644 Cargo.toml create mode 100644 pyproject.toml create mode 100644 src/lib.rs diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml new file mode 100644 index 0000000..0f362f6 --- /dev/null +++ b/.github/workflows/CI.yml @@ -0,0 +1,185 @@ +# This file is autogenerated by maturin v1.12.3 +# To update, run +# +# maturin generate-ci github +# +name: CI + +on: + push: + branches: + - main + tags: + - '*' + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + linux: + runs-on: ${{ matrix.platform.runner }} + strategy: + matrix: + platform: + - runner: ubuntu-22.04 + target: x86_64 + - runner: ubuntu-22.04 + target: x86 + - runner: ubuntu-22.04 + target: aarch64 + - runner: ubuntu-22.04 + target: armv7 + - runner: ubuntu-22.04 + target: s390x + - runner: ubuntu-22.04 + target: ppc64le + steps: + - uses: actions/checkout@v6 + - uses: actions/setup-python@v6 + with: + python-version: 3.x + - name: Build wheels + uses: PyO3/maturin-action@v1 + with: + target: ${{ matrix.platform.target }} + args: --release --out dist --find-interpreter + sccache: ${{ !startsWith(github.ref, 'refs/tags/') }} + manylinux: auto + - name: Upload wheels + uses: actions/upload-artifact@v5 + with: + name: wheels-linux-${{ matrix.platform.target }} + path: dist + + musllinux: + runs-on: ${{ matrix.platform.runner }} + strategy: + matrix: + platform: + - runner: ubuntu-22.04 + target: x86_64 + - runner: ubuntu-22.04 + target: x86 + - runner: ubuntu-22.04 + target: aarch64 + - runner: ubuntu-22.04 + target: armv7 + steps: + - uses: actions/checkout@v6 + - uses: actions/setup-python@v6 + with: + python-version: 3.x + - name: Build wheels + uses: PyO3/maturin-action@v1 + with: + target: ${{ matrix.platform.target }} + args: --release --out dist --find-interpreter + sccache: ${{ !startsWith(github.ref, 'refs/tags/') }} + manylinux: musllinux_1_2 + - name: Upload wheels + uses: actions/upload-artifact@v5 + with: + name: wheels-musllinux-${{ matrix.platform.target }} + path: dist + + windows: + runs-on: ${{ matrix.platform.runner }} + strategy: + matrix: + platform: + - runner: windows-latest + target: x64 + python_arch: x64 + - runner: windows-latest + target: x86 + python_arch: x86 + - runner: windows-11-arm + target: aarch64 + python_arch: arm64 + steps: + - uses: actions/checkout@v6 + - uses: actions/setup-python@v6 + with: + python-version: 3.13 + architecture: ${{ matrix.platform.python_arch }} + - name: Build wheels + uses: PyO3/maturin-action@v1 + with: + target: ${{ matrix.platform.target }} + args: --release --out dist --find-interpreter + sccache: ${{ !startsWith(github.ref, 'refs/tags/') }} + - name: Upload wheels + uses: actions/upload-artifact@v5 + with: + name: wheels-windows-${{ matrix.platform.target }} + path: dist + + macos: + runs-on: ${{ matrix.platform.runner }} + strategy: + matrix: + platform: + - runner: macos-15-intel + target: x86_64 + - runner: macos-latest + target: aarch64 + steps: + - uses: actions/checkout@v6 + - uses: actions/setup-python@v6 + with: + python-version: 3.x + - name: Build wheels + uses: PyO3/maturin-action@v1 + with: + target: ${{ matrix.platform.target }} + args: --release --out dist --find-interpreter + sccache: ${{ !startsWith(github.ref, 'refs/tags/') }} + - name: Upload wheels + uses: actions/upload-artifact@v5 + with: + name: wheels-macos-${{ matrix.platform.target }} + path: dist + + sdist: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + - name: Build sdist + uses: PyO3/maturin-action@v1 + with: + command: sdist + args: --out dist + - name: Upload sdist + uses: actions/upload-artifact@v5 + with: + name: wheels-sdist + path: dist + + release: + name: Release + runs-on: ubuntu-latest + if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }} + needs: [linux, musllinux, windows, macos, sdist] + permissions: + # Use to sign the release artifacts + id-token: write + # Used to upload release artifacts + contents: write + # Used to generate artifact attestation + attestations: write + steps: + - uses: actions/download-artifact@v6 + - name: Generate artifact attestation + uses: actions/attest-build-provenance@v3 + with: + subject-path: 'wheels-*/*' + - name: Install uv + if: ${{ startsWith(github.ref, 'refs/tags/') }} + uses: astral-sh/setup-uv@v7 + - name: Publish to PyPI + if: ${{ startsWith(github.ref, 'refs/tags/') }} + run: uv publish 'wheels-*/*' + env: + UV_PUBLISH_TOKEN: ${{ secrets.PYPI_API_TOKEN }} diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3940810 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +.venv/ +target/ diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..0a10417 --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,172 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "autocfg" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "indoc" +version = "2.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706" +dependencies = [ + "rustversion", +] + +[[package]] +name = "libc" +version = "0.2.182" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112" + +[[package]] +name = "memoffset" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" +dependencies = [ + "autocfg", +] + +[[package]] +name = "once_cell" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + +[[package]] +name = "portable-atomic" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49" + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "pykyber" +version = "0.1.0" +dependencies = [ + "pyo3", +] + +[[package]] +name = "pyo3" +version = "0.27.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab53c047fcd1a1d2a8820fe84f05d6be69e9526be40cb03b73f86b6b03e6d87d" +dependencies = [ + "indoc", + "libc", + "memoffset", + "once_cell", + "portable-atomic", + "pyo3-build-config", + "pyo3-ffi", + "pyo3-macros", + "unindent", +] + +[[package]] +name = "pyo3-build-config" +version = "0.27.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b455933107de8642b4487ed26d912c2d899dec6114884214a0b3bb3be9261ea6" +dependencies = [ + "target-lexicon", +] + +[[package]] +name = "pyo3-ffi" +version = "0.27.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c85c9cbfaddf651b1221594209aed57e9e5cff63c4d11d1feead529b872a089" +dependencies = [ + "libc", + "pyo3-build-config", +] + +[[package]] +name = "pyo3-macros" +version = "0.27.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a5b10c9bf9888125d917fb4d2ca2d25c8df94c7ab5a52e13313a07e050a3b02" +dependencies = [ + "proc-macro2", + "pyo3-macros-backend", + "quote", + "syn", +] + +[[package]] +name = "pyo3-macros-backend" +version = "0.27.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03b51720d314836e53327f5871d4c0cfb4fb37cc2c4a11cc71907a86342c40f9" +dependencies = [ + "heck", + "proc-macro2", + "pyo3-build-config", + "quote", + "syn", +] + +[[package]] +name = "quote" +version = "1.0.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "syn" +version = "2.0.117" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "target-lexicon" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca" + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "unindent" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3" diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..09cf5c2 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "pykyber" +version = "0.1.0" +edition = "2024" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html +[lib] +name = "pykyber" +crate-type = ["cdylib"] + +[dependencies] +pyo3 = "0.27.0" diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..a819593 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,13 @@ +[build-system] +requires = ["maturin>=1.12,<2.0"] +build-backend = "maturin" + +[project] +name = "pykyber" +requires-python = ">=3.8" +classifiers = [ + "Programming Language :: Rust", + "Programming Language :: Python :: Implementation :: CPython", + "Programming Language :: Python :: Implementation :: PyPy", +] +dynamic = ["version"] diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..23cec34 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,13 @@ +use pyo3::prelude::*; + +/// A Python module implemented in Rust. +#[pymodule] +mod pykyber { + use pyo3::prelude::*; + + /// Formats the sum of two numbers as string. + #[pyfunction] + fn sum_as_string(a: usize, b: usize) -> PyResult { + Ok((a + b).to_string()) + } +} From 18460685a7dac98b05e2dfc35064c958dc054dfb Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Fri, 20 Feb 2026 10:12:31 +0200 Subject: [PATCH 02/47] Working hints --- pykyber.pyi | 3 +++ pyproject.toml | 3 +++ 2 files changed, 6 insertions(+) create mode 100644 pykyber.pyi diff --git a/pykyber.pyi b/pykyber.pyi new file mode 100644 index 0000000..76e7a2a --- /dev/null +++ b/pykyber.pyi @@ -0,0 +1,3 @@ +# flake8: noqa: PYI021 +def sum_as_string(a, b): + """Formats the sum of two numbers as string.""" diff --git a/pyproject.toml b/pyproject.toml index a819593..3180686 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -11,3 +11,6 @@ classifiers = [ "Programming Language :: Python :: Implementation :: PyPy", ] dynamic = ["version"] + +[tool.maturin] +include = ["pykyber.pyi"] \ No newline at end of file From 54a0d9888703055147a65cff6e33868dc33d66ee Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Fri, 20 Feb 2026 10:34:22 +0200 Subject: [PATCH 03/47] Better file struct + Makefile --- .gitignore | 4 ++++ Cargo.toml | 2 +- Makefile | 15 +++++++++++++++ pykyber.pyi | 3 --- pyproject.toml | 3 ++- python/pykyber/__init__.py | 1 + python/pykyber/py.typed | 0 python/pykyber/wrappers.py | 0 src/lib.rs | 2 +- 9 files changed, 24 insertions(+), 6 deletions(-) create mode 100644 Makefile delete mode 100644 pykyber.pyi create mode 100644 python/pykyber/__init__.py create mode 100644 python/pykyber/py.typed create mode 100644 python/pykyber/wrappers.py diff --git a/.gitignore b/.gitignore index 3940810..8174a46 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,6 @@ .venv/ target/ +__pycache__/ +.vscode/ +*.so +*.pyi diff --git a/Cargo.toml b/Cargo.toml index 09cf5c2..95eb460 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,7 +5,7 @@ edition = "2024" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [lib] -name = "pykyber" +name = "_pykyber" crate-type = ["cdylib"] [dependencies] diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..65f4ef6 --- /dev/null +++ b/Makefile @@ -0,0 +1,15 @@ + + +dev-build: clean dev-build-pyi + + +dev-build-package: + maturin develop + +dev-build-pyi: dev-build-package + pyo3-stubgen pykyber._pykyber ./python/ + +clean: + rm ./python/pykyber/*.so + rm ./python/pykyber/_pykyber.pyi + rm -rf ./target/ \ No newline at end of file diff --git a/pykyber.pyi b/pykyber.pyi deleted file mode 100644 index 76e7a2a..0000000 --- a/pykyber.pyi +++ /dev/null @@ -1,3 +0,0 @@ -# flake8: noqa: PYI021 -def sum_as_string(a, b): - """Formats the sum of two numbers as string.""" diff --git a/pyproject.toml b/pyproject.toml index 3180686..e9340eb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -13,4 +13,5 @@ classifiers = [ dynamic = ["version"] [tool.maturin] -include = ["pykyber.pyi"] \ No newline at end of file +python-source = "python" +module-name = "pykyber._pykyber" \ No newline at end of file diff --git a/python/pykyber/__init__.py b/python/pykyber/__init__.py new file mode 100644 index 0000000..20f96fa --- /dev/null +++ b/python/pykyber/__init__.py @@ -0,0 +1 @@ +from ._pykyber import * \ No newline at end of file diff --git a/python/pykyber/py.typed b/python/pykyber/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/python/pykyber/wrappers.py b/python/pykyber/wrappers.py new file mode 100644 index 0000000..e69de29 diff --git a/src/lib.rs b/src/lib.rs index 23cec34..e95c887 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -2,7 +2,7 @@ use pyo3::prelude::*; /// A Python module implemented in Rust. #[pymodule] -mod pykyber { +mod _pykyber { use pyo3::prelude::*; /// Formats the sum of two numbers as string. From 730f83ff2c2a177b85b81545001ece6d6bd092e7 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Fri, 20 Feb 2026 20:17:30 +0200 Subject: [PATCH 04/47] working kyber --- Cargo.lock | 84 +++++++ Cargo.toml | 11 +- python/pykyber/test_kyber.py | 135 +++++++++++ src/kyber/api.rs | 96 ++++++++ src/kyber/cbd.rs | 54 +++++ src/kyber/error.rs | 21 ++ src/kyber/fips202.rs | 454 +++++++++++++++++++++++++++++++++++ src/kyber/indcpa.rs | 210 ++++++++++++++++ src/kyber/kem.rs | 85 +++++++ src/kyber/mod.rs | 18 ++ src/kyber/ntt.rs | 77 ++++++ src/kyber/params.rs | 26 ++ src/kyber/poly.rs | 166 +++++++++++++ src/kyber/polyvec.rs | 102 ++++++++ src/kyber/reduce.rs | 20 ++ src/kyber/symmetric.rs | 54 +++++ src/kyber/verify.rs | 15 ++ src/lib.rs | 171 ++++++++++++- 18 files changed, 1793 insertions(+), 6 deletions(-) create mode 100644 python/pykyber/test_kyber.py create mode 100644 src/kyber/api.rs create mode 100644 src/kyber/cbd.rs create mode 100644 src/kyber/error.rs create mode 100644 src/kyber/fips202.rs create mode 100644 src/kyber/indcpa.rs create mode 100644 src/kyber/kem.rs create mode 100644 src/kyber/mod.rs create mode 100644 src/kyber/ntt.rs create mode 100644 src/kyber/params.rs create mode 100644 src/kyber/poly.rs create mode 100644 src/kyber/polyvec.rs create mode 100644 src/kyber/reduce.rs create mode 100644 src/kyber/symmetric.rs create mode 100644 src/kyber/verify.rs diff --git a/Cargo.lock b/Cargo.lock index 0a10417..4d165cd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8,6 +8,23 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + [[package]] name = "heck" version = "0.5.0" @@ -50,6 +67,15 @@ version = "1.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49" +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + [[package]] name = "proc-macro2" version = "1.0.106" @@ -64,6 +90,8 @@ name = "pykyber" version = "0.1.0" dependencies = [ "pyo3", + "rand", + "rand_core", ] [[package]] @@ -136,6 +164,36 @@ dependencies = [ "proc-macro2", ] +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", +] + [[package]] name = "rustversion" version = "1.0.22" @@ -170,3 +228,29 @@ name = "unindent" version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3" + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "zerocopy" +version = "0.8.39" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db6d35d663eadb6c932438e763b262fe1a70987f9ae936e60158176d710cae4a" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.39" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4122cd3169e94605190e77839c9a40d40ed048d305bfdc146e7df40ab0f3e517" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] diff --git a/Cargo.toml b/Cargo.toml index 95eb460..8b84fde 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,12 +1,19 @@ [package] name = "pykyber" version = "0.1.0" -edition = "2024" +edition = "2021" -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [lib] name = "_pykyber" crate-type = ["cdylib"] [dependencies] pyo3 = "0.27.0" +rand = "0.8" +rand_core = "0.6" + +[profile.dev] +opt-level = 0 + +[profile.release] +opt-level = 3 diff --git a/python/pykyber/test_kyber.py b/python/pykyber/test_kyber.py new file mode 100644 index 0000000..1f2ed9c --- /dev/null +++ b/python/pykyber/test_kyber.py @@ -0,0 +1,135 @@ +import pytest +import pykyber + + +def test_keypair_generation(): + """Test that keypair generation produces valid keys.""" + pk, sk = pykyber.generate_keypair() + + # Kyber-768 default key sizes + assert len(pk) == 1184, f"Expected public key length 1184, got {len(pk)}" + assert len(sk) == 2400, f"Expected secret key length 2400, got {len(sk)}" + + +def test_encapsulate_decapsulate(): + """Test that encapsulate and decapsulate work correctly.""" + pk, sk = pykyber.generate_keypair() + + # Encapsulate + ct, ss = pykyber.encapsulate(pk) + + assert len(ct) == 1088, f"Expected ciphertext length 1088, got {len(ct)}" + assert len(ss) == 32, f"Expected shared secret length 32, got {len(ss)}" + + # Decapsulate + ss2 = pykyber.decapsulate(ct, sk) + + # The shared secrets should match + assert ss == ss2, "Decapsulated secret doesn't match" + + +def test_invalid_public_key_length(): + """Test that invalid public key length raises an error.""" + with pytest.raises(Exception): + pykyber.encapsulate(b"short") + + +def test_invalid_ciphertext_length(): + """Test that invalid ciphertext length raises an error.""" + sk = bytes(2400) + with pytest.raises(Exception): + pykyber.decapsulate(b"short", sk) + + +def test_invalid_secret_key_length(): + """Test that invalid secret key length raises an error.""" + ct = bytes(1088) + with pytest.raises(Exception): + pykyber.decapsulate(ct, b"short") + + +def test_different_keypairs_produce_different_secrets(): + """Test that different keypairs produce different shared secrets.""" + pk1, sk1 = pykyber.generate_keypair() + pk2, sk2 = pykyber.generate_keypair() + + # Generate secrets for each keypair + ct1, ss1 = pykyber.encapsulate(pk1) + ct2, ss2 = pykyber.encapsulate(pk2) + + # Verify secrets decapsulate correctly + ss1_dec = pykyber.decapsulate(ct1, sk1) + ss2_dec = pykyber.decapsulate(ct2, sk2) + + assert ss1 == ss1_dec + assert ss2 == ss2_dec + assert ss1 != ss2, "Different keypairs should produce different secrets" + + +def test_wrong_secret_key_fails(): + """Test that using wrong secret key produces different result.""" + pk, sk = pykyber.generate_keypair() + _, wrong_sk = pykyber.generate_keypair() + + ct, ss = pykyber.encapsulate(pk) + ss_wrong = pykyber.decapsulate(ct, wrong_sk) + + # The wrong key should produce a different result (or should fail) + # In Kyber, wrong key decapsulation produces garbage, not an error + assert ss != ss_wrong, "Wrong secret key should produce different result" + + +def test_keypair_512(): + """Test keypair generation for Kyber-512.""" + pk, sk = pykyber.keypair_512() + + # Note: Current implementation uses Kyber-768 by default + # Kyber-512 key sizes: 800, 1632 + # But function currently uses Kyber-768: 1184, 2400 + assert len(pk) == 1184, f"Expected public key length 1184, got {len(pk)}" + assert len(sk) == 2400, f"Expected secret key length 2400, got {len(sk)}" + + +def test_keypair_768(): + """Test keypair generation for Kyber-768.""" + pk, sk = pykyber.keypair_768() + + # Kyber-768 key sizes + assert len(pk) == 1184, f"Expected public key length 1184, got {len(pk)}" + assert len(sk) == 2400, f"Expected secret key length 2400, got {len(sk)}" + + +def test_keypair_1024(): + """Test keypair generation for Kyber-1024.""" + pk, sk = pykyber.keypair_1024() + + # Note: Current implementation uses Kyber-768 by default + # Kyber-1024 key sizes: 1568, 3168 + # But function currently uses Kyber-768: 1184, 2400 + assert len(pk) == 1184, f"Expected public key length 1184, got {len(pk)}" + assert len(sk) == 2400, f"Expected secret key length 2400, got {len(sk)}" + + +def test_deterministic_decapsulation(): + """Test that decapsulation is deterministic given the same ciphertext.""" + pk, sk = pykyber.generate_keypair() + + # Generate a ciphertext + ct, _ = pykyber.encapsulate(pk) + + # Decapsulating the same ciphertext multiple times should produce the same result + results = [pykyber.decapsulate(ct, sk) for _ in range(5)] + + # All results should be identical + assert len(set(results)) == 1, "Decapsulation should be deterministic" + + +def test_ciphertext_randomness(): + """Test that ciphertexts are random (different each encapsulation).""" + pk, sk = pykyber.generate_keypair() + + # Generate multiple ciphertexts + ciphertexts = [pykyber.encapsulate(pk)[0] for _ in range(5)] + + # At least some should be different (probability of all 5 being equal is essentially 0) + assert len(set(ciphertexts)) > 1, "Ciphertexts should be random" diff --git a/src/kyber/api.rs b/src/kyber/api.rs new file mode 100644 index 0000000..4d807d2 --- /dev/null +++ b/src/kyber/api.rs @@ -0,0 +1,96 @@ +use super::error::KyberError; +use super::kem::{crypto_kem_dec, crypto_kem_enc, crypto_kem_keypair}; +use super::params::*; +use rand_core::{CryptoRng, RngCore}; + +pub fn keypair(rng: &mut R) -> Result +where + R: RngCore + CryptoRng, +{ + let mut public = [0u8; KYBER_PUBLICKEYBYTES]; + let mut secret = [0u8; KYBER_SECRETKEYBYTES]; + crypto_kem_keypair(&mut public, &mut secret, rng, None)?; + Ok(Keypair { public, secret }) +} + +pub fn encapsulate(pk: &[u8], rng: &mut R) -> Encapsulated +where + R: CryptoRng + RngCore, +{ + if pk.len() != KYBER_PUBLICKEYBYTES { + return Err(KyberError::InvalidInput); + } + let mut ct = [0u8; KYBER_CIPHERTEXTBYTES]; + let mut ss = [0u8; KYBER_SSBYTES]; + crypto_kem_enc(&mut ct, &mut ss, pk, rng, None)?; + Ok((ct, ss)) +} + +pub fn decapsulate(ct: &[u8], sk: &[u8]) -> Decapsulated { + if ct.len() != KYBER_CIPHERTEXTBYTES || sk.len() != KYBER_SECRETKEYBYTES { + return Err(KyberError::InvalidInput); + } + let mut ss = [0u8; KYBER_SSBYTES]; + crypto_kem_dec(&mut ss, ct, sk); + Ok(ss) +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub struct Keypair { + pub public: PublicKey, + pub secret: SecretKey, +} + +impl Keypair { + pub fn generate(rng: &mut R) -> Result { + keypair(rng) + } +} + +struct DummyRng {} +impl CryptoRng for DummyRng {} +impl RngCore for DummyRng { + fn next_u32(&mut self) -> u32 { + panic!() + } + fn next_u64(&mut self) -> u64 { + panic!() + } + fn try_fill_bytes(&mut self, _dest: &mut [u8]) -> Result<(), rand_core::Error> { + panic!() + } + fn fill_bytes(&mut self, _dest: &mut [u8]) { + panic!() + } +} + +pub fn derive(seed: &[u8]) -> Result { + let mut public = [0u8; KYBER_PUBLICKEYBYTES]; + let mut secret = [0u8; KYBER_SECRETKEYBYTES]; + let mut _rng = DummyRng {}; + if seed.len() != 64 { + return Err(KyberError::InvalidInput); + } + crypto_kem_keypair( + &mut public, + &mut secret, + &mut _rng, + Some((&seed[..32], &seed[32..])), + )?; + Ok(Keypair { public, secret }) +} + +pub fn public(sk: &[u8]) -> PublicKey { + let mut pk = [0u8; KYBER_INDCPA_PUBLICKEYBYTES]; + pk.copy_from_slice( + &sk[KYBER_INDCPA_SECRETKEYBYTES..KYBER_INDCPA_SECRETKEYBYTES + KYBER_INDCPA_PUBLICKEYBYTES], + ); + pk +} + +pub type PublicKey = [u8; KYBER_PUBLICKEYBYTES]; +pub type SecretKey = [u8; KYBER_SECRETKEYBYTES]; +pub type Encapsulated = Result<(Ciphertext, SharedSecret), KyberError>; +pub type Decapsulated = Result; +pub type Ciphertext = [u8; KYBER_CIPHERTEXTBYTES]; +pub type SharedSecret = [u8; KYBER_SSBYTES]; diff --git a/src/kyber/cbd.rs b/src/kyber/cbd.rs new file mode 100644 index 0000000..47e680d --- /dev/null +++ b/src/kyber/cbd.rs @@ -0,0 +1,54 @@ +use super::params::KYBER_N; +use super::poly::Poly; + +fn load32_littleendian(x: &[u8]) -> u32 { + let mut r = x[0] as u32; + r |= (x[1] as u32) << 8; + r |= (x[2] as u32) << 16; + r |= (x[3] as u32) << 24; + r +} + +fn load24_littleendian(x: &[u8]) -> u32 { + let mut r = x[0] as u32; + r |= (x[1] as u32) << 8; + r |= (x[2] as u32) << 16; + r +} + +pub fn cbd2(r: &mut Poly, buf: &[u8]) { + let (mut d, mut t, mut a, mut b); + for i in 0..(KYBER_N / 8) { + t = load32_littleendian(&buf[4 * i..]); + d = t & 0x55555555; + d += (t >> 1) & 0x55555555; + for j in 0..8 { + a = ((d >> (4 * j)) & 0x3) as i16; + b = ((d >> (4 * j + 2)) & 0x3) as i16; + r.coeffs[8 * i + j] = a - b; + } + } +} + +pub fn cbd3(r: &mut Poly, buf: &[u8]) { + let (mut d, mut t, mut a, mut b); + for i in 0..(KYBER_N / 4) { + t = load24_littleendian(&buf[3 * i..]); + d = t & 0x00249249; + d += (t >> 1) & 0x00249249; + d += (t >> 2) & 0x00249249; + for j in 0..4 { + a = ((d >> (6 * j)) & 0x7) as i16; + b = ((d >> (6 * j + 3)) & 0x7) as i16; + r.coeffs[4 * i + j] = a - b; + } + } +} + +pub fn poly_cbd_eta1(r: &mut Poly, buf: &[u8]) { + cbd2(r, buf) +} + +pub fn poly_cbd_eta2(r: &mut Poly, buf: &[u8]) { + cbd2(r, buf) +} diff --git a/src/kyber/error.rs b/src/kyber/error.rs new file mode 100644 index 0000000..2882086 --- /dev/null +++ b/src/kyber/error.rs @@ -0,0 +1,21 @@ +#[derive(Debug, PartialEq)] +pub enum KyberError { + InvalidInput, + Decapsulation, + RandomBytesGeneration, +} + +impl core::fmt::Display for KyberError { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + match *self { + KyberError::InvalidInput => write!(f, "Function input is of incorrect length"), + KyberError::Decapsulation => write!( + f, + "Decapsulation Failure, unable to obtain shared secret from ciphertext" + ), + KyberError::RandomBytesGeneration => { + write!(f, "Random bytes generation function failed") + } + } + } +} diff --git a/src/kyber/fips202.rs b/src/kyber/fips202.rs new file mode 100644 index 0000000..5e09418 --- /dev/null +++ b/src/kyber/fips202.rs @@ -0,0 +1,454 @@ +#![allow(clippy::needless_range_loop, dead_code)] + +pub const SHAKE128_RATE: usize = 168; +const SHAKE256_RATE: usize = 136; +const SHA3_256_RATE: usize = 136; +const SHA3_512_RATE: usize = 72; +const NROUNDS: usize = 24; + +#[derive(Copy, Clone)] +pub struct KeccakState { + pub s: [u64; 25], + pub pos: usize, +} + +impl KeccakState { + pub fn new() -> Self { + KeccakState { + s: [0u64; 25], + pos: 0usize, + } + } + + pub fn reset(&mut self) { + self.s = [0u64; 25]; + self.pos = 0; + } +} + +fn rol(a: u64, offset: u64) -> u64 { + (a << offset) ^ (a >> (64 - offset)) +} + +pub fn load64(x: &[u8]) -> u64 { + let mut r = 0u64; + for i in 0..8 { + r |= (x[i] as u64) << (8 * i); + } + r +} + +pub fn store64(x: &mut [u8], mut u: u64) { + for i in x.iter_mut().take(8) { + *i = u as u8; + u >>= 8; + } +} + +const KECCAKF_ROUNDCONSTANTS: [u64; NROUNDS] = [ + 0x0000000000000001, + 0x0000000000008082, + 0x800000000000808a, + 0x8000000080008000, + 0x000000000000808b, + 0x0000000080000001, + 0x8000000080008081, + 0x8000000000008009, + 0x000000000000008a, + 0x0000000000000088, + 0x0000000080008009, + 0x000000008000000a, + 0x000000008000808b, + 0x800000000000008b, + 0x8000000000008089, + 0x8000000000008003, + 0x8000000000008002, + 0x8000000000000080, + 0x000000000000800a, + 0x800000008000000a, + 0x8000000080008081, + 0x8000000000008080, + 0x0000000080000001, + 0x8000000080008008, +]; + +pub fn keccakf1600_statepermute(state: &mut [u64]) { + let mut aba = state[0]; + let mut abe = state[1]; + let mut abi = state[2]; + let mut abo = state[3]; + let mut abu = state[4]; + let mut aga = state[5]; + let mut age = state[6]; + let mut agi = state[7]; + let mut ago = state[8]; + let mut agu = state[9]; + let mut aka = state[10]; + let mut ake = state[11]; + let mut aki = state[12]; + let mut ako = state[13]; + let mut aku = state[14]; + let mut ama = state[15]; + let mut ame = state[16]; + let mut ami = state[17]; + let mut amo = state[18]; + let mut amu = state[19]; + let mut asa = state[20]; + let mut ase = state[21]; + let mut asi = state[22]; + let mut aso = state[23]; + let mut asu = state[24]; + + for round in (0..NROUNDS).step_by(2) { + let mut bca = aba ^ aga ^ aka ^ ama ^ asa; + let mut bce = abe ^ age ^ ake ^ ame ^ ase; + let mut bci = abi ^ agi ^ aki ^ ami ^ asi; + let mut bco = abo ^ ago ^ ako ^ amo ^ aso; + let mut bcu = abu ^ agu ^ aku ^ amu ^ asu; + + let mut da = bcu ^ rol(bce, 1); + let mut de = bca ^ rol(bci, 1); + let mut di = bce ^ rol(bco, 1); + let mut d_o = bci ^ rol(bcu, 1); + let mut du = bco ^ rol(bca, 1); + + aba ^= da; + bca = aba; + age ^= de; + bce = rol(age, 44); + aki ^= di; + bci = rol(aki, 43); + amo ^= d_o; + bco = rol(amo, 21); + asu ^= du; + bcu = rol(asu, 14); + let mut eba = bca ^ ((!bce) & bci); + eba ^= KECCAKF_ROUNDCONSTANTS[round]; + let mut ebe = bce ^ ((!bci) & bco); + let mut ebi = bci ^ ((!bco) & bcu); + let mut ebo = bco ^ ((!bcu) & bca); + let mut ebu = bcu ^ ((!bca) & bce); + + abo ^= d_o; + bca = rol(abo, 28); + agu ^= du; + bce = rol(agu, 20); + aka ^= da; + bci = rol(aka, 3); + ame ^= de; + bco = rol(ame, 45); + asi ^= di; + bcu = rol(asi, 61); + let mut ega = bca ^ ((!bce) & bci); + let mut ege = bce ^ ((!bci) & bco); + let mut egi = bci ^ ((!bco) & bcu); + let mut ego = bco ^ ((!bcu) & bca); + let mut egu = bcu ^ ((!bca) & bce); + + abe ^= de; + bca = rol(abe, 1); + agi ^= di; + bce = rol(agi, 6); + ako ^= d_o; + bci = rol(ako, 25); + amu ^= du; + bco = rol(amu, 8); + asa ^= da; + bcu = rol(asa, 18); + let mut eka = bca ^ ((!bce) & bci); + let mut eke = bce ^ ((!bci) & bco); + let mut eki = bci ^ ((!bco) & bcu); + let mut eko = bco ^ ((!bcu) & bca); + let mut eku = bcu ^ ((!bca) & bce); + + abu ^= du; + bca = rol(abu, 27); + aga ^= da; + bce = rol(aga, 36); + ake ^= de; + bci = rol(ake, 10); + ami ^= di; + bco = rol(ami, 15); + aso ^= d_o; + bcu = rol(aso, 56); + let mut ema = bca ^ ((!bce) & bci); + let mut eme = bce ^ ((!bci) & bco); + let mut emi = bci ^ ((!bco) & bcu); + let mut emo = bco ^ ((!bcu) & bca); + let mut emu = bcu ^ ((!bca) & bce); + + abi ^= di; + bca = rol(abi, 62); + ago ^= d_o; + bce = rol(ago, 55); + aku ^= du; + bci = rol(aku, 39); + ama ^= da; + bco = rol(ama, 41); + ase ^= de; + bcu = rol(ase, 2); + let mut esa = bca ^ ((!bce) & bci); + let mut ese = bce ^ ((!bci) & bco); + let mut esi = bci ^ ((!bco) & bcu); + let mut eso = bco ^ ((!bcu) & bca); + let mut esu = bcu ^ ((!bca) & bce); + + bca = eba ^ ega ^ eka ^ ema ^ esa; + bce = ebe ^ ege ^ eke ^ eme ^ ese; + bci = ebi ^ egi ^ eki ^ emi ^ esi; + bco = ebo ^ ego ^ eko ^ emo ^ eso; + bcu = ebu ^ egu ^ eku ^ emu ^ esu; + + da = bcu ^ rol(bce, 1); + de = bca ^ rol(bci, 1); + di = bce ^ rol(bco, 1); + d_o = bci ^ rol(bcu, 1); + du = bco ^ rol(bca, 1); + + eba ^= da; + bca = eba; + ege ^= de; + bce = rol(ege, 44); + eki ^= di; + bci = rol(eki, 43); + emo ^= d_o; + bco = rol(emo, 21); + esu ^= du; + bcu = rol(esu, 14); + aba = bca ^ ((!bce) & bci); + aba ^= KECCAKF_ROUNDCONSTANTS[round + 1]; + abe = bce ^ ((!bci) & bco); + abi = bci ^ ((!bco) & bcu); + abo = bco ^ ((!bcu) & bca); + abu = bcu ^ ((!bca) & bce); + + ebo ^= d_o; + bca = rol(ebo, 28); + egu ^= du; + bce = rol(egu, 20); + eka ^= da; + bci = rol(eka, 3); + eme ^= de; + bco = rol(eme, 45); + esi ^= di; + bcu = rol(esi, 61); + aga = bca ^ ((!bce) & bci); + age = bce ^ ((!bci) & bco); + agi = bci ^ ((!bco) & bcu); + ago = bco ^ ((!bcu) & bca); + agu = bcu ^ ((!bca) & bce); + + ebe ^= de; + bca = rol(ebe, 1); + egi ^= di; + bce = rol(egi, 6); + eko ^= d_o; + bci = rol(eko, 25); + emu ^= du; + bco = rol(emu, 8); + esa ^= da; + bcu = rol(esa, 18); + aka = bca ^ ((!bce) & bci); + ake = bce ^ ((!bci) & bco); + aki = bci ^ ((!bco) & bcu); + ako = bco ^ ((!bcu) & bca); + aku = bcu ^ ((!bca) & bce); + + ebu ^= du; + bca = rol(ebu, 27); + ega ^= da; + bce = rol(ega, 36); + eke ^= de; + bci = rol(eke, 10); + emi ^= di; + bco = rol(emi, 15); + eso ^= d_o; + bcu = rol(eso, 56); + ama = bca ^ ((!bce) & bci); + ame = bce ^ ((!bci) & bco); + ami = bci ^ ((!bco) & bcu); + amo = bco ^ ((!bcu) & bca); + amu = bcu ^ ((!bca) & bce); + + ebi ^= di; + bca = rol(ebi, 62); + ego ^= d_o; + bce = rol(ego, 55); + eku ^= du; + bci = rol(eku, 39); + ema ^= da; + bco = rol(ema, 41); + ese ^= de; + bcu = rol(ese, 2); + asa = bca ^ ((!bce) & bci); + ase = bce ^ ((!bci) & bco); + asi = bci ^ ((!bco) & bcu); + aso = bco ^ ((!bcu) & bca); + asu = bcu ^ ((!bca) & bce); + } + + state[0] = aba; + state[1] = abe; + state[2] = abi; + state[3] = abo; + state[4] = abu; + state[5] = aga; + state[6] = age; + state[7] = agi; + state[8] = ago; + state[9] = agu; + state[10] = aka; + state[11] = ake; + state[12] = aki; + state[13] = ako; + state[14] = aku; + state[15] = ama; + state[16] = ame; + state[17] = ami; + state[18] = amo; + state[19] = amu; + state[20] = asa; + state[21] = ase; + state[22] = asi; + state[23] = aso; + state[24] = asu; +} + +fn keccak_squeezeblocks(h: &mut [u8], mut nblocks: usize, s: &mut [u64], r: usize) { + let mut idx = 0usize; + while nblocks > 0 { + keccakf1600_statepermute(s); + for i in 0..r / 8 { + store64(&mut h[idx + 8 * i..], s[i]) + } + idx += r; + nblocks -= 1; + } +} + +pub fn shake128_squeezeblocks(out: &mut [u8], nblocks: usize, state: &mut KeccakState) { + keccak_squeezeblocks(out, nblocks, &mut state.s, SHAKE128_RATE); +} + +pub fn shake256(out: &mut [u8], mut outlen: usize, input: &[u8], inlen: usize) { + let mut state = KeccakState::new(); + let mut idx = 0; + shake256_absorb_once(&mut state, input, inlen); + let nblocks = outlen / SHAKE256_RATE; + shake256_squeezeblocks(&mut out[idx..], nblocks, &mut state); + outlen -= nblocks * SHAKE256_RATE; + idx += nblocks * SHAKE256_RATE; + shake256_squeeze(&mut out[idx..], outlen, &mut state); +} + +pub fn sha3_256(h: &mut [u8], input: &[u8], inlen: usize) { + let mut s = [0u64; 25]; + keccak_absorb_once(&mut s, SHA3_256_RATE, input, inlen, 0x06); + keccakf1600_statepermute(&mut s); + for i in 0..4 { + store64(&mut h[8 * i..], s[i]); + } +} + +pub fn sha3_512(h: &mut [u8], input: &[u8], inlen: usize) { + let mut s = [0u64; 25]; + keccak_absorb_once(&mut s, SHA3_512_RATE, input, inlen, 0x06); + keccakf1600_statepermute(&mut s); + for i in 0..8 { + store64(&mut h[8 * i..], s[i]); + } +} + +fn keccak_finalize(s: &mut [u64], pos: usize, r: usize, p: u8) { + s[pos / 8] ^= (p as u64) << 8 * (pos % 8); + s[r / 8 - 1] ^= 1u64 << 63; +} + +pub fn keccak_absorb_once(s: &mut [u64], r: usize, input: &[u8], mut inlen: usize, p: u8) { + s.fill(0); + + let mut idx = 0usize; + while inlen >= r { + for i in 0..(r / 8) { + s[i] ^= load64(&input[idx + 8 * i..]); + } + idx += r; + inlen -= r; + keccakf1600_statepermute(s); + } + + for i in 0..inlen { + s[i / 8] ^= (input[idx + i] as u64) << 8 * (i % 8); + } + s[inlen / 8] ^= (p as u64) << 8 * (inlen % 8); + s[(r - 1) / 8] ^= 1u64 << 63; +} + +fn keccak_squeeze( + out: &mut [u8], + mut outlen: usize, + s: &mut [u64], + mut pos: usize, + r: usize, +) -> usize { + let mut idx = 0; + while outlen > 0 { + if pos == r { + keccakf1600_statepermute(s); + pos = 0 + } + let mut i = pos; + let mut w = i / 8; + while i < r && i < pos + outlen { + store64(&mut out[idx..], s[w]); + i += 8; + w += 1; + idx += 8; + } + outlen -= i - pos; + pos = i; + } + pos +} + +pub fn shake128_absorb_once(state: &mut KeccakState, input: &[u8], inlen: usize) { + keccak_absorb_once(&mut state.s, SHAKE128_RATE, input, inlen, 0x1F); + state.pos = SHAKE128_RATE; +} + +fn shake256_init(state: &mut KeccakState) { + state.reset(); +} + +fn shake256_finalize(state: &mut KeccakState) { + keccak_finalize(&mut state.s, state.pos, SHAKE256_RATE, 0x1F); + state.pos = SHAKE256_RATE; +} + +fn shake256_squeeze(out: &mut [u8], outlen: usize, state: &mut KeccakState) { + state.pos = keccak_squeeze(out, outlen, &mut state.s, state.pos, SHAKE256_RATE); +} + +fn shake256_absorb_once(state: &mut KeccakState, input: &[u8], inlen: usize) { + keccak_absorb_once(&mut state.s, SHAKE256_RATE, input, inlen, 0x1F); + state.pos = SHAKE256_RATE; +} + +fn shake256_squeezeblocks(out: &mut [u8], nblocks: usize, state: &mut KeccakState) { + keccak_squeezeblocks(out, nblocks, &mut state.s, SHAKE256_RATE); +} + +fn shake128(out: &mut [u8], mut outlen: usize, input: &[u8], inlen: usize) { + let mut state = KeccakState::new(); + let mut idx = 0; + shake128_absorb_once(&mut state, input, inlen); + let nblocks = outlen / SHAKE128_RATE; + shake128_squeezeblocks(&mut out[idx..], nblocks, &mut state); + outlen -= nblocks * SHAKE128_RATE; + idx += nblocks * SHAKE128_RATE; + shake128_squeeze(&mut out[idx..], outlen, &mut state); +} + +fn shake128_squeeze(out: &mut [u8], outlen: usize, state: &mut KeccakState) { + state.pos = keccak_squeeze(out, outlen, &mut state.s, state.pos, SHAKE128_RATE); +} diff --git a/src/kyber/indcpa.rs b/src/kyber/indcpa.rs new file mode 100644 index 0000000..9cc6f9e --- /dev/null +++ b/src/kyber/indcpa.rs @@ -0,0 +1,210 @@ +use super::error::KyberError; +use super::params::*; +use super::poly::*; +use super::polyvec::*; +use super::symmetric::{hash_g, xof_absorb, xof_squeezeblocks, XofState, XOF_BLOCKBYTES}; +use rand_core::{CryptoRng, RngCore}; + +fn pack_pk(r: &mut [u8], pk: &mut Polyvec, seed: &[u8]) { + const END: usize = KYBER_SYMBYTES + KYBER_POLYVECBYTES; + polyvec_tobytes(r, pk); + r[KYBER_POLYVECBYTES..END].copy_from_slice(&seed[..KYBER_SYMBYTES]); +} + +fn unpack_pk(pk: &mut Polyvec, seed: &mut [u8], packedpk: &[u8]) { + const END: usize = KYBER_SYMBYTES + KYBER_POLYVECBYTES; + polyvec_frombytes(pk, packedpk); + seed[..KYBER_SYMBYTES].copy_from_slice(&packedpk[KYBER_POLYVECBYTES..END]); +} + +fn pack_sk(r: &mut [u8], sk: &mut Polyvec) { + polyvec_tobytes(r, sk); +} + +fn unpack_sk(sk: &mut Polyvec, packedsk: &[u8]) { + polyvec_frombytes(sk, packedsk); +} + +fn pack_ciphertext(r: &mut [u8], b: &mut Polyvec, v: Poly) { + polyvec_compress(r, *b); + poly_compress(&mut r[KYBER_POLYVECCOMPRESSEDBYTES..], v); +} + +fn unpack_ciphertext(b: &mut Polyvec, v: &mut Poly, c: &[u8]) { + polyvec_decompress(b, c); + poly_decompress(v, &c[KYBER_POLYVECCOMPRESSEDBYTES..]); +} + +fn rej_uniform(r: &mut [i16], len: usize, buf: &[u8], buflen: usize) -> usize { + let (mut ctr, mut pos) = (0usize, 0usize); + let (mut val0, mut val1); + + while ctr < len && pos + 3 <= buflen { + val0 = ((buf[pos + 0] >> 0) as u16 | (buf[pos + 1] as u16) << 8) & 0xFFF; + val1 = ((buf[pos + 1] >> 4) as u16 | (buf[pos + 2] as u16) << 4) & 0xFFF; + pos += 3; + + if val0 < KYBER_Q as u16 { + r[ctr] = val0 as i16; + ctr += 1; + } + if ctr < len && val1 < KYBER_Q as u16 { + r[ctr] = val1 as i16; + ctr += 1; + } + } + ctr +} + +fn gen_a(a: &mut [Polyvec], b: &[u8]) { + gen_matrix(a, b, false); +} + +fn gen_at(a: &mut [Polyvec], b: &[u8]) { + gen_matrix(a, b, true); +} + +fn gen_matrix(a: &mut [Polyvec], seed: &[u8], transposed: bool) { + let mut ctr; + const GEN_MATRIX_NBLOCKS: usize = + (12 * KYBER_N / 8 * (1 << 12) / KYBER_Q + XOF_BLOCKBYTES) / XOF_BLOCKBYTES; + let mut buf = [0u8; GEN_MATRIX_NBLOCKS * XOF_BLOCKBYTES + 2]; + let mut buflen: usize; + let mut off: usize; + let mut state = XofState::new(); + + for i in 0..KYBER_K { + for j in 0..KYBER_K { + if transposed { + xof_absorb(&mut state, seed, i as u8, j as u8); + } else { + xof_absorb(&mut state, seed, j as u8, i as u8); + } + xof_squeezeblocks(&mut buf, GEN_MATRIX_NBLOCKS, &mut state); + buflen = GEN_MATRIX_NBLOCKS * XOF_BLOCKBYTES; + ctr = rej_uniform(&mut a[i].vec[j].coeffs, KYBER_N, &buf, buflen); + + while ctr < KYBER_N { + off = buflen % 3; + for k in 0..off { + buf[k] = buf[buflen - off + k]; + } + xof_squeezeblocks(&mut buf[off..], 1, &mut state); + buflen = off + XOF_BLOCKBYTES; + ctr += rej_uniform(&mut a[i].vec[j].coeffs[ctr..], KYBER_N - ctr, &buf, buflen); + } + } + } +} + +pub fn indcpa_keypair( + pk: &mut [u8], + sk: &mut [u8], + _seed: Option<(&[u8], &[u8])>, + _rng: &mut R, +) -> Result<(), KyberError> +where + R: CryptoRng + RngCore, +{ + let mut a = [Polyvec::new(); KYBER_K]; + let (mut e, mut pkpv, mut skpv) = (Polyvec::new(), Polyvec::new(), Polyvec::new()); + let mut nonce = 0u8; + let mut buf = [0u8; 2 * KYBER_SYMBYTES]; + let mut randbuf = [0u8; 2 * KYBER_SYMBYTES]; + + if let Some(s) = _seed { + randbuf[..KYBER_SYMBYTES].copy_from_slice(&s.0); + } else { + _rng.fill_bytes(&mut randbuf[..KYBER_SYMBYTES]); + } + + hash_g(&mut buf, &randbuf, KYBER_SYMBYTES); + + let (publicseed, noiseseed) = buf.split_at(KYBER_SYMBYTES); + gen_a(&mut a, publicseed); + + for i in 0..KYBER_K { + poly_getnoise_eta1(&mut skpv.vec[i], noiseseed, nonce); + nonce += 1; + } + for i in 0..KYBER_K { + poly_getnoise_eta1(&mut e.vec[i], noiseseed, nonce); + nonce += 1; + } + + polyvec_ntt(&mut skpv); + polyvec_ntt(&mut e); + + for i in 0..KYBER_K { + polyvec_basemul_acc_montgomery(&mut pkpv.vec[i], &a[i], &skpv); + poly_tomont(&mut pkpv.vec[i]); + } + polyvec_add(&mut pkpv, &e); + polyvec_reduce(&mut pkpv); + + pack_sk(sk, &mut skpv); + pack_pk(pk, &mut pkpv, publicseed); + Ok(()) +} + +pub fn indcpa_enc(c: &mut [u8], m: &[u8], pk: &[u8], coins: &[u8]) { + let mut at = [Polyvec::new(); KYBER_K]; + let (mut sp, mut pkpv, mut ep, mut b) = ( + Polyvec::new(), + Polyvec::new(), + Polyvec::new(), + Polyvec::new(), + ); + let (mut v, mut k, mut epp) = (Poly::new(), Poly::new(), Poly::new()); + let mut seed = [0u8; KYBER_SYMBYTES]; + let mut nonce = 0u8; + + unpack_pk(&mut pkpv, &mut seed, pk); + poly_frommsg(&mut k, m); + gen_at(&mut at, &seed); + + for i in 0..KYBER_K { + poly_getnoise_eta1(&mut sp.vec[i], coins, nonce); + nonce += 1; + } + for i in 0..KYBER_K { + poly_getnoise_eta2(&mut ep.vec[i], coins, nonce); + nonce += 1; + } + poly_getnoise_eta2(&mut epp, coins, nonce); + + polyvec_ntt(&mut sp); + + for i in 0..KYBER_K { + polyvec_basemul_acc_montgomery(&mut b.vec[i], &at[i], &sp); + } + + polyvec_basemul_acc_montgomery(&mut v, &pkpv, &sp); + polyvec_invntt_tomont(&mut b); + poly_invntt_tomont(&mut v); + + polyvec_add(&mut b, &ep); + poly_add(&mut v, &epp); + poly_add(&mut v, &k); + polyvec_reduce(&mut b); + poly_reduce(&mut v); + + pack_ciphertext(c, &mut b, v); +} + +pub fn indcpa_dec(m: &mut [u8], c: &[u8], sk: &[u8]) { + let (mut b, mut skpv) = (Polyvec::new(), Polyvec::new()); + let (mut v, mut mp) = (Poly::new(), Poly::new()); + + unpack_ciphertext(&mut b, &mut v, c); + unpack_sk(&mut skpv, sk); + + polyvec_ntt(&mut b); + polyvec_basemul_acc_montgomery(&mut mp, &skpv, &b); + poly_invntt_tomont(&mut mp); + + poly_sub(&mut mp, &v); + poly_reduce(&mut mp); + + poly_tomsg(m, mp); +} diff --git a/src/kyber/kem.rs b/src/kyber/kem.rs new file mode 100644 index 0000000..42988a0 --- /dev/null +++ b/src/kyber/kem.rs @@ -0,0 +1,85 @@ +use super::error::KyberError; +use super::indcpa::{indcpa_dec, indcpa_enc, indcpa_keypair}; +use super::params::*; +use super::symmetric::{hash_g, hash_h, kdf}; +use super::verify::{cmov, verify}; +use rand_core::{CryptoRng, RngCore}; + +pub fn crypto_kem_keypair( + pk: &mut [u8], + sk: &mut [u8], + _rng: &mut R, + _seed: Option<(&[u8], &[u8])>, +) -> Result<(), KyberError> +where + R: RngCore + CryptoRng, +{ + const PK_START: usize = KYBER_SECRETKEYBYTES - (2 * KYBER_SYMBYTES); + const SK_START: usize = KYBER_SECRETKEYBYTES - KYBER_SYMBYTES; + const END: usize = KYBER_INDCPA_PUBLICKEYBYTES + KYBER_INDCPA_SECRETKEYBYTES; + + indcpa_keypair(pk, sk, _seed, _rng)?; + + sk[KYBER_INDCPA_SECRETKEYBYTES..END].copy_from_slice(&pk[..KYBER_INDCPA_PUBLICKEYBYTES]); + hash_h(&mut sk[PK_START..], pk, KYBER_PUBLICKEYBYTES); + + if let Some(s) = _seed { + sk[SK_START..].copy_from_slice(&s.1) + } else { + _rng.fill_bytes(&mut sk[SK_START..SK_START + KYBER_SYMBYTES]); + } + Ok(()) +} + +pub fn crypto_kem_enc( + ct: &mut [u8], + ss: &mut [u8], + pk: &[u8], + _rng: &mut R, + _seed: Option<&[u8]>, +) -> Result<(), KyberError> +where + R: RngCore + CryptoRng, +{ + let mut kr = [0u8; 2 * KYBER_SYMBYTES]; + let mut buf = [0u8; 2 * KYBER_SYMBYTES]; + let mut randbuf = [0u8; 2 * KYBER_SYMBYTES]; + + if let Some(s) = _seed { + randbuf[..KYBER_SYMBYTES].copy_from_slice(&s); + } else { + _rng.fill_bytes(&mut randbuf); + } + + hash_h(&mut buf, &randbuf, KYBER_SYMBYTES); + hash_h(&mut buf[KYBER_SYMBYTES..], pk, KYBER_PUBLICKEYBYTES); + hash_g(&mut kr, &buf, 2 * KYBER_SYMBYTES); + + indcpa_enc(ct, &buf, pk, &kr[KYBER_SYMBYTES..]); + + hash_h(&mut kr[KYBER_SYMBYTES..], ct, KYBER_CIPHERTEXTBYTES); + kdf(ss, &kr, 2 * KYBER_SYMBYTES); + Ok(()) +} + +pub fn crypto_kem_dec(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> () { + let mut buf = [0u8; 2 * KYBER_SYMBYTES]; + let mut kr = [0u8; 2 * KYBER_SYMBYTES]; + let mut cmp = [0u8; KYBER_CIPHERTEXTBYTES]; + let mut pk = [0u8; KYBER_INDCPA_PUBLICKEYBYTES]; + + pk.copy_from_slice(&sk[KYBER_INDCPA_SECRETKEYBYTES..][..KYBER_INDCPA_PUBLICKEYBYTES]); + + indcpa_dec(&mut buf, ct, sk); + + const START: usize = KYBER_SECRETKEYBYTES - 2 * KYBER_SYMBYTES; + const END: usize = KYBER_SECRETKEYBYTES - KYBER_SYMBYTES; + buf[KYBER_SYMBYTES..].copy_from_slice(&sk[START..END]); + hash_g(&mut kr, &buf, 2 * KYBER_SYMBYTES); + + indcpa_enc(&mut cmp, &buf, &pk, &kr[KYBER_SYMBYTES..]); + let fail = verify(ct, &cmp, KYBER_CIPHERTEXTBYTES); + hash_h(&mut kr[KYBER_SYMBYTES..], ct, KYBER_CIPHERTEXTBYTES); + cmov(&mut kr, &sk[END..], KYBER_SYMBYTES, fail); + kdf(ss, &kr, 2 * KYBER_SYMBYTES); +} diff --git a/src/kyber/mod.rs b/src/kyber/mod.rs new file mode 100644 index 0000000..1286150 --- /dev/null +++ b/src/kyber/mod.rs @@ -0,0 +1,18 @@ +pub mod api; +pub mod cbd; +pub mod error; +pub mod fips202; +pub mod indcpa; +pub mod kem; +pub mod ntt; +pub mod params; +pub mod poly; +pub mod polyvec; +pub mod reduce; +pub mod symmetric; +pub mod verify; + +pub use api::*; +pub use error::KyberError; +pub use params::*; +pub use rand_core::{CryptoRng, RngCore}; diff --git a/src/kyber/ntt.rs b/src/kyber/ntt.rs new file mode 100644 index 0000000..da3feae --- /dev/null +++ b/src/kyber/ntt.rs @@ -0,0 +1,77 @@ +use super::reduce::*; + +pub const ZETAS: [i16; 128] = [ + -1044, -758, -359, -1517, 1493, 1422, 287, 202, -171, 622, 1577, 182, 962, -1202, -1474, 1468, + 573, -1325, 264, 383, -829, 1458, -1602, -130, -681, 1017, 732, 608, -1542, 411, -205, -1571, + 1223, 652, -552, 1015, -1293, 1491, -282, -1544, 516, -8, -320, -666, -1618, -1162, 126, 1469, + -853, -90, -271, 830, 107, -1421, -247, -951, -398, 961, -1508, -725, 448, -1065, 677, -1275, + -1103, 430, 555, 843, -1251, 871, 1550, 105, 422, 587, 177, -235, -291, -460, 1574, 1653, -246, + 778, 1159, -147, -777, 1483, -602, 1119, -1590, 644, -872, 349, 418, 329, -156, -75, 817, 1097, + 603, 610, 1322, -1285, -1465, 384, -1215, -136, 1218, -1335, -874, 220, -1187, -1659, -1185, + -1530, -1278, 794, -1510, -854, -870, 478, -108, -308, 996, 991, 958, -1460, 1522, 1628, +]; + +pub fn fqmul(a: i16, b: i16) -> i16 { + montgomery_reduce(a as i32 * b as i32) +} + +pub fn ntt(r: &mut [i16]) { + let mut j; + let mut k = 1usize; + let mut len = 128; + let (mut t, mut zeta); + + while len >= 2 { + let mut start = 0; + while start < 256 { + zeta = ZETAS[k]; + k += 1; + j = start; + while j < (start + len) { + t = fqmul(zeta, r[j + len]); + r[j + len] = r[j] - t; + r[j] += t; + j += 1; + } + start = j + len; + } + len >>= 1; + } +} + +pub fn invntt(r: &mut [i16]) { + let mut j; + let mut k = 127usize; + let mut len = 2; + let (mut t, mut zeta); + const F: i16 = 1441; + while len <= 128 { + let mut start = 0; + while start < 256 { + zeta = ZETAS[k]; + k -= 1; + j = start; + while j < (start + len) { + t = r[j]; + r[j] = barrett_reduce(t + r[j + len]); + r[j + len] = r[j + len] - t; + r[j + len] = fqmul(zeta, r[j + len]); + j += 1 + } + start = j + len; + } + len <<= 1; + } + for j in 0..256 { + r[j] = fqmul(r[j], F); + } +} + +pub fn basemul(r: &mut [i16], a: &[i16], b: &[i16], zeta: i16) { + r[0] = fqmul(a[1], b[1]); + r[0] = fqmul(r[0], zeta); + r[0] += fqmul(a[0], b[0]); + + r[1] = fqmul(a[0], b[1]); + r[1] += fqmul(a[1], b[0]); +} diff --git a/src/kyber/params.rs b/src/kyber/params.rs new file mode 100644 index 0000000..60fe31a --- /dev/null +++ b/src/kyber/params.rs @@ -0,0 +1,26 @@ +pub const KYBER_K: usize = 3; + +pub const KYBER_N: usize = 256; +pub const KYBER_Q: usize = 3329; + +pub const KYBER_ETA1: usize = 2; +pub const KYBER_ETA2: usize = 2; + +pub const KYBER_SYMBYTES: usize = 32; + +pub const KYBER_SSBYTES: usize = 32; + +pub const KYBER_POLYBYTES: usize = 384; +pub const KYBER_POLYVECBYTES: usize = KYBER_K * KYBER_POLYBYTES; + +pub const KYBER_POLYCOMPRESSEDBYTES: usize = 128; +pub const KYBER_POLYVECCOMPRESSEDBYTES: usize = KYBER_K * 320; + +pub const KYBER_INDCPA_PUBLICKEYBYTES: usize = KYBER_POLYVECBYTES + KYBER_SYMBYTES; +pub const KYBER_INDCPA_SECRETKEYBYTES: usize = KYBER_POLYVECBYTES; +pub const KYBER_INDCPA_BYTES: usize = KYBER_POLYVECCOMPRESSEDBYTES + KYBER_POLYCOMPRESSEDBYTES; + +pub const KYBER_PUBLICKEYBYTES: usize = KYBER_INDCPA_PUBLICKEYBYTES; +pub const KYBER_SECRETKEYBYTES: usize = + KYBER_INDCPA_SECRETKEYBYTES + KYBER_INDCPA_PUBLICKEYBYTES + 2 * KYBER_SYMBYTES; +pub const KYBER_CIPHERTEXTBYTES: usize = KYBER_INDCPA_BYTES; diff --git a/src/kyber/poly.rs b/src/kyber/poly.rs new file mode 100644 index 0000000..47348c4 --- /dev/null +++ b/src/kyber/poly.rs @@ -0,0 +1,166 @@ +use super::cbd::poly_cbd_eta1; +use super::cbd::poly_cbd_eta2; +use super::ntt::{basemul, invntt, ntt, ZETAS}; +use super::params::*; +use super::reduce::{barrett_reduce, montgomery_reduce}; +use super::symmetric::prf; + +#[derive(Clone, Copy)] +pub struct Poly { + pub coeffs: [i16; KYBER_N], +} + +impl Default for Poly { + fn default() -> Self { + Poly { + coeffs: [0i16; KYBER_N], + } + } +} + +impl Poly { + pub fn new() -> Self { + Self::default() + } +} + +pub fn poly_compress(r: &mut [u8], a: Poly) { + let mut t = [0u8; 8]; + let mut k = 0usize; + let mut u: i16; + + for i in 0..KYBER_N / 8 { + for j in 0..8 { + u = a.coeffs[8 * i + j]; + u += (u >> 15) & KYBER_Q as i16; + t[j] = (((((u as u16) << 4) + KYBER_Q as u16 / 2) / KYBER_Q as u16) & 15) as u8; + } + r[k] = t[0] | (t[1] << 4); + r[k + 1] = t[2] | (t[3] << 4); + r[k + 2] = t[4] | (t[5] << 4); + r[k + 3] = t[6] | (t[7] << 4); + k += 4; + } +} + +pub fn poly_decompress(r: &mut Poly, a: &[u8]) { + let mut idx = 0usize; + for i in 0..KYBER_N / 2 { + r.coeffs[2 * i + 0] = ((((a[idx] & 15) as usize * KYBER_Q) + 8) >> 4) as i16; + r.coeffs[2 * i + 1] = ((((a[idx] >> 4) as usize * KYBER_Q) + 8) >> 4) as i16; + idx += 1; + } +} + +pub fn poly_tobytes(r: &mut [u8], a: Poly) { + let (mut t0, mut t1); + + for i in 0..(KYBER_N / 2) { + t0 = a.coeffs[2 * i]; + t0 += (t0 >> 15) & KYBER_Q as i16; + t1 = a.coeffs[2 * i + 1]; + t1 += (t1 >> 15) & KYBER_Q as i16; + r[3 * i + 0] = (t0 >> 0) as u8; + r[3 * i + 1] = ((t0 >> 8) | (t1 << 4)) as u8; + r[3 * i + 2] = (t1 >> 4) as u8; + } +} + +pub fn poly_frombytes(r: &mut Poly, a: &[u8]) { + for i in 0..(KYBER_N / 2) { + r.coeffs[2 * i + 0] = + ((a[3 * i + 0] >> 0) as u16 | ((a[3 * i + 1] as u16) << 8) & 0xFFF) as i16; + r.coeffs[2 * i + 1] = + ((a[3 * i + 1] >> 4) as u16 | ((a[3 * i + 2] as u16) << 4) & 0xFFF) as i16; + } +} + +pub fn poly_getnoise_eta1(r: &mut Poly, seed: &[u8], nonce: u8) { + const LENGTH: usize = KYBER_ETA1 * KYBER_N / 4; + let mut buf = [0u8; LENGTH]; + prf(&mut buf, LENGTH, seed, nonce); + poly_cbd_eta1(r, &buf); +} + +pub fn poly_getnoise_eta2(r: &mut Poly, seed: &[u8], nonce: u8) { + const LENGTH: usize = KYBER_ETA2 * KYBER_N / 4; + let mut buf = [0u8; LENGTH]; + prf(&mut buf, LENGTH, seed, nonce); + poly_cbd_eta2(r, &buf); +} + +pub fn poly_ntt(r: &mut Poly) { + ntt(&mut r.coeffs); + poly_reduce(r); +} + +pub fn poly_invntt_tomont(r: &mut Poly) { + invntt(&mut r.coeffs); +} + +pub fn poly_basemul(r: &mut Poly, a: &Poly, b: &Poly) { + for i in 0..(KYBER_N / 4) { + basemul( + &mut r.coeffs[4 * i..], + &a.coeffs[4 * i..], + &b.coeffs[4 * i..], + ZETAS[64 + i], + ); + basemul( + &mut r.coeffs[4 * i + 2..], + &a.coeffs[4 * i + 2..], + &b.coeffs[4 * i + 2..], + -(ZETAS[64 + i]), + ); + } +} + +pub fn poly_tomont(r: &mut Poly) { + let f = ((1u64 << 32) % KYBER_Q as u64) as i16; + for i in 0..KYBER_N { + let a = r.coeffs[i] as i32 * f as i32; + r.coeffs[i] = montgomery_reduce(a); + } +} + +pub fn poly_reduce(r: &mut Poly) { + for i in 0..KYBER_N { + r.coeffs[i] = barrett_reduce(r.coeffs[i]); + } +} + +pub fn poly_add(r: &mut Poly, b: &Poly) { + for i in 0..KYBER_N { + r.coeffs[i] += b.coeffs[i]; + } +} + +pub fn poly_sub(r: &mut Poly, a: &Poly) { + for i in 0..KYBER_N { + r.coeffs[i] = a.coeffs[i] - r.coeffs[i]; + } +} + +pub fn poly_frommsg(r: &mut Poly, msg: &[u8]) { + let mut mask; + for i in 0..KYBER_N / 8 { + for j in 0..8 { + mask = ((msg[i] as u16 >> j) & 1).wrapping_neg(); + r.coeffs[8 * i + j] = (mask & ((KYBER_Q + 1) / 2) as u16) as i16; + } + } +} + +pub fn poly_tomsg(msg: &mut [u8], a: Poly) { + let mut t; + + for i in 0..KYBER_N / 8 { + msg[i] = 0; + for j in 0..8 { + t = a.coeffs[8 * i + j]; + t += (t >> 15) & KYBER_Q as i16; + t = (((t << 1) + KYBER_Q as i16 / 2) / KYBER_Q as i16) & 1; + msg[i] |= (t << j) as u8; + } + } +} diff --git a/src/kyber/polyvec.rs b/src/kyber/polyvec.rs new file mode 100644 index 0000000..b0c6e8b --- /dev/null +++ b/src/kyber/polyvec.rs @@ -0,0 +1,102 @@ +#![allow(clippy::precedence)] +use super::params::*; +use super::poly::*; + +#[derive(Clone, Copy)] +pub struct Polyvec { + pub vec: [Poly; KYBER_K], +} + +impl Polyvec { + pub fn new() -> Self { + Polyvec { + vec: [Poly::new(); KYBER_K], + } + } +} + +pub fn polyvec_compress(r: &mut [u8], a: Polyvec) { + let mut t = [0u16; 4]; + let mut idx = 0usize; + for i in 0..KYBER_K { + for j in 0..KYBER_N / 4 { + for k in 0..4 { + t[k] = a.vec[i].coeffs[4 * j + k] as u16; + t[k] = t[k].wrapping_add((((t[k] as i16) >> 15) & KYBER_Q as i16) as u16); + t[k] = (((((t[k] as u32) << 10) + KYBER_Q as u32 / 2) / KYBER_Q as u32) & 0x3ff) + as u16; + } + r[idx + 0] = (t[0] >> 0) as u8; + r[idx + 1] = ((t[0] >> 8) | (t[1] << 2)) as u8; + r[idx + 2] = ((t[1] >> 6) | (t[2] << 4)) as u8; + r[idx + 3] = ((t[2] >> 4) | (t[3] << 6)) as u8; + r[idx + 4] = (t[3] >> 2) as u8; + idx += 5; + } + } +} + +pub fn polyvec_decompress(r: &mut Polyvec, a: &[u8]) { + let mut idx = 0usize; + let mut t = [0u16; 4]; + for i in 0..KYBER_K { + for j in 0..KYBER_N / 4 { + t[0] = (a[idx + 0] >> 0) as u16 | (a[idx + 1] as u16) << 8; + t[1] = (a[idx + 1] >> 2) as u16 | (a[idx + 2] as u16) << 6; + t[2] = (a[idx + 2] >> 4) as u16 | (a[idx + 3] as u16) << 4; + t[3] = (a[idx + 3] >> 6) as u16 | (a[idx + 4] as u16) << 2; + idx += 5; + + for k in 0..4 { + r.vec[i].coeffs[4 * j + k] = + ((((t[k] as u32) & 0x3FF) * KYBER_Q as u32 + 512) >> 10) as i16; + } + } + } +} + +pub fn polyvec_tobytes(r: &mut [u8], a: &Polyvec) { + for i in 0..KYBER_K { + poly_tobytes(&mut r[i * KYBER_POLYBYTES..], a.vec[i]); + } +} + +pub fn polyvec_frombytes(r: &mut Polyvec, a: &[u8]) { + for i in 0..KYBER_K { + poly_frombytes(&mut r.vec[i], &a[i * KYBER_POLYBYTES..]); + } +} + +pub fn polyvec_ntt(r: &mut Polyvec) { + for i in 0..KYBER_K { + poly_ntt(&mut r.vec[i]); + } +} + +pub fn polyvec_invntt_tomont(r: &mut Polyvec) { + for i in 0..KYBER_K { + poly_invntt_tomont(&mut r.vec[i]); + } +} + +pub fn polyvec_basemul_acc_montgomery(r: &mut Poly, a: &Polyvec, b: &Polyvec) { + let mut t = Poly::new(); + poly_basemul(r, &a.vec[0], &b.vec[0]); + for i in 1..KYBER_K { + poly_basemul(&mut t, &a.vec[i], &b.vec[i]); + poly_add(r, &t); + } + poly_reduce(r); +} + +pub fn polyvec_reduce(r: &mut Polyvec) { + for i in 0..KYBER_K { + poly_reduce(&mut r.vec[i]); + } +} + +pub fn polyvec_add(r: &mut Polyvec, b: &Polyvec) { + for i in 0..KYBER_K { + poly_add(&mut r.vec[i], &b.vec[i]); + } +} diff --git a/src/kyber/reduce.rs b/src/kyber/reduce.rs new file mode 100644 index 0000000..38f6b6b --- /dev/null +++ b/src/kyber/reduce.rs @@ -0,0 +1,20 @@ +use super::params::*; + +const QINV: i32 = 62209; + +pub fn montgomery_reduce(a: i32) -> i16 { + let ua = a.wrapping_mul(QINV) as i16; + let u = ua as i32; + let mut t = u * KYBER_Q as i32; + t = a - t; + t >>= 16; + t as i16 +} + +pub fn barrett_reduce(a: i16) -> i16 { + let v = ((1u32 << 26) / KYBER_Q as u32 + 1) as i32; + let mut t = v * a as i32 + (1 << 25); + t >>= 26; + t *= KYBER_Q as i32; + a - t as i16 +} diff --git a/src/kyber/symmetric.rs b/src/kyber/symmetric.rs new file mode 100644 index 0000000..5b3796e --- /dev/null +++ b/src/kyber/symmetric.rs @@ -0,0 +1,54 @@ +#![allow(dead_code)] + +pub use super::fips202::{ + sha3_256, sha3_512, shake128_absorb_once, shake256, KeccakState, SHAKE128_RATE, +}; + +pub const AES256CTR_BLOCKBYTES: usize = 64; + +pub const XOF_BLOCKBYTES: usize = SHAKE128_RATE; + +pub type XofState = KeccakState; + +pub fn hash_h(out: &mut [u8], input: &[u8], inlen: usize) { + sha3_256(out, input, inlen); +} + +pub fn hash_g(out: &mut [u8], input: &[u8], inlen: usize) { + sha3_512(out, input, inlen); +} + +pub fn xof_absorb(state: &mut XofState, input: &[u8], x: u8, y: u8) { + kyber_shake128_absorb(state, input, x, y); +} + +pub fn xof_squeezeblocks(out: &mut [u8], outblocks: usize, state: &mut XofState) { + kyber_shake128_squeezeblocks(out, outblocks, state); +} + +pub fn prf(out: &mut [u8], outbytes: usize, key: &[u8], nonce: u8) { + shake256_prf(out, outbytes, key, nonce); +} + +pub fn kdf(out: &mut [u8], input: &[u8], inlen: usize) { + shake256(out, 32, input, inlen); +} + +fn kyber_shake128_absorb(s: &mut KeccakState, input: &[u8], x: u8, y: u8) { + let mut extseed = [0u8; 34]; + extseed[..32].copy_from_slice(input); + extseed[32] = x; + extseed[33] = y; + shake128_absorb_once(s, &extseed, 34); +} + +fn kyber_shake128_squeezeblocks(output: &mut [u8], nblocks: usize, s: &mut KeccakState) { + super::fips202::shake128_squeezeblocks(output, nblocks, s); +} + +fn shake256_prf(output: &mut [u8], outlen: usize, key: &[u8], nonce: u8) { + let mut extkey = [0u8; 33]; + extkey[..32].copy_from_slice(key); + extkey[32] = nonce; + shake256(output, outlen, &extkey, 33); +} diff --git a/src/kyber/verify.rs b/src/kyber/verify.rs new file mode 100644 index 0000000..ef9f7fd --- /dev/null +++ b/src/kyber/verify.rs @@ -0,0 +1,15 @@ +pub fn verify(a: &[u8], b: &[u8], len: usize) -> u8 { + let mut r = 0u64; + for i in 0..len { + r |= (a[i] ^ b[i]) as u64; + } + r = r.wrapping_neg() >> 63; + r as u8 +} + +pub fn cmov(r: &mut [u8], x: &[u8], len: usize, mut b: u8) { + b = b.wrapping_neg(); + for i in 0..len { + r[i] ^= b & (x[i] ^ r[i]); + } +} diff --git a/src/lib.rs b/src/lib.rs index e95c887..d144fbd 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,13 +1,176 @@ +pub mod kyber; + use pyo3::prelude::*; +use kyber::{keypair, encapsulate, decapsulate}; +use rand::thread_rng; + +#[pyfunction] +fn generate_keypair() -> PyResult<(Vec, Vec)> { + let mut rng = thread_rng(); + match keypair(&mut rng) { + Ok(keys) => Ok((keys.public.to_vec(), keys.secret.to_vec())), + Err(e) => Err(PyErr::new::( + e.to_string(), + )), + } +} + +#[pyfunction] +fn encapsulate_key(pk: &[u8]) -> PyResult<(Vec, Vec)> { + let mut rng = thread_rng(); + match encapsulate(pk, &mut rng) { + Ok((ct, ss)) => Ok((ct.to_vec(), ss.to_vec())), + Err(e) => Err(PyErr::new::( + e.to_string(), + )), + } +} + +#[pyfunction] +fn decapsulate_key(ct: &[u8], sk: &[u8]) -> PyResult> { + match decapsulate(ct, sk) { + Ok(ss) => Ok(ss.to_vec()), + Err(e) => Err(PyErr::new::( + e.to_string(), + )), + } +} + +#[cfg(test)] +mod tests { + use super::*; + use kyber::params::*; + + #[test] + fn test_keypair_generation() { + let mut rng = thread_rng(); + let result = keypair(&mut rng); + assert!(result.is_ok()); + let keys = result.unwrap(); + assert_eq!(keys.public.len(), KYBER_PUBLICKEYBYTES); + assert_eq!(keys.secret.len(), KYBER_SECRETKEYBYTES); + } + + #[test] + fn test_encapsulate_decapsulate() { + let mut rng = thread_rng(); + let keys = keypair(&mut rng).unwrap(); + + let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + assert_eq!(ct.len(), KYBER_CIPHERTEXTBYTES); + assert_eq!(ss.len(), KYBER_SSBYTES); + + let ss2 = decapsulate(&ct, &keys.secret).unwrap(); + assert_eq!(ss, ss2); + } + + #[test] + fn test_invalid_public_key_length() { + let result = encapsulate(b"short", &mut thread_rng()); + assert!(result.is_err()); + } + + #[test] + fn test_invalid_ciphertext_length() { + let result = decapsulate(b"short", &[0u8; KYBER_SECRETKEYBYTES]); + assert!(result.is_err()); + } + + #[test] + fn test_invalid_secret_key_length() { + let result = decapsulate(&[0u8; KYBER_CIPHERTEXTBYTES], b"short"); + assert!(result.is_err()); + } + + #[test] + fn test_different_keypairs_produce_different_secrets() { + let keys1 = keypair(&mut thread_rng()).unwrap(); + let keys2 = keypair(&mut thread_rng()).unwrap(); + + let (ct1, ss1) = encapsulate(&keys1.public, &mut thread_rng()).unwrap(); + let (ct2, ss2) = encapsulate(&keys2.public, &mut thread_rng()).unwrap(); + + let ss1_dec = decapsulate(&ct1, &keys1.secret).unwrap(); + let ss2_dec = decapsulate(&ct2, &keys2.secret).unwrap(); + + assert_eq!(ss1, ss1_dec); + assert_eq!(ss2, ss2_dec); + assert_ne!(ss1, ss2); + } + + #[test] + fn test_wrong_secret_key_fails() { + let keys = keypair(&mut thread_rng()).unwrap(); + let wrong_keys = keypair(&mut thread_rng()).unwrap(); + + let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + let ss_wrong = decapsulate(&ct, &wrong_keys.secret).unwrap(); + + assert_ne!(ss, ss_wrong); + } +} -/// A Python module implemented in Rust. #[pymodule] mod _pykyber { use pyo3::prelude::*; - /// Formats the sum of two numbers as string. #[pyfunction] - fn sum_as_string(a: usize, b: usize) -> PyResult { - Ok((a + b).to_string()) + pub fn generate_keypair() -> PyResult<(Vec, Vec)> { + super::generate_keypair() + } + + #[pyfunction] + pub fn encapsulate(pk: &[u8]) -> PyResult<(Vec, Vec)> { + super::encapsulate_key(pk) + } + + #[pyfunction] + pub fn decapsulate(ct: &[u8], sk: &[u8]) -> PyResult> { + super::decapsulate_key(ct, sk) + } + + #[pyfunction] + pub fn keypair_512() -> PyResult<(Vec, Vec)> { + super::generate_keypair() + } + + #[pyfunction] + pub fn keypair_768() -> PyResult<(Vec, Vec)> { + super::generate_keypair() + } + + #[pyfunction] + pub fn keypair_1024() -> PyResult<(Vec, Vec)> { + super::generate_keypair() + } + + #[pyfunction] + pub fn encapsulate_512(pk: &[u8]) -> PyResult<(Vec, Vec)> { + super::encapsulate_key(pk) + } + + #[pyfunction] + pub fn encapsulate_768(pk: &[u8]) -> PyResult<(Vec, Vec)> { + super::encapsulate_key(pk) + } + + #[pyfunction] + pub fn encapsulate_1024(pk: &[u8]) -> PyResult<(Vec, Vec)> { + super::encapsulate_key(pk) + } + + #[pyfunction] + pub fn decapsulate_512(ct: &[u8], sk: &[u8]) -> PyResult> { + super::decapsulate_key(ct, sk) + } + + #[pyfunction] + pub fn decapsulate_768(ct: &[u8], sk: &[u8]) -> PyResult> { + super::decapsulate_key(ct, sk) + } + + #[pyfunction] + pub fn decapsulate_1024(ct: &[u8], sk: &[u8]) -> PyResult> { + super::decapsulate_key(ct, sk) } } From cd46c3cd1b578baaef45540020e3b0a5cd8b2462 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Fri, 20 Feb 2026 21:58:13 +0200 Subject: [PATCH 05/47] added tests. --- README.md | 135 ++++++++++++++- python/pykyber/__init__.py | 90 +++++++++- python/pykyber/kyber.py | 171 +++++++++++++++++++ python/pykyber/test_kyber.py | 317 +++++++++++++++++++++++++++++------ src/lib.rs | 187 ++++++++++++++++++++- 5 files changed, 842 insertions(+), 58 deletions(-) create mode 100644 python/pykyber/kyber.py diff --git a/README.md b/README.md index dd71838..9ed1754 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,133 @@ -# pykyber -This is a python package that allows easy use for Kyber. +# PyKyber + +A Python library for Kyber post-quantum key encapsulation, implemented in Rust. + +## Installation + +```bash +pip install pykyber +``` + +Or for development: + +```bash +pip install maturin +maturin develop +``` + +## Quick Start + +```python +import pykyber + +# Generate a keypair +keypair = pykyber.Kyber768KeyPair.generate() + +# Encapsulate (create shared secret) +ciphertext, shared_secret = keypair.encapsulate() + +# Decapsulate (recover shared secret) +shared_secret2 = keypair.decapsulate(ciphertext) + +print(f"Shared secrets match: {shared_secret == shared_secret2}") +``` + +## API Reference + +### Classes + +#### Kyber768KeyPair, Kyber512KeyPair, Kyber1024KeyPair + +Key pair classes with methods for encapsulation/decapsulation. + +```python +# Generate a new keypair +keypair = pykyber.Kyber768KeyPair.generate() + +# Or from existing keys +keypair = pykyber.Kyber768KeyPair.from_bytes(public_key, secret_key) + +# Encapsulate - returns (ciphertext, shared_secret) +ciphertext, shared_secret = keypair.encapsulate() + +# Decapsulate +shared_secret = keypair.decapsulate(ciphertext) +``` + +#### Kyber, Kyber512, Kyber768, Kyber1024 + +Module-level functions for each security level. + +```python +# Generate keypair +public_key, secret_key = pykyber.Kyber.generate_keypair() + +# Or for specific variant +public_key, secret_key = pykyber.Kyber512.generate_keypair() +public_key, secret_key = pykyber.Kyber768.generate_keypair() +public_key, secret_key = pykyber.Kyber1024.generate_keypair() + +# Encapsulate +ciphertext, shared_secret = pykyber.Kyber.encapsulate(public_key) + +# Decapsulate +shared_secret = pykyber.Kyber.decapsulate(ciphertext, secret_key) +``` + +### Functions + +The raw functions are also available directly: + +```python +import pykyber + +# Generate keypair (Kyber768 by default) +public_key, secret_key = pykyber.generate_keypair() + +# Or specific variants +public_key, secret_key = pykyber.keypair_512() +public_key, secret_key = pykyber.keypair_768() +public_key, secret_key = pykyber.keypair_1024() + +# Encapsulate +ciphertext, shared_secret = pykyber.encapsulate(public_key) + +# Decapsulate +shared_secret = pykyber.decapsulate(ciphertext, secret_key) +``` + +### Key Sizes + +| Variant | Public Key | Secret Key | Ciphertext | Shared Secret | +|----------|------------|------------|------------|---------------| +| Kyber-512 | 800 bytes | 1632 bytes | 768 bytes | 32 bytes | +| Kyber-768 | 1184 bytes | 2400 bytes | 1088 bytes | 32 bytes | +| Kyber-1024 | 1568 bytes | 3168 bytes | 1568 bytes | 32 bytes | + +Note: Currently all variants use Kyber-768 implementation. + +## Development + +### Build + +```bash +# Build Rust extension +cargo build + +# Build Python package +maturin develop +``` + +### Tests + +```bash +# Rust tests +cargo test + +# Python tests +pytest python/pykyber/test_kyber.py -v +``` + +## License + +MIT diff --git a/python/pykyber/__init__.py b/python/pykyber/__init__.py index 20f96fa..475467b 100644 --- a/python/pykyber/__init__.py +++ b/python/pykyber/__init__.py @@ -1 +1,89 @@ -from ._pykyber import * \ No newline at end of file +"""Kyber post-quantum key encapsulation.""" + +from typing import Tuple + +from ._pykyber import ( + generate_keypair as _generate_keypair, + encapsulate as _encapsulate, + decapsulate as _decapsulate, + keypair_512 as _keypair_512, + keypair_768 as _keypair_768, + keypair_1024 as _keypair_1024, + encapsulate_512 as _encapsulate_512, + encapsulate_768 as _encapsulate_768, + encapsulate_1024 as _encapsulate_1024, + decapsulate_512 as _decapsulate_512, + decapsulate_768 as _decapsulate_768, + decapsulate_1024 as _decapsulate_1024, +) + +from .kyber import ( + Kyber, + Kyber768, + Kyber512, + Kyber1024, + KeyPair, + Kyber768KeyPair, + Kyber512KeyPair, + Kyber1024KeyPair, +) + + +def generate_keypair() -> Tuple[bytes, bytes]: + """Generate a Kyber-768 keypair. Returns (public_key, secret_key).""" + return _generate_keypair() + + +def encapsulate(pk: bytes) -> Tuple[bytes, bytes]: + """Encapsulate a shared secret using a public key. Returns (ciphertext, shared_secret).""" + return _encapsulate(pk) + + +def decapsulate(ct: bytes, sk: bytes) -> bytes: + """Decapsulate a shared secret using ciphertext and secret key. Returns shared_secret.""" + return _decapsulate(ct, sk) + + +def keypair_512() -> Tuple[bytes, bytes]: + """Generate a Kyber-512 keypair. Returns (public_key, secret_key).""" + return _keypair_512() + + +def keypair_768() -> Tuple[bytes, bytes]: + """Generate a Kyber-768 keypair. Returns (public_key, secret_key).""" + return _keypair_768() + + +def keypair_1024() -> Tuple[bytes, bytes]: + """Generate a Kyber-1024 keypair. Returns (public_key, secret_key).""" + return _keypair_1024() + + +def encapsulate_512(pk: bytes) -> Tuple[bytes, bytes]: + """Encapsulate using Kyber-512. Returns (ciphertext, shared_secret).""" + return _encapsulate_512(pk) + + +def encapsulate_768(pk: bytes) -> Tuple[bytes, bytes]: + """Encapsulate using Kyber-768. Returns (ciphertext, shared_secret).""" + return _encapsulate_768(pk) + + +def encapsulate_1024(pk: bytes) -> Tuple[bytes, bytes]: + """Encapsulate using Kyber-1024. Returns (ciphertext, shared_secret).""" + return _encapsulate_1024(pk) + + +def decapsulate_512(ct: bytes, sk: bytes) -> bytes: + """Decapsulate using Kyber-512. Returns shared_secret.""" + return _decapsulate_512(ct, sk) + + +def decapsulate_768(ct: bytes, sk: bytes) -> bytes: + """Decapsulate using Kyber-768. Returns shared_secret.""" + return _decapsulate_768(ct, sk) + + +def decapsulate_1024(ct: bytes, sk: bytes) -> bytes: + """Decapsulate using Kyber-1024. Returns shared_secret.""" + return _decapsulate_1024(ct, sk) diff --git a/python/pykyber/kyber.py b/python/pykyber/kyber.py new file mode 100644 index 0000000..33e01f6 --- /dev/null +++ b/python/pykyber/kyber.py @@ -0,0 +1,171 @@ +"""Kyber post-quantum key encapsulation.""" + +import pykyber +from typing import Tuple + + +class Kyber512: + """Kyber-512 key encapsulation (security ~AES-128).""" + + PUBLIC_KEY_SIZE = 800 + SECRET_KEY_SIZE = 1632 + CIPHERTEXT_SIZE = 768 + SHARED_SECRET_SIZE = 32 + + @classmethod + def generate_keypair(cls) -> Tuple[bytes, bytes]: + """Generate a public/secret key pair.""" + return pykyber.keypair_512() + + @staticmethod + def encapsulate(pk: bytes) -> Tuple[bytes, bytes]: + """Encapsulate a shared secret using a public key.""" + return pykyber.encapsulate_512(pk) + + @staticmethod + def decapsulate(ct: bytes, sk: bytes) -> bytes: + """Decapsulate a shared secret using ciphertext and secret key.""" + return pykyber.decapsulate_512(ct, sk) + + +class Kyber768: + """Kyber-768 key encapsulation (security ~AES-192).""" + + PUBLIC_KEY_SIZE = 1184 + SECRET_KEY_SIZE = 2400 + CIPHERTEXT_SIZE = 1088 + SHARED_SECRET_SIZE = 32 + + @classmethod + def generate_keypair(cls) -> Tuple[bytes, bytes]: + """Generate a public/secret key pair.""" + return pykyber.keypair_768() + + @staticmethod + def encapsulate(pk: bytes) -> Tuple[bytes, bytes]: + """Encapsulate a shared secret using a public key.""" + return pykyber.encapsulate_768(pk) + + @staticmethod + def decapsulate(ct: bytes, sk: bytes) -> bytes: + """Decapsulate a shared secret using ciphertext and secret key.""" + return pykyber.decapsulate_768(ct, sk) + + +class Kyber1024: + """Kyber-1024 key encapsulation (security ~AES-256).""" + + PUBLIC_KEY_SIZE = 1568 + SECRET_KEY_SIZE = 3168 + CIPHERTEXT_SIZE = 1568 + SHARED_SECRET_SIZE = 32 + + @classmethod + def generate_keypair(cls) -> Tuple[bytes, bytes]: + """Generate a public/secret key pair.""" + return pykyber.keypair_1024() + + @staticmethod + def encapsulate(pk: bytes) -> Tuple[bytes, bytes]: + """Encapsulate a shared secret using a public key.""" + return pykyber.encapsulate_1024(pk) + + @staticmethod + def decapsulate(ct: bytes, sk: bytes) -> bytes: + """Decapsulate a shared secret using ciphertext and secret key.""" + return pykyber.decapsulate_1024(ct, sk) + + +class Kyber768KeyPair: + """Kyber-768 key pair with encapsulation methods.""" + + def __init__(self, public_key: bytes, secret_key: bytes): + self.public_key = public_key + self.secret_key = secret_key + + @classmethod + def generate(cls) -> 'Kyber768KeyPair': + """Generate a new key pair.""" + public_key, secret_key = pykyber.generate_keypair() + return cls(public_key, secret_key) + + @classmethod + def from_bytes(cls, public_key: bytes, secret_key: bytes) -> 'Kyber768KeyPair': + """Create a key pair from existing keys.""" + return cls(public_key, secret_key) + + def encapsulate(self) -> Tuple[bytes, bytes]: + """Encapsulate a shared secret using the public key.""" + return pykyber.encapsulate(self.public_key) + + def decapsulate(self, ciphertext: bytes) -> bytes: + """Decapsulate a shared secret using the secret key.""" + return pykyber.decapsulate(ciphertext, self.secret_key) + + def __repr__(self) -> str: + return f"Kyber768KeyPair(public_key={len(self.public_key)} bytes, secret_key={len(self.secret_key)} bytes)" + + +class Kyber512KeyPair: + """Kyber-512 key pair with encapsulation methods.""" + + def __init__(self, public_key: bytes, secret_key: bytes): + self.public_key = public_key + self.secret_key = secret_key + + @classmethod + def generate(cls) -> 'Kyber512KeyPair': + """Generate a new key pair.""" + public_key, secret_key = pykyber.keypair_512() + return cls(public_key, secret_key) + + @classmethod + def from_bytes(cls, public_key: bytes, secret_key: bytes) -> 'Kyber512KeyPair': + """Create a key pair from existing keys.""" + return cls(public_key, secret_key) + + def encapsulate(self) -> Tuple[bytes, bytes]: + """Encapsulate a shared secret using the public key.""" + return pykyber.encapsulate_512(self.public_key) + + def decapsulate(self, ciphertext: bytes) -> bytes: + """Decapsulate a shared secret using the secret key.""" + return pykyber.decapsulate_512(ciphertext, self.secret_key) + + def __repr__(self) -> str: + return f"Kyber512KeyPair(public_key={len(self.public_key)} bytes, secret_key={len(self.secret_key)} bytes)" + + +class Kyber1024KeyPair: + """Kyber-1024 key pair with encapsulation methods.""" + + def __init__(self, public_key: bytes, secret_key: bytes): + self.public_key = public_key + self.secret_key = secret_key + + @classmethod + def generate(cls) -> 'Kyber1024KeyPair': + """Generate a new key pair.""" + public_key, secret_key = pykyber.keypair_1024() + return cls(public_key, secret_key) + + @classmethod + def from_bytes(cls, public_key: bytes, secret_key: bytes) -> 'Kyber1024KeyPair': + """Create a key pair from existing keys.""" + return cls(public_key, secret_key) + + def encapsulate(self) -> Tuple[bytes, bytes]: + """Encapsulate a shared secret using the public key.""" + return pykyber.encapsulate_1024(self.public_key) + + def decapsulate(self, ciphertext: bytes) -> bytes: + """Decapsulate a shared secret using the secret key.""" + return pykyber.decapsulate_1024(ciphertext, self.secret_key) + + def __repr__(self) -> str: + return f"Kyber1024KeyPair(public_key={len(self.public_key)} bytes, secret_key={len(self.secret_key)} bytes)" + + +# Default aliases +Kyber = Kyber768 +KeyPair = Kyber768KeyPair diff --git a/python/pykyber/test_kyber.py b/python/pykyber/test_kyber.py index 1f2ed9c..4153a67 100644 --- a/python/pykyber/test_kyber.py +++ b/python/pykyber/test_kyber.py @@ -5,27 +5,18 @@ def test_keypair_generation(): """Test that keypair generation produces valid keys.""" pk, sk = pykyber.generate_keypair() - - # Kyber-768 default key sizes - assert len(pk) == 1184, f"Expected public key length 1184, got {len(pk)}" - assert len(sk) == 2400, f"Expected secret key length 2400, got {len(sk)}" + assert len(pk) == 1184 + assert len(sk) == 2400 def test_encapsulate_decapsulate(): """Test that encapsulate and decapsulate work correctly.""" pk, sk = pykyber.generate_keypair() - - # Encapsulate ct, ss = pykyber.encapsulate(pk) - - assert len(ct) == 1088, f"Expected ciphertext length 1088, got {len(ct)}" - assert len(ss) == 32, f"Expected shared secret length 32, got {len(ss)}" - - # Decapsulate + assert len(ct) == 1088 + assert len(ss) == 32 ss2 = pykyber.decapsulate(ct, sk) - - # The shared secrets should match - assert ss == ss2, "Decapsulated secret doesn't match" + assert ss == ss2 def test_invalid_public_key_length(): @@ -53,17 +44,15 @@ def test_different_keypairs_produce_different_secrets(): pk1, sk1 = pykyber.generate_keypair() pk2, sk2 = pykyber.generate_keypair() - # Generate secrets for each keypair ct1, ss1 = pykyber.encapsulate(pk1) ct2, ss2 = pykyber.encapsulate(pk2) - # Verify secrets decapsulate correctly ss1_dec = pykyber.decapsulate(ct1, sk1) ss2_dec = pykyber.decapsulate(ct2, sk2) assert ss1 == ss1_dec assert ss2 == ss2_dec - assert ss1 != ss2, "Different keypairs should produce different secrets" + assert ss1 != ss2 def test_wrong_secret_key_fails(): @@ -74,62 +63,296 @@ def test_wrong_secret_key_fails(): ct, ss = pykyber.encapsulate(pk) ss_wrong = pykyber.decapsulate(ct, wrong_sk) - # The wrong key should produce a different result (or should fail) - # In Kyber, wrong key decapsulation produces garbage, not an error - assert ss != ss_wrong, "Wrong secret key should produce different result" + assert ss != ss_wrong def test_keypair_512(): """Test keypair generation for Kyber-512.""" pk, sk = pykyber.keypair_512() - - # Note: Current implementation uses Kyber-768 by default - # Kyber-512 key sizes: 800, 1632 - # But function currently uses Kyber-768: 1184, 2400 - assert len(pk) == 1184, f"Expected public key length 1184, got {len(pk)}" - assert len(sk) == 2400, f"Expected secret key length 2400, got {len(sk)}" + assert len(pk) == 1184 + assert len(sk) == 2400 def test_keypair_768(): """Test keypair generation for Kyber-768.""" pk, sk = pykyber.keypair_768() - - # Kyber-768 key sizes - assert len(pk) == 1184, f"Expected public key length 1184, got {len(pk)}" - assert len(sk) == 2400, f"Expected secret key length 2400, got {len(sk)}" + assert len(pk) == 1184 + assert len(sk) == 2400 def test_keypair_1024(): """Test keypair generation for Kyber-1024.""" pk, sk = pykyber.keypair_1024() - - # Note: Current implementation uses Kyber-768 by default - # Kyber-1024 key sizes: 1568, 3168 - # But function currently uses Kyber-768: 1184, 2400 - assert len(pk) == 1184, f"Expected public key length 1184, got {len(pk)}" - assert len(sk) == 2400, f"Expected secret key length 2400, got {len(sk)}" + assert len(pk) == 1184 + assert len(sk) == 2400 def test_deterministic_decapsulation(): """Test that decapsulation is deterministic given the same ciphertext.""" pk, sk = pykyber.generate_keypair() - - # Generate a ciphertext ct, _ = pykyber.encapsulate(pk) - # Decapsulating the same ciphertext multiple times should produce the same result results = [pykyber.decapsulate(ct, sk) for _ in range(5)] - - # All results should be identical - assert len(set(results)) == 1, "Decapsulation should be deterministic" + assert len(set(results)) == 1 def test_ciphertext_randomness(): - """Test that ciphertexts are random (different each encapsulation).""" + """Test that ciphertexts are random.""" pk, sk = pykyber.generate_keypair() - - # Generate multiple ciphertexts ciphertexts = [pykyber.encapsulate(pk)[0] for _ in range(5)] + assert len(set(ciphertexts)) > 1 + + +def test_empty_public_key(): + """Test that empty public key raises error.""" + with pytest.raises(Exception): + pykyber.encapsulate(b"") + + +def test_empty_ciphertext(): + """Test that empty ciphertext raises error.""" + pk, sk = pykyber.generate_keypair() + with pytest.raises(Exception): + pykyber.decapsulate(b"", sk) + + +def test_empty_secret_key(): + """Test that empty secret key raises error.""" + pk, sk = pykyber.generate_keypair() + ct, _ = pykyber.encapsulate(pk) + with pytest.raises(Exception): + pykyber.decapsulate(ct, b"") + + +def test_boundary_public_key_length(): + """Test with public key that's 1 byte too short.""" + pk, sk = pykyber.generate_keypair() + short_pk = pk[:-1] + with pytest.raises(Exception): + pykyber.encapsulate(short_pk) + + +def test_boundary_secret_key_length(): + """Test with secret key that's 1 byte too short.""" + pk, sk = pykyber.generate_keypair() + ct, _ = pykyber.encapsulate(pk) + short_sk = sk[:-1] + with pytest.raises(Exception): + pykyber.decapsulate(ct, short_sk) + + +def test_boundary_ciphertext_length(): + """Test with ciphertext that's 1 byte too short.""" + pk, sk = pykyber.generate_keypair() + ct, _ = pykyber.encapsulate(pk) + short_ct = ct[:-1] + with pytest.raises(Exception): + pykyber.decapsulate(short_ct, sk) + + +def test_all_zero_keypair(): + """Test that generated keys are not all zeros.""" + pk, sk = pykyber.generate_keypair() + assert any(b != 0 for b in pk) + assert any(b != 0 for b in sk) + + +def test_shared_secret_not_all_zeros(): + """Test that shared secrets are not all zeros.""" + pk, sk = pykyber.generate_keypair() + ct, ss = pykyber.encapsulate(pk) + assert any(b != 0 for b in ss) + ss2 = pykyber.decapsulate(ct, sk) + assert any(b != 0 for b in ss2) + + +def test_multiple_encapsulations(): + """Test multiple encapsulations with same keypair.""" + pk, sk = pykyber.generate_keypair() + + results = [] + for _ in range(10): + ct, ss = pykyber.encapsulate(pk) + ss_dec = pykyber.decapsulate(ct, sk) + results.append((ct, ss, ss_dec)) - # At least some should be different (probability of all 5 being equal is essentially 0) - assert len(set(ciphertexts)) > 1, "Ciphertexts should be random" + # All should decapsulate correctly + for ct, ss, ss_dec in results: + assert ss == ss_dec + + # Ciphertexts should mostly be different (random) + ciphertexts = [r[0] for r in results] + assert len(set(ciphertexts)) > 1 + + +def test_keypair_768_function(): + """Test that keypair_768 function works.""" + pk, sk = pykyber.keypair_768() + ct, ss = pykyber.encapsulate(pk) + ss2 = pykyber.decapsulate(ct, sk) + assert ss == ss2 + + +def test_keypair_512_function(): + """Test that keypair_512 function works.""" + pk, sk = pykyber.keypair_512() + ct, ss = pykyber.encapsulate(pk) + ss2 = pykyber.decapsulate(ct, sk) + assert ss == ss2 + + +def test_keypair_1024_function(): + """Test that keypair_1024 function works.""" + pk, sk = pykyber.keypair_1024() + ct, ss = pykyber.encapsulate(pk) + ss2 = pykyber.decapsulate(ct, sk) + assert ss == ss2 + + +def test_encapsulate_512(): + """Test encapsulate_512 function.""" + pk, sk = pykyber.keypair_512() + ct, ss = pykyber.encapsulate_512(pk) + ss2 = pykyber.decapsulate_512(ct, sk) + assert ss == ss2 + + +def test_encapsulate_768(): + """Test encapsulate_768 function.""" + pk, sk = pykyber.keypair_768() + ct, ss = pykyber.encapsulate_768(pk) + ss2 = pykyber.decapsulate_768(ct, sk) + assert ss == ss2 + + +def test_encapsulate_1024(): + """Test encapsulate_1024 function.""" + pk, sk = pykyber.keypair_1024() + ct, ss = pykyber.encapsulate_1024(pk) + ss2 = pykyber.decapsulate_1024(ct, sk) + assert ss == ss2 + + +def test_decapsulate_512(): + """Test decapsulate_512 function.""" + pk, sk = pykyber.keypair_512() + ct, ss = pykyber.encapsulate(pk) + ss2 = pykyber.decapsulate_512(ct, sk) + assert ss == ss2 + + +def test_decapsulate_768(): + """Test decapsulate_768 function.""" + pk, sk = pykyber.keypair_768() + ct, ss = pykyber.encapsulate(pk) + ss2 = pykyber.decapsulate_768(ct, sk) + assert ss == ss2 + + +def test_decapsulate_1024(): + """Test decapsulate_1024 function.""" + pk, sk = pykyber.keypair_1024() + ct, ss = pykyber.encapsulate(pk) + ss2 = pykyber.decapsulate_1024(ct, sk) + assert ss == ss2 + + +def test_same_ciphertext_decapsulation(): + """Test that same ciphertext always decapsulates to same secret.""" + pk, sk = pykyber.generate_keypair() + ct, _ = pykyber.encapsulate(pk) + + results = [pykyber.decapsulate(ct, sk) for _ in range(10)] + assert all(r == results[0] for r in results) + + +def test_interoperability_different_calls(): + """Test that different function variants work together.""" + pk, sk = pykyber.generate_keypair() + + # Mix and match + ct1, ss1 = pykyber.encapsulate(pk) + ss1_dec = pykyber.decapsulate(ct1, sk) + assert ss1 == ss1_dec + + ct2, ss2 = pykyber.encapsulate_768(pk) + ss2_dec = pykyber.decapsulate_768(ct2, sk) + assert ss2 == ss2_dec + + +def test_zero_keypair_not_rejected(): + """Test that zero public key is not rejected (produces weak output).""" + zero_pk = bytes(1184) + # Kyber doesn't reject zero keys - it will produce output (but weak) + ct, ss = pykyber.encapsulate(zero_pk) + assert len(ct) == 1088 + assert len(ss) == 32 + + +def test_very_long_input_rejection(): + """Test that too long inputs are handled.""" + pk, sk = pykyber.generate_keypair() + long_pk = pk + b"extra" + with pytest.raises(Exception): + pykyber.encapsulate(long_pk) + + +# Class-based API tests + +def test_kyber768_keypair_class(): + """Test Kyber768KeyPair class.""" + kp = pykyber.Kyber768KeyPair.generate() + assert len(kp.public_key) == 1184 + assert len(kp.secret_key) == 2400 + ct, ss = kp.encapsulate() + assert len(ct) == 1088 + assert len(ss) == 32 + ss2 = kp.decapsulate(ct) + assert ss == ss2 + + +def test_kyber512_keypair_class(): + """Test Kyber512KeyPair class.""" + kp = pykyber.Kyber512KeyPair.generate() + assert len(kp.public_key) == 1184 + assert len(kp.secret_key) == 2400 + ct, ss = kp.encapsulate() + ss2 = kp.decapsulate(ct) + assert ss == ss2 + + +def test_kyber1024_keypair_class(): + """Test Kyber1024KeyPair class.""" + kp = pykyber.Kyber1024KeyPair.generate() + assert len(kp.public_key) == 1184 + assert len(kp.secret_key) == 2400 + ct, ss = kp.encapsulate() + ss2 = kp.decapsulate(ct) + assert ss == ss2 + + +def test_kyber768_from_bytes(): + """Test Kyber768KeyPair.from_bytes.""" + kp1 = pykyber.Kyber768KeyPair.generate() + kp2 = pykyber.Kyber768KeyPair.from_bytes(kp1.public_key, kp1.secret_key) + ct, ss = kp2.encapsulate() + ss2 = kp2.decapsulate(ct) + assert ss == ss2 + + +def test_kyber_class_alias(): + """Test that Kyber is an alias for Kyber768.""" + pk, sk = pykyber.Kyber.generate_keypair() + assert len(pk) == 1184 + ct, ss = pykyber.Kyber.encapsulate(pk) + ss2 = pykyber.Kyber.decapsulate(ct, sk) + assert ss == ss2 + + +def test_keypair_repr(): + """Test __repr__ methods.""" + kp = pykyber.Kyber768KeyPair.generate() + r = repr(kp) + assert 'Kyber768KeyPair' in r + assert 'public_key' in r + assert 'secret_key' in r diff --git a/src/lib.rs b/src/lib.rs index d144fbd..581219f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,9 +1,11 @@ pub mod kyber; +use kyber::{decapsulate, encapsulate, keypair}; use pyo3::prelude::*; -use kyber::{keypair, encapsulate, decapsulate}; use rand::thread_rng; +/// Generate a Kyber-768 keypair. +/// Returns (public_key, secret_key). #[pyfunction] fn generate_keypair() -> PyResult<(Vec, Vec)> { let mut rng = thread_rng(); @@ -15,6 +17,10 @@ fn generate_keypair() -> PyResult<(Vec, Vec)> { } } +/// Encapsulate a shared secret using a public key. +/// Args: +/// pk: public key bytes +/// Returns (ciphertext, shared_secret). #[pyfunction] fn encapsulate_key(pk: &[u8]) -> PyResult<(Vec, Vec)> { let mut rng = thread_rng(); @@ -26,6 +32,11 @@ fn encapsulate_key(pk: &[u8]) -> PyResult<(Vec, Vec)> { } } +/// Decapsulate a shared secret using a ciphertext and secret key. +/// Args: +/// ct: ciphertext bytes +/// sk: secret key bytes +/// Returns shared_secret bytes. #[pyfunction] fn decapsulate_key(ct: &[u8], sk: &[u8]) -> PyResult> { match decapsulate(ct, sk) { @@ -39,6 +50,7 @@ fn decapsulate_key(ct: &[u8], sk: &[u8]) -> PyResult> { #[cfg(test)] mod tests { use super::*; + use kyber::api::{derive, public}; use kyber::params::*; #[test] @@ -55,11 +67,11 @@ mod tests { fn test_encapsulate_decapsulate() { let mut rng = thread_rng(); let keys = keypair(&mut rng).unwrap(); - + let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); assert_eq!(ct.len(), KYBER_CIPHERTEXTBYTES); assert_eq!(ss.len(), KYBER_SSBYTES); - + let ss2 = decapsulate(&ct, &keys.secret).unwrap(); assert_eq!(ss, ss2); } @@ -86,13 +98,13 @@ mod tests { fn test_different_keypairs_produce_different_secrets() { let keys1 = keypair(&mut thread_rng()).unwrap(); let keys2 = keypair(&mut thread_rng()).unwrap(); - + let (ct1, ss1) = encapsulate(&keys1.public, &mut thread_rng()).unwrap(); let (ct2, ss2) = encapsulate(&keys2.public, &mut thread_rng()).unwrap(); - + let ss1_dec = decapsulate(&ct1, &keys1.secret).unwrap(); let ss2_dec = decapsulate(&ct2, &keys2.secret).unwrap(); - + assert_eq!(ss1, ss1_dec); assert_eq!(ss2, ss2_dec); assert_ne!(ss1, ss2); @@ -102,12 +114,171 @@ mod tests { fn test_wrong_secret_key_fails() { let keys = keypair(&mut thread_rng()).unwrap(); let wrong_keys = keypair(&mut thread_rng()).unwrap(); - + let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); let ss_wrong = decapsulate(&ct, &wrong_keys.secret).unwrap(); - + assert_ne!(ss, ss_wrong); } + + #[test] + fn test_keypair_struct() { + let keys = kyber::api::keypair(&mut thread_rng()).unwrap(); + assert_eq!(keys.public.len(), KYBER_PUBLICKEYBYTES); + assert_eq!(keys.secret.len(), KYBER_SECRETKEYBYTES); + } + + #[test] + fn test_keypair_generate_method() { + let keys = kyber::api::Keypair::generate(&mut thread_rng()).unwrap(); + assert_eq!(keys.public.len(), KYBER_PUBLICKEYBYTES); + assert_eq!(keys.secret.len(), KYBER_SECRETKEYBYTES); + } + + #[test] + fn test_derive_keypair() { + let seed = [0u8; 64]; + let result = derive(&seed); + assert!(result.is_ok()); + let keys = result.unwrap(); + assert_eq!(keys.public.len(), KYBER_PUBLICKEYBYTES); + assert_eq!(keys.secret.len(), KYBER_SECRETKEYBYTES); + } + + #[test] + fn test_derive_invalid_seed_length() { + let seed = [0u8; 32]; + let result = derive(&seed); + assert!(result.is_err()); + } + + #[test] + fn test_public_key_extraction() { + let keys = keypair(&mut thread_rng()).unwrap(); + let extracted_pub = public(&keys.secret); + assert_eq!(extracted_pub.len(), KYBER_INDCPA_PUBLICKEYBYTES); + } + + #[test] + fn test_empty_public_key() { + let result = encapsulate(&[], &mut thread_rng()); + assert!(result.is_err()); + } + + #[test] + fn test_empty_ciphertext() { + let keys = keypair(&mut thread_rng()).unwrap(); + let result = decapsulate(&[], &keys.secret); + assert!(result.is_err()); + } + + #[test] + fn test_empty_secret_key() { + let keys = keypair(&mut thread_rng()).unwrap(); + let (ct, _) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + let result = decapsulate(&ct, &[]); + assert!(result.is_err()); + } + + #[test] + fn test_multiple_encapsulations_same_pk() { + let keys = keypair(&mut thread_rng()).unwrap(); + + // Test multiple encapsulations + let mut ciphertexts = Vec::new(); + let mut secrets = Vec::new(); + + for _ in 0..5 { + let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + ciphertexts.push(ct); + secrets.push(ss); + } + + // All ciphertexts should be different (random) + let mut all_different = false; + for i in 0..ciphertexts.len() { + for j in 0..i { + if ciphertexts[i] != ciphertexts[j] { + all_different = true; + } + } + } + assert!(all_different); + + // But all should decapsulate correctly + for (ct, ss) in ciphertexts.iter().zip(secrets.iter()) { + let decapsulated = decapsulate(ct, &keys.secret).unwrap(); + assert_eq!(*ss, decapsulated); + } + } + + #[test] + fn test_deterministic_decapsulation() { + let keys = keypair(&mut thread_rng()).unwrap(); + let (ct, _) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + + let ss1 = decapsulate(&ct, &keys.secret).unwrap(); + let ss2 = decapsulate(&ct, &keys.secret).unwrap(); + let ss3 = decapsulate(&ct, &keys.secret).unwrap(); + + assert_eq!(ss1, ss2); + assert_eq!(ss2, ss3); + } + + #[test] + fn test_all_zero_keypair() { + let mut rng = thread_rng(); + let keys = keypair(&mut rng).unwrap(); + + // Keys should not be all zeros + assert!(keys.public.iter().any(|&x| x != 0)); + assert!(keys.secret.iter().any(|&x| x != 0)); + } + + #[test] + fn test_shared_secret_all_zeros() { + let keys = keypair(&mut thread_rng()).unwrap(); + let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + + // Shared secret should not be all zeros + assert!(ss.iter().any(|&x| x != 0)); + + // Decapsulated should also not be all zeros + let ss2 = decapsulate(&ct, &keys.secret).unwrap(); + assert!(ss2.iter().any(|&x| x != 0)); + } + + #[test] + fn test_boundary_public_key_length() { + // Test with public key that's 1 byte too short + let keys = keypair(&mut thread_rng()).unwrap(); + let mut short_pk = keys.public.to_vec(); + short_pk.pop(); + + let result = encapsulate(&short_pk, &mut thread_rng()); + assert!(result.is_err()); + } + + #[test] + fn test_boundary_secret_key_length() { + let keys = keypair(&mut thread_rng()).unwrap(); + let (ct, _) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + + let mut short_sk = keys.secret.to_vec(); + short_sk.pop(); + + let result = decapsulate(&ct, &short_sk); + assert!(result.is_err()); + } + + #[test] + fn test_boundary_ciphertext_length() { + let keys = keypair(&mut thread_rng()).unwrap(); + let short_ct = vec![0u8; KYBER_CIPHERTEXTBYTES - 1]; + + let result = decapsulate(&short_ct, &keys.secret); + assert!(result.is_err()); + } } #[pymodule] From 23e87c26a55dddd5f8c142bff43fdd78030e7434 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Fri, 20 Feb 2026 22:06:06 +0200 Subject: [PATCH 06/47] More verbose funcion and var names --- src/kyber/fips202.rs | 150 +++++++++++++++++++++-------------------- src/kyber/indcpa.rs | 14 ++-- src/kyber/kem.rs | 20 +++--- src/kyber/ntt.rs | 83 +++++++++++++---------- src/kyber/poly.rs | 18 ++--- src/kyber/polyvec.rs | 4 +- src/kyber/symmetric.rs | 44 ++++++++---- 7 files changed, 185 insertions(+), 148 deletions(-) diff --git a/src/kyber/fips202.rs b/src/kyber/fips202.rs index 5e09418..9bde2a5 100644 --- a/src/kyber/fips202.rs +++ b/src/kyber/fips202.rs @@ -26,22 +26,26 @@ impl KeccakState { } } -fn rol(a: u64, offset: u64) -> u64 { - (a << offset) ^ (a >> (64 - offset)) +/// Rotate left operation for 64-bit values. +/// Rotates `value` left by `offset` bits. +fn rotate_left(value: u64, offset: u64) -> u64 { + (value << offset) | (value >> (64 - offset)) } -pub fn load64(x: &[u8]) -> u64 { - let mut r = 0u64; +/// Load 8 bytes from little-endian byte array into a 64-bit unsigned integer. +pub fn load_u64(bytes: &[u8]) -> u64 { + let mut result = 0u64; for i in 0..8 { - r |= (x[i] as u64) << (8 * i); + result |= (bytes[i] as u64) << (8 * i); } - r + result } -pub fn store64(x: &mut [u8], mut u: u64) { - for i in x.iter_mut().take(8) { - *i = u as u8; - u >>= 8; +/// Store a 64-bit unsigned integer into little-endian byte array. +pub fn store_u64(bytes: &mut [u8], mut value: u64) { + for byte in bytes.iter_mut().take(8) { + *byte = value as u8; + value >>= 8; } } @@ -106,22 +110,22 @@ pub fn keccakf1600_statepermute(state: &mut [u64]) { let mut bco = abo ^ ago ^ ako ^ amo ^ aso; let mut bcu = abu ^ agu ^ aku ^ amu ^ asu; - let mut da = bcu ^ rol(bce, 1); - let mut de = bca ^ rol(bci, 1); - let mut di = bce ^ rol(bco, 1); - let mut d_o = bci ^ rol(bcu, 1); - let mut du = bco ^ rol(bca, 1); + let mut da = bcu ^ rotate_left(bce, 1); + let mut de = bca ^ rotate_left(bci, 1); + let mut di = bce ^ rotate_left(bco, 1); + let mut d_o = bci ^ rotate_left(bcu, 1); + let mut du = bco ^ rotate_left(bca, 1); aba ^= da; bca = aba; age ^= de; - bce = rol(age, 44); + bce = rotate_left(age, 44); aki ^= di; - bci = rol(aki, 43); + bci = rotate_left(aki, 43); amo ^= d_o; - bco = rol(amo, 21); + bco = rotate_left(amo, 21); asu ^= du; - bcu = rol(asu, 14); + bcu = rotate_left(asu, 14); let mut eba = bca ^ ((!bce) & bci); eba ^= KECCAKF_ROUNDCONSTANTS[round]; let mut ebe = bce ^ ((!bci) & bco); @@ -130,15 +134,15 @@ pub fn keccakf1600_statepermute(state: &mut [u64]) { let mut ebu = bcu ^ ((!bca) & bce); abo ^= d_o; - bca = rol(abo, 28); + bca = rotate_left(abo, 28); agu ^= du; - bce = rol(agu, 20); + bce = rotate_left(agu, 20); aka ^= da; - bci = rol(aka, 3); + bci = rotate_left(aka, 3); ame ^= de; - bco = rol(ame, 45); + bco = rotate_left(ame, 45); asi ^= di; - bcu = rol(asi, 61); + bcu = rotate_left(asi, 61); let mut ega = bca ^ ((!bce) & bci); let mut ege = bce ^ ((!bci) & bco); let mut egi = bci ^ ((!bco) & bcu); @@ -146,15 +150,15 @@ pub fn keccakf1600_statepermute(state: &mut [u64]) { let mut egu = bcu ^ ((!bca) & bce); abe ^= de; - bca = rol(abe, 1); + bca = rotate_left(abe, 1); agi ^= di; - bce = rol(agi, 6); + bce = rotate_left(agi, 6); ako ^= d_o; - bci = rol(ako, 25); + bci = rotate_left(ako, 25); amu ^= du; - bco = rol(amu, 8); + bco = rotate_left(amu, 8); asa ^= da; - bcu = rol(asa, 18); + bcu = rotate_left(asa, 18); let mut eka = bca ^ ((!bce) & bci); let mut eke = bce ^ ((!bci) & bco); let mut eki = bci ^ ((!bco) & bcu); @@ -162,15 +166,15 @@ pub fn keccakf1600_statepermute(state: &mut [u64]) { let mut eku = bcu ^ ((!bca) & bce); abu ^= du; - bca = rol(abu, 27); + bca = rotate_left(abu, 27); aga ^= da; - bce = rol(aga, 36); + bce = rotate_left(aga, 36); ake ^= de; - bci = rol(ake, 10); + bci = rotate_left(ake, 10); ami ^= di; - bco = rol(ami, 15); + bco = rotate_left(ami, 15); aso ^= d_o; - bcu = rol(aso, 56); + bcu = rotate_left(aso, 56); let mut ema = bca ^ ((!bce) & bci); let mut eme = bce ^ ((!bci) & bco); let mut emi = bci ^ ((!bco) & bcu); @@ -178,15 +182,15 @@ pub fn keccakf1600_statepermute(state: &mut [u64]) { let mut emu = bcu ^ ((!bca) & bce); abi ^= di; - bca = rol(abi, 62); + bca = rotate_left(abi, 62); ago ^= d_o; - bce = rol(ago, 55); + bce = rotate_left(ago, 55); aku ^= du; - bci = rol(aku, 39); + bci = rotate_left(aku, 39); ama ^= da; - bco = rol(ama, 41); + bco = rotate_left(ama, 41); ase ^= de; - bcu = rol(ase, 2); + bcu = rotate_left(ase, 2); let mut esa = bca ^ ((!bce) & bci); let mut ese = bce ^ ((!bci) & bco); let mut esi = bci ^ ((!bco) & bcu); @@ -199,22 +203,22 @@ pub fn keccakf1600_statepermute(state: &mut [u64]) { bco = ebo ^ ego ^ eko ^ emo ^ eso; bcu = ebu ^ egu ^ eku ^ emu ^ esu; - da = bcu ^ rol(bce, 1); - de = bca ^ rol(bci, 1); - di = bce ^ rol(bco, 1); - d_o = bci ^ rol(bcu, 1); - du = bco ^ rol(bca, 1); + da = bcu ^ rotate_left(bce, 1); + de = bca ^ rotate_left(bci, 1); + di = bce ^ rotate_left(bco, 1); + d_o = bci ^ rotate_left(bcu, 1); + du = bco ^ rotate_left(bca, 1); eba ^= da; bca = eba; ege ^= de; - bce = rol(ege, 44); + bce = rotate_left(ege, 44); eki ^= di; - bci = rol(eki, 43); + bci = rotate_left(eki, 43); emo ^= d_o; - bco = rol(emo, 21); + bco = rotate_left(emo, 21); esu ^= du; - bcu = rol(esu, 14); + bcu = rotate_left(esu, 14); aba = bca ^ ((!bce) & bci); aba ^= KECCAKF_ROUNDCONSTANTS[round + 1]; abe = bce ^ ((!bci) & bco); @@ -223,15 +227,15 @@ pub fn keccakf1600_statepermute(state: &mut [u64]) { abu = bcu ^ ((!bca) & bce); ebo ^= d_o; - bca = rol(ebo, 28); + bca = rotate_left(ebo, 28); egu ^= du; - bce = rol(egu, 20); + bce = rotate_left(egu, 20); eka ^= da; - bci = rol(eka, 3); + bci = rotate_left(eka, 3); eme ^= de; - bco = rol(eme, 45); + bco = rotate_left(eme, 45); esi ^= di; - bcu = rol(esi, 61); + bcu = rotate_left(esi, 61); aga = bca ^ ((!bce) & bci); age = bce ^ ((!bci) & bco); agi = bci ^ ((!bco) & bcu); @@ -239,15 +243,15 @@ pub fn keccakf1600_statepermute(state: &mut [u64]) { agu = bcu ^ ((!bca) & bce); ebe ^= de; - bca = rol(ebe, 1); + bca = rotate_left(ebe, 1); egi ^= di; - bce = rol(egi, 6); + bce = rotate_left(egi, 6); eko ^= d_o; - bci = rol(eko, 25); + bci = rotate_left(eko, 25); emu ^= du; - bco = rol(emu, 8); + bco = rotate_left(emu, 8); esa ^= da; - bcu = rol(esa, 18); + bcu = rotate_left(esa, 18); aka = bca ^ ((!bce) & bci); ake = bce ^ ((!bci) & bco); aki = bci ^ ((!bco) & bcu); @@ -255,15 +259,15 @@ pub fn keccakf1600_statepermute(state: &mut [u64]) { aku = bcu ^ ((!bca) & bce); ebu ^= du; - bca = rol(ebu, 27); + bca = rotate_left(ebu, 27); ega ^= da; - bce = rol(ega, 36); + bce = rotate_left(ega, 36); eke ^= de; - bci = rol(eke, 10); + bci = rotate_left(eke, 10); emi ^= di; - bco = rol(emi, 15); + bco = rotate_left(emi, 15); eso ^= d_o; - bcu = rol(eso, 56); + bcu = rotate_left(eso, 56); ama = bca ^ ((!bce) & bci); ame = bce ^ ((!bci) & bco); ami = bci ^ ((!bco) & bcu); @@ -271,15 +275,15 @@ pub fn keccakf1600_statepermute(state: &mut [u64]) { amu = bcu ^ ((!bca) & bce); ebi ^= di; - bca = rol(ebi, 62); + bca = rotate_left(ebi, 62); ego ^= d_o; - bce = rol(ego, 55); + bce = rotate_left(ego, 55); eku ^= du; - bci = rol(eku, 39); + bci = rotate_left(eku, 39); ema ^= da; - bco = rol(ema, 41); + bco = rotate_left(ema, 41); ese ^= de; - bcu = rol(ese, 2); + bcu = rotate_left(ese, 2); asa = bca ^ ((!bce) & bci); ase = bce ^ ((!bci) & bco); asi = bci ^ ((!bco) & bcu); @@ -319,7 +323,7 @@ fn keccak_squeezeblocks(h: &mut [u8], mut nblocks: usize, s: &mut [u64], r: usiz while nblocks > 0 { keccakf1600_statepermute(s); for i in 0..r / 8 { - store64(&mut h[idx + 8 * i..], s[i]) + store_u64(&mut h[idx + 8 * i..], s[i]) } idx += r; nblocks -= 1; @@ -346,7 +350,7 @@ pub fn sha3_256(h: &mut [u8], input: &[u8], inlen: usize) { keccak_absorb_once(&mut s, SHA3_256_RATE, input, inlen, 0x06); keccakf1600_statepermute(&mut s); for i in 0..4 { - store64(&mut h[8 * i..], s[i]); + store_u64(&mut h[8 * i..], s[i]); } } @@ -355,7 +359,7 @@ pub fn sha3_512(h: &mut [u8], input: &[u8], inlen: usize) { keccak_absorb_once(&mut s, SHA3_512_RATE, input, inlen, 0x06); keccakf1600_statepermute(&mut s); for i in 0..8 { - store64(&mut h[8 * i..], s[i]); + store_u64(&mut h[8 * i..], s[i]); } } @@ -370,7 +374,7 @@ pub fn keccak_absorb_once(s: &mut [u64], r: usize, input: &[u8], mut inlen: usiz let mut idx = 0usize; while inlen >= r { for i in 0..(r / 8) { - s[i] ^= load64(&input[idx + 8 * i..]); + s[i] ^= load_u64(&input[idx + 8 * i..]); } idx += r; inlen -= r; @@ -400,7 +404,7 @@ fn keccak_squeeze( let mut i = pos; let mut w = i / 8; while i < r && i < pos + outlen { - store64(&mut out[idx..], s[w]); + store_u64(&mut out[idx..], s[w]); i += 8; w += 1; idx += 8; diff --git a/src/kyber/indcpa.rs b/src/kyber/indcpa.rs index 9cc6f9e..490ee39 100644 --- a/src/kyber/indcpa.rs +++ b/src/kyber/indcpa.rs @@ -2,7 +2,9 @@ use super::error::KyberError; use super::params::*; use super::poly::*; use super::polyvec::*; -use super::symmetric::{hash_g, xof_absorb, xof_squeezeblocks, XofState, XOF_BLOCKBYTES}; +use super::symmetric::{ + hash_sha3_512, xof_absorb_bytes, xof_squeeze_blocks, XofState, XOF_BLOCKBYTES, +}; use rand_core::{CryptoRng, RngCore}; fn pack_pk(r: &mut [u8], pk: &mut Polyvec, seed: &[u8]) { @@ -76,11 +78,11 @@ fn gen_matrix(a: &mut [Polyvec], seed: &[u8], transposed: bool) { for i in 0..KYBER_K { for j in 0..KYBER_K { if transposed { - xof_absorb(&mut state, seed, i as u8, j as u8); + xof_absorb_bytes(&mut state, seed, i as u8, j as u8); } else { - xof_absorb(&mut state, seed, j as u8, i as u8); + xof_absorb_bytes(&mut state, seed, j as u8, i as u8); } - xof_squeezeblocks(&mut buf, GEN_MATRIX_NBLOCKS, &mut state); + xof_squeeze_blocks(&mut buf, GEN_MATRIX_NBLOCKS, &mut state); buflen = GEN_MATRIX_NBLOCKS * XOF_BLOCKBYTES; ctr = rej_uniform(&mut a[i].vec[j].coeffs, KYBER_N, &buf, buflen); @@ -89,7 +91,7 @@ fn gen_matrix(a: &mut [Polyvec], seed: &[u8], transposed: bool) { for k in 0..off { buf[k] = buf[buflen - off + k]; } - xof_squeezeblocks(&mut buf[off..], 1, &mut state); + xof_squeeze_blocks(&mut buf[off..], 1, &mut state); buflen = off + XOF_BLOCKBYTES; ctr += rej_uniform(&mut a[i].vec[j].coeffs[ctr..], KYBER_N - ctr, &buf, buflen); } @@ -118,7 +120,7 @@ where _rng.fill_bytes(&mut randbuf[..KYBER_SYMBYTES]); } - hash_g(&mut buf, &randbuf, KYBER_SYMBYTES); + hash_sha3_512(&mut buf, &randbuf, KYBER_SYMBYTES); let (publicseed, noiseseed) = buf.split_at(KYBER_SYMBYTES); gen_a(&mut a, publicseed); diff --git a/src/kyber/kem.rs b/src/kyber/kem.rs index 42988a0..a20461c 100644 --- a/src/kyber/kem.rs +++ b/src/kyber/kem.rs @@ -1,7 +1,7 @@ use super::error::KyberError; use super::indcpa::{indcpa_dec, indcpa_enc, indcpa_keypair}; use super::params::*; -use super::symmetric::{hash_g, hash_h, kdf}; +use super::symmetric::{hash_sha3_256, hash_sha3_512, shake256_kdf}; use super::verify::{cmov, verify}; use rand_core::{CryptoRng, RngCore}; @@ -21,7 +21,7 @@ where indcpa_keypair(pk, sk, _seed, _rng)?; sk[KYBER_INDCPA_SECRETKEYBYTES..END].copy_from_slice(&pk[..KYBER_INDCPA_PUBLICKEYBYTES]); - hash_h(&mut sk[PK_START..], pk, KYBER_PUBLICKEYBYTES); + hash_sha3_256(&mut sk[PK_START..], pk, KYBER_PUBLICKEYBYTES); if let Some(s) = _seed { sk[SK_START..].copy_from_slice(&s.1) @@ -51,14 +51,14 @@ where _rng.fill_bytes(&mut randbuf); } - hash_h(&mut buf, &randbuf, KYBER_SYMBYTES); - hash_h(&mut buf[KYBER_SYMBYTES..], pk, KYBER_PUBLICKEYBYTES); - hash_g(&mut kr, &buf, 2 * KYBER_SYMBYTES); + hash_sha3_256(&mut buf, &randbuf, KYBER_SYMBYTES); + hash_sha3_256(&mut buf[KYBER_SYMBYTES..], pk, KYBER_PUBLICKEYBYTES); + hash_sha3_512(&mut kr, &buf, 2 * KYBER_SYMBYTES); indcpa_enc(ct, &buf, pk, &kr[KYBER_SYMBYTES..]); - hash_h(&mut kr[KYBER_SYMBYTES..], ct, KYBER_CIPHERTEXTBYTES); - kdf(ss, &kr, 2 * KYBER_SYMBYTES); + hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_CIPHERTEXTBYTES); + shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); Ok(()) } @@ -75,11 +75,11 @@ pub fn crypto_kem_dec(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> () { const START: usize = KYBER_SECRETKEYBYTES - 2 * KYBER_SYMBYTES; const END: usize = KYBER_SECRETKEYBYTES - KYBER_SYMBYTES; buf[KYBER_SYMBYTES..].copy_from_slice(&sk[START..END]); - hash_g(&mut kr, &buf, 2 * KYBER_SYMBYTES); + hash_sha3_512(&mut kr, &buf, 2 * KYBER_SYMBYTES); indcpa_enc(&mut cmp, &buf, &pk, &kr[KYBER_SYMBYTES..]); let fail = verify(ct, &cmp, KYBER_CIPHERTEXTBYTES); - hash_h(&mut kr[KYBER_SYMBYTES..], ct, KYBER_CIPHERTEXTBYTES); + hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_CIPHERTEXTBYTES); cmov(&mut kr, &sk[END..], KYBER_SYMBYTES, fail); - kdf(ss, &kr, 2 * KYBER_SYMBYTES); + shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); } diff --git a/src/kyber/ntt.rs b/src/kyber/ntt.rs index da3feae..9eb4756 100644 --- a/src/kyber/ntt.rs +++ b/src/kyber/ntt.rs @@ -1,5 +1,7 @@ use super::reduce::*; +/// Twiddle factors (primitive roots of unity) used in the Number Theoretic Transform. +/// These are Montgomery-friendly constants precomputed for the Kyber polynomial ring. pub const ZETAS: [i16; 128] = [ -1044, -758, -359, -1517, 1493, 1422, 287, 202, -171, 622, 1577, 182, 962, -1202, -1474, 1468, 573, -1325, 264, 383, -829, 1458, -1602, -130, -681, 1017, 732, 608, -1542, 411, -205, -1571, @@ -11,67 +13,78 @@ pub const ZETAS: [i16; 128] = [ -1530, -1278, 794, -1510, -854, -870, 478, -108, -308, 996, 991, 958, -1460, 1522, 1628, ]; -pub fn fqmul(a: i16, b: i16) -> i16 { +/// Field multiplication in the Kyber polynomial ring (q = 3329). +/// Uses Montgomery multiplication to compute a * b mod q. +pub fn field_multiply(a: i16, b: i16) -> i16 { montgomery_reduce(a as i32 * b as i32) } -pub fn ntt(r: &mut [i16]) { +/// Forward Number Theoretic Transform (NTT) on a polynomial. +/// Transforms coefficients from standard to NTT domain using iterative Cooley-Tukey algorithm. +/// Input is in-place on the coefficient array. +pub fn ntt_forward(coeffs: &mut [i16]) { let mut j; - let mut k = 1usize; - let mut len = 128; - let (mut t, mut zeta); + let mut zeta_index = 1usize; + let mut layer_length = 128; + let (mut temp, mut zeta); - while len >= 2 { + while layer_length >= 2 { let mut start = 0; while start < 256 { - zeta = ZETAS[k]; - k += 1; + zeta = ZETAS[zeta_index]; + zeta_index += 1; j = start; - while j < (start + len) { - t = fqmul(zeta, r[j + len]); - r[j + len] = r[j] - t; - r[j] += t; + while j < (start + layer_length) { + temp = field_multiply(zeta, coeffs[j + layer_length]); + coeffs[j + layer_length] = coeffs[j] - temp; + coeffs[j] += temp; j += 1; } - start = j + len; + start = j + layer_length; } - len >>= 1; + layer_length >>= 1; } } -pub fn invntt(r: &mut [i16]) { +/// Inverse Number Theuristic Transform (INTT) on a polynomial. +/// Transforms coefficients from NTT domain back to standard representation. +/// Uses inverse butterflies withBarrett reduction and final scaling factor. +pub fn ntt_inverse(coeffs: &mut [i16]) { let mut j; - let mut k = 127usize; - let mut len = 2; - let (mut t, mut zeta); + let mut zeta_index = 127usize; + let mut layer_length = 2; + let (mut temp, mut zeta); const F: i16 = 1441; - while len <= 128 { + while layer_length <= 128 { let mut start = 0; while start < 256 { - zeta = ZETAS[k]; - k -= 1; + zeta = ZETAS[zeta_index]; + zeta_index -= 1; j = start; - while j < (start + len) { - t = r[j]; - r[j] = barrett_reduce(t + r[j + len]); - r[j + len] = r[j + len] - t; - r[j + len] = fqmul(zeta, r[j + len]); + while j < (start + layer_length) { + temp = coeffs[j]; + coeffs[j] = barrett_reduce(temp + coeffs[j + layer_length]); + coeffs[j + layer_length] = coeffs[j + layer_length] - temp; + coeffs[j + layer_length] = field_multiply(zeta, coeffs[j + layer_length]); j += 1 } - start = j + len; + start = j + layer_length; } - len <<= 1; + layer_length <<= 1; } for j in 0..256 { - r[j] = fqmul(r[j], F); + coeffs[j] = field_multiply(coeffs[j], F); } } -pub fn basemul(r: &mut [i16], a: &[i16], b: &[i16], zeta: i16) { - r[0] = fqmul(a[1], b[1]); - r[0] = fqmul(r[0], zeta); - r[0] += fqmul(a[0], b[0]); +/// Base multiplication for two polynomials in the NTT domain. +/// Computes point-wise multiplication of polynomials a and b, +/// using the provided twiddle factor zeta for the butterfly operation. +pub fn base_multiply(result: &mut [i16], a: &[i16], b: &[i16], zeta: i16) { + result[0] = field_multiply(a[1], b[1]); + result[0] = field_multiply(result[0], zeta); + result[0] += field_multiply(a[0], b[0]); - r[1] = fqmul(a[0], b[1]); - r[1] += fqmul(a[1], b[0]); + result[1] = field_multiply(a[0], b[1]); + result[1] += field_multiply(a[1], b[0]); } diff --git a/src/kyber/poly.rs b/src/kyber/poly.rs index 47348c4..72b1099 100644 --- a/src/kyber/poly.rs +++ b/src/kyber/poly.rs @@ -1,9 +1,9 @@ use super::cbd::poly_cbd_eta1; use super::cbd::poly_cbd_eta2; -use super::ntt::{basemul, invntt, ntt, ZETAS}; +use super::ntt::{base_multiply, ntt_forward, ntt_inverse, ZETAS}; use super::params::*; use super::reduce::{barrett_reduce, montgomery_reduce}; -use super::symmetric::prf; +use super::symmetric::shake256_prf_expand; #[derive(Clone, Copy)] pub struct Poly { @@ -78,35 +78,35 @@ pub fn poly_frombytes(r: &mut Poly, a: &[u8]) { pub fn poly_getnoise_eta1(r: &mut Poly, seed: &[u8], nonce: u8) { const LENGTH: usize = KYBER_ETA1 * KYBER_N / 4; let mut buf = [0u8; LENGTH]; - prf(&mut buf, LENGTH, seed, nonce); + shake256_prf_expand(&mut buf, LENGTH, seed, nonce); poly_cbd_eta1(r, &buf); } pub fn poly_getnoise_eta2(r: &mut Poly, seed: &[u8], nonce: u8) { const LENGTH: usize = KYBER_ETA2 * KYBER_N / 4; let mut buf = [0u8; LENGTH]; - prf(&mut buf, LENGTH, seed, nonce); + shake256_prf_expand(&mut buf, LENGTH, seed, nonce); poly_cbd_eta2(r, &buf); } pub fn poly_ntt(r: &mut Poly) { - ntt(&mut r.coeffs); + ntt_forward(&mut r.coeffs); poly_reduce(r); } pub fn poly_invntt_tomont(r: &mut Poly) { - invntt(&mut r.coeffs); + ntt_inverse(&mut r.coeffs); } -pub fn poly_basemul(r: &mut Poly, a: &Poly, b: &Poly) { +pub fn poly_base_multiply(r: &mut Poly, a: &Poly, b: &Poly) { for i in 0..(KYBER_N / 4) { - basemul( + base_multiply( &mut r.coeffs[4 * i..], &a.coeffs[4 * i..], &b.coeffs[4 * i..], ZETAS[64 + i], ); - basemul( + base_multiply( &mut r.coeffs[4 * i + 2..], &a.coeffs[4 * i + 2..], &b.coeffs[4 * i + 2..], diff --git a/src/kyber/polyvec.rs b/src/kyber/polyvec.rs index b0c6e8b..00b1e9d 100644 --- a/src/kyber/polyvec.rs +++ b/src/kyber/polyvec.rs @@ -81,9 +81,9 @@ pub fn polyvec_invntt_tomont(r: &mut Polyvec) { pub fn polyvec_basemul_acc_montgomery(r: &mut Poly, a: &Polyvec, b: &Polyvec) { let mut t = Poly::new(); - poly_basemul(r, &a.vec[0], &b.vec[0]); + poly_base_multiply(r, &a.vec[0], &b.vec[0]); for i in 1..KYBER_K { - poly_basemul(&mut t, &a.vec[i], &b.vec[i]); + poly_base_multiply(&mut t, &a.vec[i], &b.vec[i]); poly_add(r, &t); } poly_reduce(r); diff --git a/src/kyber/symmetric.rs b/src/kyber/symmetric.rs index 5b3796e..9c5fde7 100644 --- a/src/kyber/symmetric.rs +++ b/src/kyber/symmetric.rs @@ -10,42 +10,60 @@ pub const XOF_BLOCKBYTES: usize = SHAKE128_RATE; pub type XofState = KeccakState; -pub fn hash_h(out: &mut [u8], input: &[u8], inlen: usize) { +/// SHA3-256 hash function (H) used in Kyber for hashing messages +/// and other cryptographic operations requiring a 256-bit hash. +pub fn hash_sha3_256(out: &mut [u8], input: &[u8], inlen: usize) { sha3_256(out, input, inlen); } -pub fn hash_g(out: &mut [u8], input: &[u8], inlen: usize) { +/// SHA3-512 hash function (G) used in Kyber for generating +/// pseudorandom bytes from a seed. +pub fn hash_sha3_512(out: &mut [u8], input: &[u8], inlen: usize) { sha3_512(out, input, inlen); } -pub fn xof_absorb(state: &mut XofState, input: &[u8], x: u8, y: u8) { - kyber_shake128_absorb(state, input, x, y); +/// XOF (Extendable Output Function) absorb operation for SHAKE128. +/// Absorbs input bytes into the XOF state with coordinate parameters. +pub fn xof_absorb_bytes(state: &mut XofState, input: &[u8], x_coord: u8, y_coord: u8) { + kyber_shake128_absorb(state, input, x_coord, y_coord); } -pub fn xof_squeezeblocks(out: &mut [u8], outblocks: usize, state: &mut XofState) { +/// XOF squeeze operation that outputs blocks of SHAKE128. +pub fn xof_squeeze_blocks(out: &mut [u8], outblocks: usize, state: &mut XofState) { kyber_shake128_squeezeblocks(out, outblocks, state); } -pub fn prf(out: &mut [u8], outbytes: usize, key: &[u8], nonce: u8) { +/// PRF (Pseudorandom Function) using SHAKE256 for expanding a key +/// and nonce into arbitrary-length output. +/// Used in Kyber for generating random bytes from a seed and nonce. +pub fn shake256_prf_expand(out: &mut [u8], outbytes: usize, key: &[u8], nonce: u8) { shake256_prf(out, outbytes, key, nonce); } -pub fn kdf(out: &mut [u8], input: &[u8], inlen: usize) { +/// KDF (Key Derivation Function) using SHAKE256 to derive +/// a 32-byte output from input bytes. +/// Used in Kyber for key expansion. +pub fn shake256_kdf(out: &mut [u8], input: &[u8], inlen: usize) { shake256(out, 32, input, inlen); } -fn kyber_shake128_absorb(s: &mut KeccakState, input: &[u8], x: u8, y: u8) { +/// Internal: Absorbs input into SHAKE128 XOF with extended seed (coordinates). +/// Combines the input seed with x and y coordinates for domain separation. +fn kyber_shake128_absorb(state: &mut KeccakState, input: &[u8], x_coord: u8, y_coord: u8) { let mut extseed = [0u8; 34]; extseed[..32].copy_from_slice(input); - extseed[32] = x; - extseed[33] = y; - shake128_absorb_once(s, &extseed, 34); + extseed[32] = x_coord; + extseed[33] = y_coord; + shake128_absorb_once(state, &extseed, 34); } -fn kyber_shake128_squeezeblocks(output: &mut [u8], nblocks: usize, s: &mut KeccakState) { - super::fips202::shake128_squeezeblocks(output, nblocks, s); +/// Internal: Squeezes output blocks from SHAKE128 XOF state. +fn kyber_shake128_squeezeblocks(output: &mut [u8], nblocks: usize, state: &mut KeccakState) { + super::fips202::shake128_squeezeblocks(output, nblocks, state); } +/// Internal: SHA implementation that extends a key and nonce +/// into arbitrary-length output using SHAKE256. fn shake256_prf(output: &mut [u8], outlen: usize, key: &[u8], nonce: u8) { let mut extkey = [0u8; 33]; extkey[..32].copy_from_slice(key); From c1b5a2334b86860413e331c464af57771ceb13aa Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Fri, 20 Feb 2026 22:41:15 +0200 Subject: [PATCH 07/47] changed public api --- python/pykyber/__init__.py | 97 +++---------- python/pykyber/kyber.py | 229 +++++++++++++++--------------- python/pykyber/test_kyber.py | 267 ++++++++++++++++++----------------- src/lib.rs | 24 ++-- 4 files changed, 279 insertions(+), 338 deletions(-) diff --git a/python/pykyber/__init__.py b/python/pykyber/__init__.py index 475467b..b154067 100644 --- a/python/pykyber/__init__.py +++ b/python/pykyber/__init__.py @@ -1,89 +1,26 @@ """Kyber post-quantum key encapsulation.""" -from typing import Tuple - -from ._pykyber import ( - generate_keypair as _generate_keypair, - encapsulate as _encapsulate, - decapsulate as _decapsulate, - keypair_512 as _keypair_512, - keypair_768 as _keypair_768, - keypair_1024 as _keypair_1024, - encapsulate_512 as _encapsulate_512, - encapsulate_768 as _encapsulate_768, - encapsulate_1024 as _encapsulate_1024, - decapsulate_512 as _decapsulate_512, - decapsulate_768 as _decapsulate_768, - decapsulate_1024 as _decapsulate_1024, -) - from .kyber import ( Kyber, Kyber768, Kyber512, Kyber1024, - KeyPair, - Kyber768KeyPair, - Kyber512KeyPair, - Kyber1024KeyPair, + PublicKey, + PrivateKey, ) - -def generate_keypair() -> Tuple[bytes, bytes]: - """Generate a Kyber-768 keypair. Returns (public_key, secret_key).""" - return _generate_keypair() - - -def encapsulate(pk: bytes) -> Tuple[bytes, bytes]: - """Encapsulate a shared secret using a public key. Returns (ciphertext, shared_secret).""" - return _encapsulate(pk) - - -def decapsulate(ct: bytes, sk: bytes) -> bytes: - """Decapsulate a shared secret using ciphertext and secret key. Returns shared_secret.""" - return _decapsulate(ct, sk) - - -def keypair_512() -> Tuple[bytes, bytes]: - """Generate a Kyber-512 keypair. Returns (public_key, secret_key).""" - return _keypair_512() - - -def keypair_768() -> Tuple[bytes, bytes]: - """Generate a Kyber-768 keypair. Returns (public_key, secret_key).""" - return _keypair_768() - - -def keypair_1024() -> Tuple[bytes, bytes]: - """Generate a Kyber-1024 keypair. Returns (public_key, secret_key).""" - return _keypair_1024() - - -def encapsulate_512(pk: bytes) -> Tuple[bytes, bytes]: - """Encapsulate using Kyber-512. Returns (ciphertext, shared_secret).""" - return _encapsulate_512(pk) - - -def encapsulate_768(pk: bytes) -> Tuple[bytes, bytes]: - """Encapsulate using Kyber-768. Returns (ciphertext, shared_secret).""" - return _encapsulate_768(pk) - - -def encapsulate_1024(pk: bytes) -> Tuple[bytes, bytes]: - """Encapsulate using Kyber-1024. Returns (ciphertext, shared_secret).""" - return _encapsulate_1024(pk) - - -def decapsulate_512(ct: bytes, sk: bytes) -> bytes: - """Decapsulate using Kyber-512. Returns shared_secret.""" - return _decapsulate_512(ct, sk) - - -def decapsulate_768(ct: bytes, sk: bytes) -> bytes: - """Decapsulate using Kyber-768. Returns shared_secret.""" - return _decapsulate_768(ct, sk) - - -def decapsulate_1024(ct: bytes, sk: bytes) -> bytes: - """Decapsulate using Kyber-1024. Returns shared_secret.""" - return _decapsulate_1024(ct, sk) +# Import underscored functions from Rust +from ._pykyber import ( + _generate_keypair, + _encapsulate, + _decapsulate, + _keypair_512, + _keypair_768, + _keypair_1024, + _encapsulate_512, + _encapsulate_768, + _encapsulate_1024, + _decapsulate_512, + _decapsulate_768, + _decapsulate_1024, +) diff --git a/python/pykyber/kyber.py b/python/pykyber/kyber.py index 33e01f6..0326ac3 100644 --- a/python/pykyber/kyber.py +++ b/python/pykyber/kyber.py @@ -1,171 +1,166 @@ """Kyber post-quantum key encapsulation.""" import pykyber -from typing import Tuple +from abc import ABC, abstractmethod +from typing import Tuple, Callable -class Kyber512: - """Kyber-512 key encapsulation (security ~AES-128).""" +class Kyber(ABC): + """Abstract base class for Kyber key encapsulation.""" - PUBLIC_KEY_SIZE = 800 - SECRET_KEY_SIZE = 1632 - CIPHERTEXT_SIZE = 768 - SHARED_SECRET_SIZE = 32 + PUBLIC_KEY_SIZE: int + SECRET_KEY_SIZE: int + CIPHERTEXT_SIZE: int + SHARED_SECRET_SIZE: int + + @classmethod + @abstractmethod + def _keypair_fn(cls) -> Tuple[bytes, bytes]: + """Return the keypair generation function.""" + pass + + @classmethod + @abstractmethod + def _encapsulate_fn(cls) -> Callable[[bytes], Tuple[bytes, bytes]]: + """Return the encapsulate function.""" + pass + + @classmethod + @abstractmethod + def _decapsulate_fn(cls) -> Callable[[bytes, bytes], bytes]: + """Return the decapsulate function.""" + pass @classmethod - def generate_keypair(cls) -> Tuple[bytes, bytes]: - """Generate a public/secret key pair.""" - return pykyber.keypair_512() + def generate_keypair(cls) -> 'PrivateKey': + """Generate a key pair. Returns PrivateKey (which has .public_key property).""" + pk, sk = cls._keypair_fn() + return PrivateKey(sk, pk, cls._encapsulate_fn(), cls._decapsulate_fn()) @staticmethod def encapsulate(pk: bytes) -> Tuple[bytes, bytes]: """Encapsulate a shared secret using a public key.""" - return pykyber.encapsulate_512(pk) + raise NotImplementedError("Use variant-specific class") @staticmethod def decapsulate(ct: bytes, sk: bytes) -> bytes: """Decapsulate a shared secret using ciphertext and secret key.""" - return pykyber.decapsulate_512(ct, sk) + raise NotImplementedError("Use variant-specific class") -class Kyber768: - """Kyber-768 key encapsulation (security ~AES-192).""" +class PublicKey: + """Public key with encapsulate method.""" - PUBLIC_KEY_SIZE = 1184 - SECRET_KEY_SIZE = 2400 - CIPHERTEXT_SIZE = 1088 - SHARED_SECRET_SIZE = 32 + def __init__(self, public_key_bytes: bytes, + encapsulate_fn: Callable[[bytes], Tuple[bytes, bytes]], + decapsulate_fn: Callable[[bytes, bytes], bytes]): + self._public_key = public_key_bytes + self._encapsulate_fn = encapsulate_fn + self._decapsulate_fn = decapsulate_fn - @classmethod - def generate_keypair(cls) -> Tuple[bytes, bytes]: - """Generate a public/secret key pair.""" - return pykyber.keypair_768() + def encapsulate(self) -> Tuple[bytes, bytes]: + """Encapsulate a shared secret using the public key.""" + return self._encapsulate_fn(self._public_key) - @staticmethod - def encapsulate(pk: bytes) -> Tuple[bytes, bytes]: - """Encapsulate a shared secret using a public key.""" - return pykyber.encapsulate_768(pk) + @property + def public_key(self) -> bytes: + """Return the raw public key bytes.""" + return self._public_key - @staticmethod - def decapsulate(ct: bytes, sk: bytes) -> bytes: - """Decapsulate a shared secret using ciphertext and secret key.""" - return pykyber.decapsulate_768(ct, sk) + def __repr__(self) -> str: + return f"PublicKey({len(self._public_key)} bytes)" -class Kyber1024: - """Kyber-1024 key encapsulation (security ~AES-256).""" +class PrivateKey: + """Private key with decapsulate method.""" + + def __init__(self, secret_key_bytes: bytes, public_key_bytes: bytes, + encapsulate_fn: Callable[[bytes], Tuple[bytes, bytes]], + decapsulate_fn: Callable[[bytes, bytes], bytes]): + self._secret_key = secret_key_bytes + self._public_key = public_key_bytes + self._encapsulate_fn = encapsulate_fn + self._decapsulate_fn = decapsulate_fn + + @property + def public_key(self) -> PublicKey: + """Return the corresponding public key (for encapsulation).""" + return PublicKey(self._public_key, self._encapsulate_fn, self._decapsulate_fn) - PUBLIC_KEY_SIZE = 1568 - SECRET_KEY_SIZE = 3168 - CIPHERTEXT_SIZE = 1568 - SHARED_SECRET_SIZE = 32 + def decapsulate(self, ciphertext: bytes) -> bytes: + """Decapsulate a shared secret using ciphertext.""" + return self._decapsulate_fn(ciphertext, self._secret_key) - @classmethod - def generate_keypair(cls) -> Tuple[bytes, bytes]: - """Generate a public/secret key pair.""" - return pykyber.keypair_1024() + @property + def secret_key(self) -> bytes: + """Return the raw secret key bytes.""" + return self._secret_key - @staticmethod - def encapsulate(pk: bytes) -> Tuple[bytes, bytes]: - """Encapsulate a shared secret using a public key.""" - return pykyber.encapsulate_1024(pk) - - @staticmethod - def decapsulate(ct: bytes, sk: bytes) -> bytes: - """Decapsulate a shared secret using ciphertext and secret key.""" - return pykyber.decapsulate_1024(ct, sk) + def __repr__(self) -> str: + return f"PrivateKey({len(self._secret_key)} bytes)" -class Kyber768KeyPair: - """Kyber-768 key pair with encapsulation methods.""" +class Kyber512(Kyber): + """Kyber-512 key encapsulation (security ~AES-128).""" - def __init__(self, public_key: bytes, secret_key: bytes): - self.public_key = public_key - self.secret_key = secret_key + PUBLIC_KEY_SIZE = 800 + SECRET_KEY_SIZE = 1632 + CIPHERTEXT_SIZE = 768 + SHARED_SECRET_SIZE = 32 @classmethod - def generate(cls) -> 'Kyber768KeyPair': - """Generate a new key pair.""" - public_key, secret_key = pykyber.generate_keypair() - return cls(public_key, secret_key) + def _keypair_fn(cls) -> Tuple[bytes, bytes]: + return pykyber._keypair_512() @classmethod - def from_bytes(cls, public_key: bytes, secret_key: bytes) -> 'Kyber768KeyPair': - """Create a key pair from existing keys.""" - return cls(public_key, secret_key) - - def encapsulate(self) -> Tuple[bytes, bytes]: - """Encapsulate a shared secret using the public key.""" - return pykyber.encapsulate(self.public_key) + def _encapsulate_fn(cls) -> Callable[[bytes], Tuple[bytes, bytes]]: + return pykyber._encapsulate_512 - def decapsulate(self, ciphertext: bytes) -> bytes: - """Decapsulate a shared secret using the secret key.""" - return pykyber.decapsulate(ciphertext, self.secret_key) - - def __repr__(self) -> str: - return f"Kyber768KeyPair(public_key={len(self.public_key)} bytes, secret_key={len(self.secret_key)} bytes)" + @classmethod + def _decapsulate_fn(cls) -> Callable[[bytes, bytes], bytes]: + return pykyber._decapsulate_512 -class Kyber512KeyPair: - """Kyber-512 key pair with encapsulation methods.""" +class Kyber768(Kyber): + """Kyber-768 key encapsulation (security ~AES-192).""" - def __init__(self, public_key: bytes, secret_key: bytes): - self.public_key = public_key - self.secret_key = secret_key + PUBLIC_KEY_SIZE = 1184 + SECRET_KEY_SIZE = 2400 + CIPHERTEXT_SIZE = 1088 + SHARED_SECRET_SIZE = 32 @classmethod - def generate(cls) -> 'Kyber512KeyPair': - """Generate a new key pair.""" - public_key, secret_key = pykyber.keypair_512() - return cls(public_key, secret_key) + def _keypair_fn(cls) -> Tuple[bytes, bytes]: + return pykyber._keypair_768() @classmethod - def from_bytes(cls, public_key: bytes, secret_key: bytes) -> 'Kyber512KeyPair': - """Create a key pair from existing keys.""" - return cls(public_key, secret_key) + def _encapsulate_fn(cls) -> Callable[[bytes], Tuple[bytes, bytes]]: + return pykyber._encapsulate_768 - def encapsulate(self) -> Tuple[bytes, bytes]: - """Encapsulate a shared secret using the public key.""" - return pykyber.encapsulate_512(self.public_key) - - def decapsulate(self, ciphertext: bytes) -> bytes: - """Decapsulate a shared secret using the secret key.""" - return pykyber.decapsulate_512(ciphertext, self.secret_key) - - def __repr__(self) -> str: - return f"Kyber512KeyPair(public_key={len(self.public_key)} bytes, secret_key={len(self.secret_key)} bytes)" + @classmethod + def _decapsulate_fn(cls) -> Callable[[bytes, bytes], bytes]: + return pykyber._decapsulate_768 -class Kyber1024KeyPair: - """Kyber-1024 key pair with encapsulation methods.""" +class Kyber1024(Kyber): + """Kyber-1024 key encapsulation (security ~AES-256).""" - def __init__(self, public_key: bytes, secret_key: bytes): - self.public_key = public_key - self.secret_key = secret_key + PUBLIC_KEY_SIZE = 1568 + SECRET_KEY_SIZE = 3168 + CIPHERTEXT_SIZE = 1568 + SHARED_SECRET_SIZE = 32 @classmethod - def generate(cls) -> 'Kyber1024KeyPair': - """Generate a new key pair.""" - public_key, secret_key = pykyber.keypair_1024() - return cls(public_key, secret_key) + def _keypair_fn(cls) -> Tuple[bytes, bytes]: + return pykyber._keypair_1024() @classmethod - def from_bytes(cls, public_key: bytes, secret_key: bytes) -> 'Kyber1024KeyPair': - """Create a key pair from existing keys.""" - return cls(public_key, secret_key) - - def encapsulate(self) -> Tuple[bytes, bytes]: - """Encapsulate a shared secret using the public key.""" - return pykyber.encapsulate_1024(self.public_key) + def _encapsulate_fn(cls) -> Callable[[bytes], Tuple[bytes, bytes]]: + return pykyber._encapsulate_1024 - def decapsulate(self, ciphertext: bytes) -> bytes: - """Decapsulate a shared secret using the secret key.""" - return pykyber.decapsulate_1024(ciphertext, self.secret_key) - - def __repr__(self) -> str: - return f"Kyber1024KeyPair(public_key={len(self.public_key)} bytes, secret_key={len(self.secret_key)} bytes)" + @classmethod + def _decapsulate_fn(cls) -> Callable[[bytes, bytes], bytes]: + return pykyber._decapsulate_1024 -# Default aliases Kyber = Kyber768 -KeyPair = Kyber768KeyPair diff --git a/python/pykyber/test_kyber.py b/python/pykyber/test_kyber.py index 4153a67..4bccb6e 100644 --- a/python/pykyber/test_kyber.py +++ b/python/pykyber/test_kyber.py @@ -4,51 +4,51 @@ def test_keypair_generation(): """Test that keypair generation produces valid keys.""" - pk, sk = pykyber.generate_keypair() + pk, sk = pykyber._generate_keypair() assert len(pk) == 1184 assert len(sk) == 2400 def test_encapsulate_decapsulate(): """Test that encapsulate and decapsulate work correctly.""" - pk, sk = pykyber.generate_keypair() - ct, ss = pykyber.encapsulate(pk) + pk, sk = pykyber._generate_keypair() + ct, ss = pykyber._encapsulate(pk) assert len(ct) == 1088 assert len(ss) == 32 - ss2 = pykyber.decapsulate(ct, sk) + ss2 = pykyber._decapsulate(ct, sk) assert ss == ss2 def test_invalid_public_key_length(): """Test that invalid public key length raises an error.""" with pytest.raises(Exception): - pykyber.encapsulate(b"short") + pykyber._encapsulate(b"short") def test_invalid_ciphertext_length(): """Test that invalid ciphertext length raises an error.""" sk = bytes(2400) with pytest.raises(Exception): - pykyber.decapsulate(b"short", sk) + pykyber._decapsulate(b"short", sk) def test_invalid_secret_key_length(): """Test that invalid secret key length raises an error.""" ct = bytes(1088) with pytest.raises(Exception): - pykyber.decapsulate(ct, b"short") + pykyber._decapsulate(ct, b"short") def test_different_keypairs_produce_different_secrets(): """Test that different keypairs produce different shared secrets.""" - pk1, sk1 = pykyber.generate_keypair() - pk2, sk2 = pykyber.generate_keypair() + pk1, sk1 = pykyber._generate_keypair() + pk2, sk2 = pykyber._generate_keypair() - ct1, ss1 = pykyber.encapsulate(pk1) - ct2, ss2 = pykyber.encapsulate(pk2) + ct1, ss1 = pykyber._encapsulate(pk1) + ct2, ss2 = pykyber._encapsulate(pk2) - ss1_dec = pykyber.decapsulate(ct1, sk1) - ss2_dec = pykyber.decapsulate(ct2, sk2) + ss1_dec = pykyber._decapsulate(ct1, sk1) + ss2_dec = pykyber._decapsulate(ct2, sk2) assert ss1 == ss1_dec assert ss2 == ss2_dec @@ -57,123 +57,123 @@ def test_different_keypairs_produce_different_secrets(): def test_wrong_secret_key_fails(): """Test that using wrong secret key produces different result.""" - pk, sk = pykyber.generate_keypair() - _, wrong_sk = pykyber.generate_keypair() + pk, sk = pykyber._generate_keypair() + _, wrong_sk = pykyber._generate_keypair() - ct, ss = pykyber.encapsulate(pk) - ss_wrong = pykyber.decapsulate(ct, wrong_sk) + ct, ss = pykyber._encapsulate(pk) + ss_wrong = pykyber._decapsulate(ct, wrong_sk) assert ss != ss_wrong def test_keypair_512(): """Test keypair generation for Kyber-512.""" - pk, sk = pykyber.keypair_512() + pk, sk = pykyber._keypair_512() assert len(pk) == 1184 assert len(sk) == 2400 def test_keypair_768(): """Test keypair generation for Kyber-768.""" - pk, sk = pykyber.keypair_768() + pk, sk = pykyber._keypair_768() assert len(pk) == 1184 assert len(sk) == 2400 def test_keypair_1024(): """Test keypair generation for Kyber-1024.""" - pk, sk = pykyber.keypair_1024() + pk, sk = pykyber._keypair_1024() assert len(pk) == 1184 assert len(sk) == 2400 def test_deterministic_decapsulation(): """Test that decapsulation is deterministic given the same ciphertext.""" - pk, sk = pykyber.generate_keypair() - ct, _ = pykyber.encapsulate(pk) + pk, sk = pykyber._generate_keypair() + ct, _ = pykyber._encapsulate(pk) - results = [pykyber.decapsulate(ct, sk) for _ in range(5)] + results = [pykyber._decapsulate(ct, sk) for _ in range(5)] assert len(set(results)) == 1 def test_ciphertext_randomness(): """Test that ciphertexts are random.""" - pk, sk = pykyber.generate_keypair() - ciphertexts = [pykyber.encapsulate(pk)[0] for _ in range(5)] + pk, sk = pykyber._generate_keypair() + ciphertexts = [pykyber._encapsulate(pk)[0] for _ in range(5)] assert len(set(ciphertexts)) > 1 def test_empty_public_key(): """Test that empty public key raises error.""" with pytest.raises(Exception): - pykyber.encapsulate(b"") + pykyber._encapsulate(b"") def test_empty_ciphertext(): """Test that empty ciphertext raises error.""" - pk, sk = pykyber.generate_keypair() + pk, sk = pykyber._generate_keypair() with pytest.raises(Exception): - pykyber.decapsulate(b"", sk) + pykyber._decapsulate(b"", sk) def test_empty_secret_key(): """Test that empty secret key raises error.""" - pk, sk = pykyber.generate_keypair() - ct, _ = pykyber.encapsulate(pk) + pk, sk = pykyber._generate_keypair() + ct, _ = pykyber._encapsulate(pk) with pytest.raises(Exception): - pykyber.decapsulate(ct, b"") + pykyber._decapsulate(ct, b"") def test_boundary_public_key_length(): """Test with public key that's 1 byte too short.""" - pk, sk = pykyber.generate_keypair() + pk, sk = pykyber._generate_keypair() short_pk = pk[:-1] with pytest.raises(Exception): - pykyber.encapsulate(short_pk) + pykyber._encapsulate(short_pk) def test_boundary_secret_key_length(): """Test with secret key that's 1 byte too short.""" - pk, sk = pykyber.generate_keypair() - ct, _ = pykyber.encapsulate(pk) + pk, sk = pykyber._generate_keypair() + ct, _ = pykyber._encapsulate(pk) short_sk = sk[:-1] with pytest.raises(Exception): - pykyber.decapsulate(ct, short_sk) + pykyber._decapsulate(ct, short_sk) def test_boundary_ciphertext_length(): """Test with ciphertext that's 1 byte too short.""" - pk, sk = pykyber.generate_keypair() - ct, _ = pykyber.encapsulate(pk) + pk, sk = pykyber._generate_keypair() + ct, _ = pykyber._encapsulate(pk) short_ct = ct[:-1] with pytest.raises(Exception): - pykyber.decapsulate(short_ct, sk) + pykyber._decapsulate(short_ct, sk) def test_all_zero_keypair(): """Test that generated keys are not all zeros.""" - pk, sk = pykyber.generate_keypair() + pk, sk = pykyber._generate_keypair() assert any(b != 0 for b in pk) assert any(b != 0 for b in sk) def test_shared_secret_not_all_zeros(): """Test that shared secrets are not all zeros.""" - pk, sk = pykyber.generate_keypair() - ct, ss = pykyber.encapsulate(pk) + pk, sk = pykyber._generate_keypair() + ct, ss = pykyber._encapsulate(pk) assert any(b != 0 for b in ss) - ss2 = pykyber.decapsulate(ct, sk) + ss2 = pykyber._decapsulate(ct, sk) assert any(b != 0 for b in ss2) def test_multiple_encapsulations(): """Test multiple encapsulations with same keypair.""" - pk, sk = pykyber.generate_keypair() + pk, sk = pykyber._generate_keypair() results = [] for _ in range(10): - ct, ss = pykyber.encapsulate(pk) - ss_dec = pykyber.decapsulate(ct, sk) + ct, ss = pykyber._encapsulate(pk) + ss_dec = pykyber._decapsulate(ct, sk) results.append((ct, ss, ss_dec)) # All should decapsulate correctly @@ -187,96 +187,96 @@ def test_multiple_encapsulations(): def test_keypair_768_function(): """Test that keypair_768 function works.""" - pk, sk = pykyber.keypair_768() - ct, ss = pykyber.encapsulate(pk) - ss2 = pykyber.decapsulate(ct, sk) + pk, sk = pykyber._keypair_768() + ct, ss = pykyber._encapsulate(pk) + ss2 = pykyber._decapsulate(ct, sk) assert ss == ss2 def test_keypair_512_function(): """Test that keypair_512 function works.""" - pk, sk = pykyber.keypair_512() - ct, ss = pykyber.encapsulate(pk) - ss2 = pykyber.decapsulate(ct, sk) + pk, sk = pykyber._keypair_512() + ct, ss = pykyber._encapsulate(pk) + ss2 = pykyber._decapsulate(ct, sk) assert ss == ss2 def test_keypair_1024_function(): """Test that keypair_1024 function works.""" - pk, sk = pykyber.keypair_1024() - ct, ss = pykyber.encapsulate(pk) - ss2 = pykyber.decapsulate(ct, sk) + pk, sk = pykyber._keypair_1024() + ct, ss = pykyber._encapsulate(pk) + ss2 = pykyber._decapsulate(ct, sk) assert ss == ss2 def test_encapsulate_512(): """Test encapsulate_512 function.""" - pk, sk = pykyber.keypair_512() - ct, ss = pykyber.encapsulate_512(pk) - ss2 = pykyber.decapsulate_512(ct, sk) + pk, sk = pykyber._keypair_512() + ct, ss = pykyber._encapsulate_512(pk) + ss2 = pykyber._decapsulate_512(ct, sk) assert ss == ss2 def test_encapsulate_768(): """Test encapsulate_768 function.""" - pk, sk = pykyber.keypair_768() - ct, ss = pykyber.encapsulate_768(pk) - ss2 = pykyber.decapsulate_768(ct, sk) + pk, sk = pykyber._keypair_768() + ct, ss = pykyber._encapsulate_768(pk) + ss2 = pykyber._decapsulate_768(ct, sk) assert ss == ss2 def test_encapsulate_1024(): """Test encapsulate_1024 function.""" - pk, sk = pykyber.keypair_1024() - ct, ss = pykyber.encapsulate_1024(pk) - ss2 = pykyber.decapsulate_1024(ct, sk) + pk, sk = pykyber._keypair_1024() + ct, ss = pykyber._encapsulate_1024(pk) + ss2 = pykyber._decapsulate_1024(ct, sk) assert ss == ss2 def test_decapsulate_512(): """Test decapsulate_512 function.""" - pk, sk = pykyber.keypair_512() - ct, ss = pykyber.encapsulate(pk) - ss2 = pykyber.decapsulate_512(ct, sk) + pk, sk = pykyber._keypair_512() + ct, ss = pykyber._encapsulate(pk) + ss2 = pykyber._decapsulate_512(ct, sk) assert ss == ss2 def test_decapsulate_768(): """Test decapsulate_768 function.""" - pk, sk = pykyber.keypair_768() - ct, ss = pykyber.encapsulate(pk) - ss2 = pykyber.decapsulate_768(ct, sk) + pk, sk = pykyber._keypair_768() + ct, ss = pykyber._encapsulate(pk) + ss2 = pykyber._decapsulate_768(ct, sk) assert ss == ss2 def test_decapsulate_1024(): """Test decapsulate_1024 function.""" - pk, sk = pykyber.keypair_1024() - ct, ss = pykyber.encapsulate(pk) - ss2 = pykyber.decapsulate_1024(ct, sk) + pk, sk = pykyber._keypair_1024() + ct, ss = pykyber._encapsulate(pk) + ss2 = pykyber._decapsulate_1024(ct, sk) assert ss == ss2 def test_same_ciphertext_decapsulation(): """Test that same ciphertext always decapsulates to same secret.""" - pk, sk = pykyber.generate_keypair() - ct, _ = pykyber.encapsulate(pk) + pk, sk = pykyber._generate_keypair() + ct, _ = pykyber._encapsulate(pk) - results = [pykyber.decapsulate(ct, sk) for _ in range(10)] + results = [pykyber._decapsulate(ct, sk) for _ in range(10)] assert all(r == results[0] for r in results) def test_interoperability_different_calls(): """Test that different function variants work together.""" - pk, sk = pykyber.generate_keypair() + pk, sk = pykyber._generate_keypair() # Mix and match - ct1, ss1 = pykyber.encapsulate(pk) - ss1_dec = pykyber.decapsulate(ct1, sk) + ct1, ss1 = pykyber._encapsulate(pk) + ss1_dec = pykyber._decapsulate(ct1, sk) assert ss1 == ss1_dec - ct2, ss2 = pykyber.encapsulate_768(pk) - ss2_dec = pykyber.decapsulate_768(ct2, sk) + ct2, ss2 = pykyber._encapsulate_768(pk) + ss2_dec = pykyber._decapsulate_768(ct2, sk) assert ss2 == ss2_dec @@ -284,75 +284,84 @@ def test_zero_keypair_not_rejected(): """Test that zero public key is not rejected (produces weak output).""" zero_pk = bytes(1184) # Kyber doesn't reject zero keys - it will produce output (but weak) - ct, ss = pykyber.encapsulate(zero_pk) + ct, ss = pykyber._encapsulate(zero_pk) assert len(ct) == 1088 assert len(ss) == 32 def test_very_long_input_rejection(): """Test that too long inputs are handled.""" - pk, sk = pykyber.generate_keypair() + pk, sk = pykyber._generate_keypair() long_pk = pk + b"extra" with pytest.raises(Exception): - pykyber.encapsulate(long_pk) + pykyber._encapsulate(long_pk) # Class-based API tests -def test_kyber768_keypair_class(): - """Test Kyber768KeyPair class.""" - kp = pykyber.Kyber768KeyPair.generate() - assert len(kp.public_key) == 1184 - assert len(kp.secret_key) == 2400 - ct, ss = kp.encapsulate() - assert len(ct) == 1088 - assert len(ss) == 32 - ss2 = kp.decapsulate(ct) - assert ss == ss2 - - -def test_kyber512_keypair_class(): - """Test Kyber512KeyPair class.""" - kp = pykyber.Kyber512KeyPair.generate() - assert len(kp.public_key) == 1184 - assert len(kp.secret_key) == 2400 - ct, ss = kp.encapsulate() - ss2 = kp.decapsulate(ct) - assert ss == ss2 +def test_kyber768_new_api(): + """Test new Kyber768 API: private_key = generate_keypair(); public_key = private_key.public_key""" + private_key = pykyber.Kyber768.generate_keypair() + public_key = private_key.public_key + + ciphertext, shared_secret = public_key.encapsulate() + shared_secret2 = private_key.decapsulate(ciphertext) + + assert len(public_key.public_key) == 1184 + assert len(private_key.secret_key) == 2400 + assert len(ciphertext) == 1088 + assert len(shared_secret) == 32 + assert shared_secret == shared_secret2 -def test_kyber1024_keypair_class(): - """Test Kyber1024KeyPair class.""" - kp = pykyber.Kyber1024KeyPair.generate() - assert len(kp.public_key) == 1184 - assert len(kp.secret_key) == 2400 - ct, ss = kp.encapsulate() - ss2 = kp.decapsulate(ct) - assert ss == ss2 +def test_kyber512_new_api(): + """Test new Kyber512 API.""" + private_key = pykyber.Kyber512.generate_keypair() + public_key = private_key.public_key + + ciphertext, shared_secret = public_key.encapsulate() + shared_secret2 = private_key.decapsulate(ciphertext) + + # Note: Rust implementation currently returns Kyber768 sizes + assert len(public_key.public_key) == 1184 + assert len(private_key.secret_key) == 2400 + assert len(ciphertext) == 1088 + assert shared_secret == shared_secret2 -def test_kyber768_from_bytes(): - """Test Kyber768KeyPair.from_bytes.""" - kp1 = pykyber.Kyber768KeyPair.generate() - kp2 = pykyber.Kyber768KeyPair.from_bytes(kp1.public_key, kp1.secret_key) - ct, ss = kp2.encapsulate() - ss2 = kp2.decapsulate(ct) - assert ss == ss2 +def test_kyber1024_new_api(): + """Test new Kyber1024 API.""" + private_key = pykyber.Kyber1024.generate_keypair() + public_key = private_key.public_key + + ciphertext, shared_secret = public_key.encapsulate() + shared_secret2 = private_key.decapsulate(ciphertext) + + # Note: Rust implementation currently returns Kyber768 sizes + assert len(public_key.public_key) == 1184 + assert len(private_key.secret_key) == 2400 + assert len(ciphertext) == 1088 + assert shared_secret == shared_secret2 def test_kyber_class_alias(): """Test that Kyber is an alias for Kyber768.""" - pk, sk = pykyber.Kyber.generate_keypair() - assert len(pk) == 1184 - ct, ss = pykyber.Kyber.encapsulate(pk) - ss2 = pykyber.Kyber.decapsulate(ct, sk) - assert ss == ss2 + private_key = pykyber.Kyber.generate_keypair() + public_key = private_key.public_key + + ciphertext, shared_secret = public_key.encapsulate() + shared_secret2 = private_key.decapsulate(ciphertext) + + assert len(public_key.public_key) == 1184 + assert shared_secret == shared_secret2 def test_keypair_repr(): """Test __repr__ methods.""" - kp = pykyber.Kyber768KeyPair.generate() - r = repr(kp) - assert 'Kyber768KeyPair' in r - assert 'public_key' in r - assert 'secret_key' in r + private_key = pykyber.Kyber768.generate_keypair() + r = repr(private_key) + assert 'PrivateKey' in r + + public_key = private_key.public_key + r = repr(public_key) + assert 'PublicKey' in r diff --git a/src/lib.rs b/src/lib.rs index 581219f..2dbd87f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -286,62 +286,62 @@ mod _pykyber { use pyo3::prelude::*; #[pyfunction] - pub fn generate_keypair() -> PyResult<(Vec, Vec)> { + pub fn _generate_keypair() -> PyResult<(Vec, Vec)> { super::generate_keypair() } #[pyfunction] - pub fn encapsulate(pk: &[u8]) -> PyResult<(Vec, Vec)> { + pub fn _encapsulate(pk: &[u8]) -> PyResult<(Vec, Vec)> { super::encapsulate_key(pk) } #[pyfunction] - pub fn decapsulate(ct: &[u8], sk: &[u8]) -> PyResult> { + pub fn _decapsulate(ct: &[u8], sk: &[u8]) -> PyResult> { super::decapsulate_key(ct, sk) } #[pyfunction] - pub fn keypair_512() -> PyResult<(Vec, Vec)> { + pub fn _keypair_512() -> PyResult<(Vec, Vec)> { super::generate_keypair() } #[pyfunction] - pub fn keypair_768() -> PyResult<(Vec, Vec)> { + pub fn _keypair_768() -> PyResult<(Vec, Vec)> { super::generate_keypair() } #[pyfunction] - pub fn keypair_1024() -> PyResult<(Vec, Vec)> { + pub fn _keypair_1024() -> PyResult<(Vec, Vec)> { super::generate_keypair() } #[pyfunction] - pub fn encapsulate_512(pk: &[u8]) -> PyResult<(Vec, Vec)> { + pub fn _encapsulate_512(pk: &[u8]) -> PyResult<(Vec, Vec)> { super::encapsulate_key(pk) } #[pyfunction] - pub fn encapsulate_768(pk: &[u8]) -> PyResult<(Vec, Vec)> { + pub fn _encapsulate_768(pk: &[u8]) -> PyResult<(Vec, Vec)> { super::encapsulate_key(pk) } #[pyfunction] - pub fn encapsulate_1024(pk: &[u8]) -> PyResult<(Vec, Vec)> { + pub fn _encapsulate_1024(pk: &[u8]) -> PyResult<(Vec, Vec)> { super::encapsulate_key(pk) } #[pyfunction] - pub fn decapsulate_512(ct: &[u8], sk: &[u8]) -> PyResult> { + pub fn _decapsulate_512(ct: &[u8], sk: &[u8]) -> PyResult> { super::decapsulate_key(ct, sk) } #[pyfunction] - pub fn decapsulate_768(ct: &[u8], sk: &[u8]) -> PyResult> { + pub fn _decapsulate_768(ct: &[u8], sk: &[u8]) -> PyResult> { super::decapsulate_key(ct, sk) } #[pyfunction] - pub fn decapsulate_1024(ct: &[u8], sk: &[u8]) -> PyResult> { + pub fn _decapsulate_1024(ct: &[u8], sk: &[u8]) -> PyResult> { super::decapsulate_key(ct, sk) } } From 0a52dc622dcac31e89139d8b9c84dd2757eb7f4d Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Fri, 20 Feb 2026 22:46:51 +0200 Subject: [PATCH 08/47] changed public api again --- python/pykyber/__init__.py | 3 +-- python/pykyber/{kyber.py => _kyber.py} | 2 -- python/pykyber/wrappers.py | 0 3 files changed, 1 insertion(+), 4 deletions(-) rename python/pykyber/{kyber.py => _kyber.py} (99%) delete mode 100644 python/pykyber/wrappers.py diff --git a/python/pykyber/__init__.py b/python/pykyber/__init__.py index b154067..4e390e7 100644 --- a/python/pykyber/__init__.py +++ b/python/pykyber/__init__.py @@ -1,7 +1,6 @@ """Kyber post-quantum key encapsulation.""" -from .kyber import ( - Kyber, +from ._kyber import ( Kyber768, Kyber512, Kyber1024, diff --git a/python/pykyber/kyber.py b/python/pykyber/_kyber.py similarity index 99% rename from python/pykyber/kyber.py rename to python/pykyber/_kyber.py index 0326ac3..4bfd0a1 100644 --- a/python/pykyber/kyber.py +++ b/python/pykyber/_kyber.py @@ -162,5 +162,3 @@ def _encapsulate_fn(cls) -> Callable[[bytes], Tuple[bytes, bytes]]: def _decapsulate_fn(cls) -> Callable[[bytes, bytes], bytes]: return pykyber._decapsulate_1024 - -Kyber = Kyber768 diff --git a/python/pykyber/wrappers.py b/python/pykyber/wrappers.py deleted file mode 100644 index e69de29..0000000 From 9e16c471450aff5916fdb87fbd7e9b3f14d9e872 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Fri, 20 Feb 2026 23:32:37 +0200 Subject: [PATCH 09/47] changed public api again v2 --- python/pykyber/__init__.py | 2 - python/pykyber/_kyber.py | 165 +++++++----------------- python/{pykyber => tests}/test_kyber.py | 127 ++++++++---------- 3 files changed, 105 insertions(+), 189 deletions(-) rename python/{pykyber => tests}/test_kyber.py (82%) diff --git a/python/pykyber/__init__.py b/python/pykyber/__init__.py index 4e390e7..9639633 100644 --- a/python/pykyber/__init__.py +++ b/python/pykyber/__init__.py @@ -4,8 +4,6 @@ Kyber768, Kyber512, Kyber1024, - PublicKey, - PrivateKey, ) # Import underscored functions from Rust diff --git a/python/pykyber/_kyber.py b/python/pykyber/_kyber.py index 4bfd0a1..c9445fc 100644 --- a/python/pykyber/_kyber.py +++ b/python/pykyber/_kyber.py @@ -1,92 +1,37 @@ """Kyber post-quantum key encapsulation.""" -import pykyber -from abc import ABC, abstractmethod +from dataclasses import dataclass from typing import Tuple, Callable -class Kyber(ABC): - """Abstract base class for Kyber key encapsulation.""" - - PUBLIC_KEY_SIZE: int - SECRET_KEY_SIZE: int - CIPHERTEXT_SIZE: int - SHARED_SECRET_SIZE: int - - @classmethod - @abstractmethod - def _keypair_fn(cls) -> Tuple[bytes, bytes]: - """Return the keypair generation function.""" - pass - - @classmethod - @abstractmethod - def _encapsulate_fn(cls) -> Callable[[bytes], Tuple[bytes, bytes]]: - """Return the encapsulate function.""" - pass - - @classmethod - @abstractmethod - def _decapsulate_fn(cls) -> Callable[[bytes, bytes], bytes]: - """Return the decapsulate function.""" - pass - - @classmethod - def generate_keypair(cls) -> 'PrivateKey': - """Generate a key pair. Returns PrivateKey (which has .public_key property).""" - pk, sk = cls._keypair_fn() - return PrivateKey(sk, pk, cls._encapsulate_fn(), cls._decapsulate_fn()) - - @staticmethod - def encapsulate(pk: bytes) -> Tuple[bytes, bytes]: - """Encapsulate a shared secret using a public key.""" - raise NotImplementedError("Use variant-specific class") - - @staticmethod - def decapsulate(ct: bytes, sk: bytes) -> bytes: - """Decapsulate a shared secret using ciphertext and secret key.""" - raise NotImplementedError("Use variant-specific class") +@dataclass(frozen=True) +class EncapsulationResult: + """Result of a Kyber encapsulation.""" + ciphertext: bytes + shared_secret: bytes -class PublicKey: - """Public key with encapsulate method.""" - - def __init__(self, public_key_bytes: bytes, - encapsulate_fn: Callable[[bytes], Tuple[bytes, bytes]], - decapsulate_fn: Callable[[bytes, bytes], bytes]): - self._public_key = public_key_bytes - self._encapsulate_fn = encapsulate_fn - self._decapsulate_fn = decapsulate_fn - - def encapsulate(self) -> Tuple[bytes, bytes]: - """Encapsulate a shared secret using the public key.""" - return self._encapsulate_fn(self._public_key) - - @property - def public_key(self) -> bytes: - """Return the raw public key bytes.""" - return self._public_key - def __repr__(self) -> str: - return f"PublicKey({len(self._public_key)} bytes)" + return ( + f"EncapsulationResult(" + f"ciphertext={len(self.ciphertext)} bytes, " + f"shared_secret={len(self.shared_secret)} bytes)" + ) + + +@dataclass +class Keypair: + """Keypair containing private key material with decapsulate method.""" + _secret_key: bytes + _public_key: bytes + _encapsulate_fn: Callable[[bytes], Tuple[bytes, bytes]] + _decapsulate_fn: Callable[[bytes, bytes], bytes] + + def encapsulate(self) -> EncapsulationResult: + """Encapsulate a shared secret using the public key.""" + return EncapsulationResult(*self._encapsulate_fn(self._public_key)) -class PrivateKey: - """Private key with decapsulate method.""" - - def __init__(self, secret_key_bytes: bytes, public_key_bytes: bytes, - encapsulate_fn: Callable[[bytes], Tuple[bytes, bytes]], - decapsulate_fn: Callable[[bytes, bytes], bytes]): - self._secret_key = secret_key_bytes - self._public_key = public_key_bytes - self._encapsulate_fn = encapsulate_fn - self._decapsulate_fn = decapsulate_fn - - @property - def public_key(self) -> PublicKey: - """Return the corresponding public key (for encapsulation).""" - return PublicKey(self._public_key, self._encapsulate_fn, self._decapsulate_fn) - def decapsulate(self, ciphertext: bytes) -> bytes: """Decapsulate a shared secret using ciphertext.""" return self._decapsulate_fn(ciphertext, self._secret_key) @@ -96,11 +41,16 @@ def secret_key(self) -> bytes: """Return the raw secret key bytes.""" return self._secret_key + @property + def public_key(self) -> bytes: + """Return the raw public key bytes.""" + return self._public_key + def __repr__(self) -> str: - return f"PrivateKey({len(self._secret_key)} bytes)" + return f"Keypair(secret_key={len(self._secret_key)} bytes, public_key={len(self._public_key)} bytes)" -class Kyber512(Kyber): +class Kyber512: """Kyber-512 key encapsulation (security ~AES-128).""" PUBLIC_KEY_SIZE = 800 @@ -108,20 +58,14 @@ class Kyber512(Kyber): CIPHERTEXT_SIZE = 768 SHARED_SECRET_SIZE = 32 - @classmethod - def _keypair_fn(cls) -> Tuple[bytes, bytes]: - return pykyber._keypair_512() - - @classmethod - def _encapsulate_fn(cls) -> Callable[[bytes], Tuple[bytes, bytes]]: - return pykyber._encapsulate_512 - - @classmethod - def _decapsulate_fn(cls) -> Callable[[bytes, bytes], bytes]: - return pykyber._decapsulate_512 + def __new__(cls) -> Keypair: + """Generate a new key pair.""" + from . import _pykyber + pk, sk = _pykyber._keypair_512() + return Keypair(sk, pk, _pykyber._encapsulate_512, _pykyber._decapsulate_512) -class Kyber768(Kyber): +class Kyber768: """Kyber-768 key encapsulation (security ~AES-192).""" PUBLIC_KEY_SIZE = 1184 @@ -129,20 +73,14 @@ class Kyber768(Kyber): CIPHERTEXT_SIZE = 1088 SHARED_SECRET_SIZE = 32 - @classmethod - def _keypair_fn(cls) -> Tuple[bytes, bytes]: - return pykyber._keypair_768() - - @classmethod - def _encapsulate_fn(cls) -> Callable[[bytes], Tuple[bytes, bytes]]: - return pykyber._encapsulate_768 - - @classmethod - def _decapsulate_fn(cls) -> Callable[[bytes, bytes], bytes]: - return pykyber._decapsulate_768 + def __new__(cls) -> Keypair: + """Generate a new key pair.""" + from . import _pykyber + pk, sk = _pykyber._keypair_768() + return Keypair(sk, pk, _pykyber._encapsulate_768, _pykyber._decapsulate_768) -class Kyber1024(Kyber): +class Kyber1024: """Kyber-1024 key encapsulation (security ~AES-256).""" PUBLIC_KEY_SIZE = 1568 @@ -150,15 +88,8 @@ class Kyber1024(Kyber): CIPHERTEXT_SIZE = 1568 SHARED_SECRET_SIZE = 32 - @classmethod - def _keypair_fn(cls) -> Tuple[bytes, bytes]: - return pykyber._keypair_1024() - - @classmethod - def _encapsulate_fn(cls) -> Callable[[bytes], Tuple[bytes, bytes]]: - return pykyber._encapsulate_1024 - - @classmethod - def _decapsulate_fn(cls) -> Callable[[bytes, bytes], bytes]: - return pykyber._decapsulate_1024 - + def __new__(cls) -> Keypair: + """Generate a new key pair.""" + from . import _pykyber + pk, sk = _pykyber._keypair_1024() + return Keypair(sk, pk, _pykyber._encapsulate_1024, _pykyber._decapsulate_1024) diff --git a/python/pykyber/test_kyber.py b/python/tests/test_kyber.py similarity index 82% rename from python/pykyber/test_kyber.py rename to python/tests/test_kyber.py index 4bccb6e..50fbc13 100644 --- a/python/pykyber/test_kyber.py +++ b/python/tests/test_kyber.py @@ -2,6 +2,63 @@ import pykyber +# Class-based API tests + +def test_kyber768_new_api(): + """Test new Kyber768 API: keypair = Kyber768(); result = keypair.encapsulate()""" + keypair = pykyber.Kyber768() + + result = keypair.encapsulate() + shared_secret2 = keypair.decapsulate(result.ciphertext) + + assert len(keypair.public_key) == 1184 + assert len(keypair.secret_key) == 2400 + assert len(result.ciphertext) == 1088 + assert len(result.shared_secret) == 32 + assert result.shared_secret == shared_secret2 + + +def test_kyber512_new_api(): + """Test new Kyber512 API.""" + keypair = pykyber.Kyber512() + + result = keypair.encapsulate() + shared_secret2 = keypair.decapsulate(result.ciphertext) + + # Note: Rust implementation currently returns Kyber768 sizes + assert len(keypair.public_key) == 1184 + assert len(keypair.secret_key) == 2400 + assert len(result.ciphertext) == 1088 + assert result.shared_secret == shared_secret2 + + +def test_kyber1024_new_api(): + """Test new Kyber1024 API.""" + keypair = pykyber.Kyber1024() + + result = keypair.encapsulate() + shared_secret2 = keypair.decapsulate(result.ciphertext) + + # Note: Rust implementation currently returns Kyber768 sizes + assert len(keypair.public_key) == 1184 + assert len(keypair.secret_key) == 2400 + assert len(result.ciphertext) == 1088 + assert result.shared_secret == shared_secret2 + + +def test_keypair_repr(): + """Test __repr__ methods.""" + keypair = pykyber.Kyber768() + r = repr(keypair) + assert 'Keypair' in r + assert 'public_key' in r + assert 'secret_key' in r + + result = keypair.encapsulate() + r = repr(result) + assert 'EncapsulationResult' in r + + def test_keypair_generation(): """Test that keypair generation produces valid keys.""" pk, sk = pykyber._generate_keypair() @@ -295,73 +352,3 @@ def test_very_long_input_rejection(): long_pk = pk + b"extra" with pytest.raises(Exception): pykyber._encapsulate(long_pk) - - -# Class-based API tests - -def test_kyber768_new_api(): - """Test new Kyber768 API: private_key = generate_keypair(); public_key = private_key.public_key""" - private_key = pykyber.Kyber768.generate_keypair() - public_key = private_key.public_key - - ciphertext, shared_secret = public_key.encapsulate() - shared_secret2 = private_key.decapsulate(ciphertext) - - assert len(public_key.public_key) == 1184 - assert len(private_key.secret_key) == 2400 - assert len(ciphertext) == 1088 - assert len(shared_secret) == 32 - assert shared_secret == shared_secret2 - - -def test_kyber512_new_api(): - """Test new Kyber512 API.""" - private_key = pykyber.Kyber512.generate_keypair() - public_key = private_key.public_key - - ciphertext, shared_secret = public_key.encapsulate() - shared_secret2 = private_key.decapsulate(ciphertext) - - # Note: Rust implementation currently returns Kyber768 sizes - assert len(public_key.public_key) == 1184 - assert len(private_key.secret_key) == 2400 - assert len(ciphertext) == 1088 - assert shared_secret == shared_secret2 - - -def test_kyber1024_new_api(): - """Test new Kyber1024 API.""" - private_key = pykyber.Kyber1024.generate_keypair() - public_key = private_key.public_key - - ciphertext, shared_secret = public_key.encapsulate() - shared_secret2 = private_key.decapsulate(ciphertext) - - # Note: Rust implementation currently returns Kyber768 sizes - assert len(public_key.public_key) == 1184 - assert len(private_key.secret_key) == 2400 - assert len(ciphertext) == 1088 - assert shared_secret == shared_secret2 - - -def test_kyber_class_alias(): - """Test that Kyber is an alias for Kyber768.""" - private_key = pykyber.Kyber.generate_keypair() - public_key = private_key.public_key - - ciphertext, shared_secret = public_key.encapsulate() - shared_secret2 = private_key.decapsulate(ciphertext) - - assert len(public_key.public_key) == 1184 - assert shared_secret == shared_secret2 - - -def test_keypair_repr(): - """Test __repr__ methods.""" - private_key = pykyber.Kyber768.generate_keypair() - r = repr(private_key) - assert 'PrivateKey' in r - - public_key = private_key.public_key - r = repr(public_key) - assert 'PublicKey' in r From febab8a3843db66f5c3dd13fdcb76757bf92beb7 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 21 Feb 2026 00:05:17 +0200 Subject: [PATCH 10/47] Added 512, 1024 support --- python/pykyber/_kyber.py | 18 ++ python/tests/test_kyber.py | 146 ++++++++++++--- src/kyber/indcpa.rs | 356 +++++++++++++++++++++++++++++++++++++ src/kyber/kem.rs | 165 ++++++++++++++++- src/kyber/mod.rs | 17 ++ src/kyber/params.rs | 39 ++++ src/kyber/polyvec.rs | 253 ++++++++++++++++++++++++++ src/lib.rs | 93 +++++++++- 8 files changed, 1058 insertions(+), 29 deletions(-) diff --git a/python/pykyber/_kyber.py b/python/pykyber/_kyber.py index c9445fc..b6750ac 100644 --- a/python/pykyber/_kyber.py +++ b/python/pykyber/_kyber.py @@ -63,6 +63,12 @@ def __new__(cls) -> Keypair: from . import _pykyber pk, sk = _pykyber._keypair_512() return Keypair(sk, pk, _pykyber._encapsulate_512, _pykyber._decapsulate_512) + + @staticmethod + def encapsulate(public_key: bytes) -> EncapsulationResult: + """Encapsulate a shared secret using a public key (no keypair needed).""" + from . import _pykyber + return EncapsulationResult(*_pykyber._encapsulate_512(public_key)) class Kyber768: @@ -78,6 +84,12 @@ def __new__(cls) -> Keypair: from . import _pykyber pk, sk = _pykyber._keypair_768() return Keypair(sk, pk, _pykyber._encapsulate_768, _pykyber._decapsulate_768) + + @staticmethod + def encapsulate(public_key: bytes) -> EncapsulationResult: + """Encapsulate a shared secret using a public key (no keypair needed).""" + from . import _pykyber + return EncapsulationResult(*_pykyber._encapsulate_768(public_key)) class Kyber1024: @@ -93,3 +105,9 @@ def __new__(cls) -> Keypair: from . import _pykyber pk, sk = _pykyber._keypair_1024() return Keypair(sk, pk, _pykyber._encapsulate_1024, _pykyber._decapsulate_1024) + + @staticmethod + def encapsulate(public_key: bytes) -> EncapsulationResult: + """Encapsulate a shared secret using a public key (no keypair needed).""" + from . import _pykyber + return EncapsulationResult(*_pykyber._encapsulate_1024(public_key)) diff --git a/python/tests/test_kyber.py b/python/tests/test_kyber.py index 50fbc13..f9206e8 100644 --- a/python/tests/test_kyber.py +++ b/python/tests/test_kyber.py @@ -25,10 +25,10 @@ def test_kyber512_new_api(): result = keypair.encapsulate() shared_secret2 = keypair.decapsulate(result.ciphertext) - # Note: Rust implementation currently returns Kyber768 sizes - assert len(keypair.public_key) == 1184 - assert len(keypair.secret_key) == 2400 - assert len(result.ciphertext) == 1088 + assert len(keypair.public_key) == 800 + assert len(keypair.secret_key) == 1632 + assert len(result.ciphertext) == 768 + assert len(result.shared_secret) == 32 assert result.shared_secret == shared_secret2 @@ -39,10 +39,10 @@ def test_kyber1024_new_api(): result = keypair.encapsulate() shared_secret2 = keypair.decapsulate(result.ciphertext) - # Note: Rust implementation currently returns Kyber768 sizes - assert len(keypair.public_key) == 1184 - assert len(keypair.secret_key) == 2400 - assert len(result.ciphertext) == 1088 + assert len(keypair.public_key) == 1568 + assert len(keypair.secret_key) == 3168 + assert len(result.ciphertext) == 1408 + assert len(result.shared_secret) == 32 assert result.shared_secret == shared_secret2 @@ -126,8 +126,8 @@ def test_wrong_secret_key_fails(): def test_keypair_512(): """Test keypair generation for Kyber-512.""" pk, sk = pykyber._keypair_512() - assert len(pk) == 1184 - assert len(sk) == 2400 + assert len(pk) == 800 + assert len(sk) == 1632 def test_keypair_768(): @@ -140,8 +140,8 @@ def test_keypair_768(): def test_keypair_1024(): """Test keypair generation for Kyber-1024.""" pk, sk = pykyber._keypair_1024() - assert len(pk) == 1184 - assert len(sk) == 2400 + assert len(pk) == 1568 + assert len(sk) == 3168 def test_deterministic_decapsulation(): @@ -253,16 +253,16 @@ def test_keypair_768_function(): def test_keypair_512_function(): """Test that keypair_512 function works.""" pk, sk = pykyber._keypair_512() - ct, ss = pykyber._encapsulate(pk) - ss2 = pykyber._decapsulate(ct, sk) + ct, ss = pykyber._encapsulate_512(pk) + ss2 = pykyber._decapsulate_512(ct, sk) assert ss == ss2 def test_keypair_1024_function(): """Test that keypair_1024 function works.""" pk, sk = pykyber._keypair_1024() - ct, ss = pykyber._encapsulate(pk) - ss2 = pykyber._decapsulate(ct, sk) + ct, ss = pykyber._encapsulate_1024(pk) + ss2 = pykyber._decapsulate_1024(ct, sk) assert ss == ss2 @@ -293,7 +293,7 @@ def test_encapsulate_1024(): def test_decapsulate_512(): """Test decapsulate_512 function.""" pk, sk = pykyber._keypair_512() - ct, ss = pykyber._encapsulate(pk) + ct, ss = pykyber._encapsulate_512(pk) ss2 = pykyber._decapsulate_512(ct, sk) assert ss == ss2 @@ -309,7 +309,7 @@ def test_decapsulate_768(): def test_decapsulate_1024(): """Test decapsulate_1024 function.""" pk, sk = pykyber._keypair_1024() - ct, ss = pykyber._encapsulate(pk) + ct, ss = pykyber._encapsulate_1024(pk) ss2 = pykyber._decapsulate_1024(ct, sk) assert ss == ss2 @@ -339,10 +339,10 @@ def test_interoperability_different_calls(): def test_zero_keypair_not_rejected(): """Test that zero public key is not rejected (produces weak output).""" - zero_pk = bytes(1184) + zero_pk = bytes(800) # Kyber doesn't reject zero keys - it will produce output (but weak) - ct, ss = pykyber._encapsulate(zero_pk) - assert len(ct) == 1088 + ct, ss = pykyber._encapsulate_512(zero_pk) + assert len(ct) == 768 assert len(ss) == 32 @@ -352,3 +352,107 @@ def test_very_long_input_rejection(): long_pk = pk + b"extra" with pytest.raises(Exception): pykyber._encapsulate(long_pk) + + +# Key exchange tests (Alice and Bob) + +def test_key_exchange_kyber512(): + """Test Alice and Bob can exchange keys using Kyber512.""" + # Alice generates a keypair + alice_keypair = pykyber.Kyber512() + alice_public_key = alice_keypair.public_key + + # Bob encapsulates using Alice's public key (no keypair needed) + result = pykyber.Kyber512.encapsulate(alice_public_key) + bob_shared_secret = result.shared_secret + ciphertext = result.ciphertext + + # Alice decapsulates using her keypair + alice_shared_secret = alice_keypair.decapsulate(ciphertext) + + # Both should have the same shared secret + assert alice_shared_secret == bob_shared_secret + + +def test_key_exchange_kyber768(): + """Test Alice and Bob can exchange keys using Kyber768.""" + # Alice generates a keypair + alice_keypair = pykyber.Kyber768() + alice_public_key = alice_keypair.public_key + + # Bob encapsulates using Alice's public key (no keypair needed) + result = pykyber.Kyber768.encapsulate(alice_public_key) + bob_shared_secret = result.shared_secret + ciphertext = result.ciphertext + + # Alice decapsulates using her keypair + alice_shared_secret = alice_keypair.decapsulate(ciphertext) + + # Both should have the same shared secret + assert alice_shared_secret == bob_shared_secret + + +def test_key_exchange_kyber1024(): + """Test Alice and Bob can exchange keys using Kyber1024.""" + # Alice generates a keypair + alice_keypair = pykyber.Kyber1024() + alice_public_key = alice_keypair.public_key + + # Bob encapsulates using Alice's public key (no keypair needed) + result = pykyber.Kyber1024.encapsulate(alice_public_key) + bob_shared_secret = result.shared_secret + ciphertext = result.ciphertext + + # Alice decapsulates using her keypair + alice_shared_secret = alice_keypair.decapsulate(ciphertext) + + # Both should have the same shared secret + assert alice_shared_secret == bob_shared_secret + + +def test_encapsulate_static_method_kyber512(): + """Test Kyber512.encapsulate() static method works.""" + # Generate a keypair to get a public key + keypair = pykyber.Kyber512() + pk = keypair.public_key + + # Use static method to encapsulate + result = pykyber.Kyber512.encapsulate(pk) + + assert isinstance(result, pykyber._kyber.EncapsulationResult) + assert len(result.ciphertext) == 768 + assert len(result.shared_secret) == 32 + + # Can decapsulate with keypair + ss = keypair.decapsulate(result.ciphertext) + assert ss == result.shared_secret + + +def test_encapsulate_static_method_kyber768(): + """Test Kyber768.encapsulate() static method works.""" + keypair = pykyber.Kyber768() + pk = keypair.public_key + + result = pykyber.Kyber768.encapsulate(pk) + + assert isinstance(result, pykyber._kyber.EncapsulationResult) + assert len(result.ciphertext) == 1088 + assert len(result.shared_secret) == 32 + + ss = keypair.decapsulate(result.ciphertext) + assert ss == result.shared_secret + + +def test_encapsulate_static_method_kyber1024(): + """Test Kyber1024.encapsulate() static method works.""" + keypair = pykyber.Kyber1024() + pk = keypair.public_key + + result = pykyber.Kyber1024.encapsulate(pk) + + assert isinstance(result, pykyber._kyber.EncapsulationResult) + assert len(result.ciphertext) == 1408 + assert len(result.shared_secret) == 32 + + ss = keypair.decapsulate(result.ciphertext) + assert ss == result.shared_secret diff --git a/src/kyber/indcpa.rs b/src/kyber/indcpa.rs index 490ee39..403f14c 100644 --- a/src/kyber/indcpa.rs +++ b/src/kyber/indcpa.rs @@ -210,3 +210,359 @@ pub fn indcpa_dec(m: &mut [u8], c: &[u8], sk: &[u8]) { poly_tomsg(m, mp); } + +fn pack_pk_512(r: &mut [u8], pk: &mut Polyvec512, seed: &[u8]) { + const END: usize = KYBER_SYMBYTES + KYBER_512_POLYVECBYTES; + polyvec_tobytes_512(r, pk); + r[KYBER_512_POLYVECBYTES..END].copy_from_slice(&seed[..KYBER_SYMBYTES]); +} + +fn unpack_pk_512(pk: &mut Polyvec512, seed: &mut [u8], packedpk: &[u8]) { + const END: usize = KYBER_SYMBYTES + KYBER_512_POLYVECBYTES; + polyvec_frombytes_512(pk, packedpk); + seed[..KYBER_SYMBYTES].copy_from_slice(&packedpk[KYBER_512_POLYVECBYTES..END]); +} + +fn pack_ciphertext_512(r: &mut [u8], b: &mut Polyvec512, v: Poly) { + polyvec_compress_512(r, *b); + poly_compress(&mut r[KYBER_512_POLYVECCOMPRESSEDBYTES..], v); +} + +fn unpack_ciphertext_512(b: &mut Polyvec512, v: &mut Poly, c: &[u8]) { + polyvec_decompress_512(b, c); + poly_decompress(v, &c[KYBER_512_POLYVECCOMPRESSEDBYTES..]); +} + +fn gen_matrix_512(a: &mut [Polyvec512], seed: &[u8], transposed: bool) { + let mut ctr; + const K: usize = KYBER_512_K; + const GEN_MATRIX_NBLOCKS: usize = + (12 * KYBER_N / 8 * (1 << 12) / KYBER_Q + XOF_BLOCKBYTES) / XOF_BLOCKBYTES; + let mut buf = [0u8; GEN_MATRIX_NBLOCKS * XOF_BLOCKBYTES + 2]; + let mut buflen: usize; + let mut off: usize; + let mut state = XofState::new(); + + for i in 0..K { + for j in 0..K { + if transposed { + xof_absorb_bytes(&mut state, seed, i as u8, j as u8); + } else { + xof_absorb_bytes(&mut state, seed, j as u8, i as u8); + } + xof_squeeze_blocks(&mut buf, GEN_MATRIX_NBLOCKS, &mut state); + buflen = GEN_MATRIX_NBLOCKS * XOF_BLOCKBYTES; + ctr = rej_uniform(&mut a[i].vec[j].coeffs, KYBER_N, &buf, buflen); + + while ctr < KYBER_N { + off = buflen % 3; + for k in 0..off { + buf[k] = buf[buflen - off + k]; + } + xof_squeeze_blocks(&mut buf[off..], 1, &mut state); + buflen = off + XOF_BLOCKBYTES; + ctr += rej_uniform(&mut a[i].vec[j].coeffs[ctr..], KYBER_N - ctr, &buf, buflen); + } + } + } +} + +fn gen_a_512(a: &mut [Polyvec512], b: &[u8]) { + gen_matrix_512(a, b, false); +} + +fn gen_at_512(a: &mut [Polyvec512], b: &[u8]) { + gen_matrix_512(a, b, true); +} + +pub fn indcpa_keypair_512( + pk: &mut [u8], + sk: &mut [u8], + _seed: Option<(&[u8], &[u8])>, + _rng: &mut R, +) -> Result<(), KyberError> +where + R: CryptoRng + RngCore, +{ + const K: usize = KYBER_512_K; + let mut a = [Polyvec512::new(); K]; + let (mut e, mut pkpv, mut skpv) = (Polyvec512::new(), Polyvec512::new(), Polyvec512::new()); + let mut nonce = 0u8; + let mut buf = [0u8; 2 * KYBER_SYMBYTES]; + let mut randbuf = [0u8; 2 * KYBER_SYMBYTES]; + + if let Some(s) = _seed { + randbuf[..KYBER_SYMBYTES].copy_from_slice(&s.0); + } else { + _rng.fill_bytes(&mut randbuf[..KYBER_SYMBYTES]); + } + + hash_sha3_512(&mut buf, &randbuf, KYBER_SYMBYTES); + + let (publicseed, noiseseed) = buf.split_at(KYBER_SYMBYTES); + gen_a_512(&mut a, publicseed); + + for i in 0..K { + poly_getnoise_eta1(&mut skpv.vec[i], noiseseed, nonce); + nonce += 1; + } + for i in 0..K { + poly_getnoise_eta1(&mut e.vec[i], noiseseed, nonce); + nonce += 1; + } + + polyvec_ntt_512(&mut skpv); + polyvec_ntt_512(&mut e); + + for i in 0..K { + polyvec_basemul_acc_montgomery_512(&mut pkpv.vec[i], &a[i], &skpv); + poly_tomont(&mut pkpv.vec[i]); + } + polyvec_add_512(&mut pkpv, &e); + polyvec_reduce_512(&mut pkpv); + + polyvec_tobytes_512(sk, &skpv); + pack_pk_512(pk, &mut pkpv, publicseed); + Ok(()) +} + +pub fn indcpa_enc_512(c: &mut [u8], m: &[u8], pk: &[u8], coins: &[u8]) { + const K: usize = KYBER_512_K; + let mut at = [Polyvec512::new(); K]; + let (mut sp, mut pkpv, mut ep, mut b) = ( + Polyvec512::new(), + Polyvec512::new(), + Polyvec512::new(), + Polyvec512::new(), + ); + let (mut v, mut k, mut epp) = (Poly::new(), Poly::new(), Poly::new()); + let mut seed = [0u8; KYBER_SYMBYTES]; + let mut nonce = 0u8; + + unpack_pk_512(&mut pkpv, &mut seed, pk); + poly_frommsg(&mut k, m); + gen_at_512(&mut at, &seed); + + for i in 0..K { + poly_getnoise_eta1(&mut sp.vec[i], coins, nonce); + nonce += 1; + } + for i in 0..K { + poly_getnoise_eta2(&mut ep.vec[i], coins, nonce); + nonce += 1; + } + poly_getnoise_eta2(&mut epp, coins, nonce); + + polyvec_ntt_512(&mut sp); + + for i in 0..K { + polyvec_basemul_acc_montgomery_512(&mut b.vec[i], &at[i], &sp); + } + + polyvec_basemul_acc_montgomery_512(&mut v, &pkpv, &sp); + polyvec_invntt_tomont_512(&mut b); + poly_invntt_tomont(&mut v); + + polyvec_add_512(&mut b, &ep); + poly_add(&mut v, &epp); + poly_add(&mut v, &k); + polyvec_reduce_512(&mut b); + poly_reduce(&mut v); + + pack_ciphertext_512(c, &mut b, v); +} + +pub fn indcpa_dec_512(m: &mut [u8], c: &[u8], sk: &[u8]) { + let (mut b, mut skpv) = (Polyvec512::new(), Polyvec512::new()); + let (mut v, mut mp) = (Poly::new(), Poly::new()); + + unpack_ciphertext_512(&mut b, &mut v, c); + polyvec_frombytes_512(&mut skpv, sk); + + polyvec_ntt_512(&mut b); + polyvec_basemul_acc_montgomery_512(&mut mp, &skpv, &b); + poly_invntt_tomont(&mut mp); + + poly_sub(&mut mp, &v); + poly_reduce(&mut mp); + + poly_tomsg(m, mp); +} + +fn pack_pk_1024(r: &mut [u8], pk: &mut Polyvec1024, seed: &[u8]) { + const END: usize = KYBER_SYMBYTES + KYBER_1024_POLYVECBYTES; + polyvec_tobytes_1024(r, pk); + r[KYBER_1024_POLYVECBYTES..END].copy_from_slice(&seed[..KYBER_SYMBYTES]); +} + +fn unpack_pk_1024(pk: &mut Polyvec1024, seed: &mut [u8], packedpk: &[u8]) { + const END: usize = KYBER_SYMBYTES + KYBER_1024_POLYVECBYTES; + polyvec_frombytes_1024(pk, packedpk); + seed[..KYBER_SYMBYTES].copy_from_slice(&packedpk[KYBER_1024_POLYVECBYTES..END]); +} + +fn pack_ciphertext_1024(r: &mut [u8], b: &mut Polyvec1024, v: Poly) { + polyvec_compress_1024(r, *b); + poly_compress(&mut r[KYBER_1024_POLYVECCOMPRESSEDBYTES..], v); +} + +fn unpack_ciphertext_1024(b: &mut Polyvec1024, v: &mut Poly, c: &[u8]) { + polyvec_decompress_1024(b, c); + poly_decompress(v, &c[KYBER_1024_POLYVECCOMPRESSEDBYTES..]); +} + +fn gen_matrix_1024(a: &mut [Polyvec1024], seed: &[u8], transposed: bool) { + let mut ctr; + const K: usize = KYBER_1024_K; + const GEN_MATRIX_NBLOCKS: usize = + (12 * KYBER_N / 8 * (1 << 12) / KYBER_Q + XOF_BLOCKBYTES) / XOF_BLOCKBYTES; + let mut buf = [0u8; GEN_MATRIX_NBLOCKS * XOF_BLOCKBYTES + 2]; + let mut buflen: usize; + let mut off: usize; + let mut state = XofState::new(); + + for i in 0..K { + for j in 0..K { + if transposed { + xof_absorb_bytes(&mut state, seed, i as u8, j as u8); + } else { + xof_absorb_bytes(&mut state, seed, j as u8, i as u8); + } + xof_squeeze_blocks(&mut buf, GEN_MATRIX_NBLOCKS, &mut state); + buflen = GEN_MATRIX_NBLOCKS * XOF_BLOCKBYTES; + ctr = rej_uniform(&mut a[i].vec[j].coeffs, KYBER_N, &buf, buflen); + + while ctr < KYBER_N { + off = buflen % 3; + for k in 0..off { + buf[k] = buf[buflen - off + k]; + } + xof_squeeze_blocks(&mut buf[off..], 1, &mut state); + buflen = off + XOF_BLOCKBYTES; + ctr += rej_uniform(&mut a[i].vec[j].coeffs[ctr..], KYBER_N - ctr, &buf, buflen); + } + } + } +} + +fn gen_a_1024(a: &mut [Polyvec1024], b: &[u8]) { + gen_matrix_1024(a, b, false); +} + +fn gen_at_1024(a: &mut [Polyvec1024], b: &[u8]) { + gen_matrix_1024(a, b, true); +} + +pub fn indcpa_keypair_1024( + pk: &mut [u8], + sk: &mut [u8], + _seed: Option<(&[u8], &[u8])>, + _rng: &mut R, +) -> Result<(), KyberError> +where + R: CryptoRng + RngCore, +{ + const K: usize = KYBER_1024_K; + let mut a = [Polyvec1024::new(); K]; + let (mut e, mut pkpv, mut skpv) = (Polyvec1024::new(), Polyvec1024::new(), Polyvec1024::new()); + let mut nonce = 0u8; + let mut buf = [0u8; 2 * KYBER_SYMBYTES]; + let mut randbuf = [0u8; 2 * KYBER_SYMBYTES]; + + if let Some(s) = _seed { + randbuf[..KYBER_SYMBYTES].copy_from_slice(&s.0); + } else { + _rng.fill_bytes(&mut randbuf[..KYBER_SYMBYTES]); + } + + hash_sha3_512(&mut buf, &randbuf, KYBER_SYMBYTES); + + let (publicseed, noiseseed) = buf.split_at(KYBER_SYMBYTES); + gen_a_1024(&mut a, publicseed); + + for i in 0..K { + poly_getnoise_eta1(&mut skpv.vec[i], noiseseed, nonce); + nonce += 1; + } + for i in 0..K { + poly_getnoise_eta1(&mut e.vec[i], noiseseed, nonce); + nonce += 1; + } + + polyvec_ntt_1024(&mut skpv); + polyvec_ntt_1024(&mut e); + + for i in 0..K { + polyvec_basemul_acc_montgomery_1024(&mut pkpv.vec[i], &a[i], &skpv); + poly_tomont(&mut pkpv.vec[i]); + } + polyvec_add_1024(&mut pkpv, &e); + polyvec_reduce_1024(&mut pkpv); + + polyvec_tobytes_1024(sk, &skpv); + pack_pk_1024(pk, &mut pkpv, publicseed); + Ok(()) +} + +pub fn indcpa_enc_1024(c: &mut [u8], m: &[u8], pk: &[u8], coins: &[u8]) { + const K: usize = KYBER_1024_K; + let mut at = [Polyvec1024::new(); K]; + let (mut sp, mut pkpv, mut ep, mut b) = ( + Polyvec1024::new(), + Polyvec1024::new(), + Polyvec1024::new(), + Polyvec1024::new(), + ); + let (mut v, mut k, mut epp) = (Poly::new(), Poly::new(), Poly::new()); + let mut seed = [0u8; KYBER_SYMBYTES]; + let mut nonce = 0u8; + + unpack_pk_1024(&mut pkpv, &mut seed, pk); + poly_frommsg(&mut k, m); + gen_at_1024(&mut at, &seed); + + for i in 0..K { + poly_getnoise_eta1(&mut sp.vec[i], coins, nonce); + nonce += 1; + } + for i in 0..K { + poly_getnoise_eta2(&mut ep.vec[i], coins, nonce); + nonce += 1; + } + poly_getnoise_eta2(&mut epp, coins, nonce); + + polyvec_ntt_1024(&mut sp); + + for i in 0..K { + polyvec_basemul_acc_montgomery_1024(&mut b.vec[i], &at[i], &sp); + } + + polyvec_basemul_acc_montgomery_1024(&mut v, &pkpv, &sp); + polyvec_invntt_tomont_1024(&mut b); + poly_invntt_tomont(&mut v); + + polyvec_add_1024(&mut b, &ep); + poly_add(&mut v, &epp); + poly_add(&mut v, &k); + polyvec_reduce_1024(&mut b); + poly_reduce(&mut v); + + pack_ciphertext_1024(c, &mut b, v); +} + +pub fn indcpa_dec_1024(m: &mut [u8], c: &[u8], sk: &[u8]) { + let (mut b, mut skpv) = (Polyvec1024::new(), Polyvec1024::new()); + let (mut v, mut mp) = (Poly::new(), Poly::new()); + + unpack_ciphertext_1024(&mut b, &mut v, c); + polyvec_frombytes_1024(&mut skpv, sk); + + polyvec_ntt_1024(&mut b); + polyvec_basemul_acc_montgomery_1024(&mut mp, &skpv, &b); + poly_invntt_tomont(&mut mp); + + poly_sub(&mut mp, &v); + poly_reduce(&mut mp); + + poly_tomsg(m, mp); +} diff --git a/src/kyber/kem.rs b/src/kyber/kem.rs index a20461c..62a217d 100644 --- a/src/kyber/kem.rs +++ b/src/kyber/kem.rs @@ -1,5 +1,8 @@ use super::error::KyberError; -use super::indcpa::{indcpa_dec, indcpa_enc, indcpa_keypair}; +use super::indcpa::{ + indcpa_dec, indcpa_dec_1024, indcpa_dec_512, indcpa_enc, indcpa_enc_1024, indcpa_enc_512, + indcpa_keypair, indcpa_keypair_1024, indcpa_keypair_512, +}; use super::params::*; use super::symmetric::{hash_sha3_256, hash_sha3_512, shake256_kdf}; use super::verify::{cmov, verify}; @@ -83,3 +86,163 @@ pub fn crypto_kem_dec(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> () { cmov(&mut kr, &sk[END..], KYBER_SYMBYTES, fail); shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); } + +pub fn crypto_kem_keypair_512( + pk: &mut [u8], + sk: &mut [u8], + _rng: &mut R, + _seed: Option<(&[u8], &[u8])>, +) -> Result<(), KyberError> +where + R: RngCore + CryptoRng, +{ + const PK_START: usize = KYBER_512_SECRETKEYBYTES - (2 * KYBER_SYMBYTES); + const SK_START: usize = KYBER_512_SECRETKEYBYTES - KYBER_SYMBYTES; + const END: usize = KYBER_512_INDCPA_PUBLICKEYBYTES + KYBER_512_INDCPA_SECRETKEYBYTES; + + indcpa_keypair_512(pk, sk, _seed, _rng)?; + + sk[KYBER_512_INDCPA_SECRETKEYBYTES..END] + .copy_from_slice(&pk[..KYBER_512_INDCPA_PUBLICKEYBYTES]); + hash_sha3_256(&mut sk[PK_START..], pk, KYBER_512_PUBLICKEYBYTES); + + if let Some(s) = _seed { + sk[SK_START..].copy_from_slice(&s.1) + } else { + _rng.fill_bytes(&mut sk[SK_START..SK_START + KYBER_SYMBYTES]); + } + Ok(()) +} + +pub fn crypto_kem_enc_512( + ct: &mut [u8], + ss: &mut [u8], + pk: &[u8], + _rng: &mut R, + _seed: Option<&[u8]>, +) -> Result<(), KyberError> +where + R: RngCore + CryptoRng, +{ + let mut kr = [0u8; 2 * KYBER_SYMBYTES]; + let mut buf = [0u8; 2 * KYBER_SYMBYTES]; + let mut randbuf = [0u8; 2 * KYBER_SYMBYTES]; + + if let Some(s) = _seed { + randbuf[..KYBER_SYMBYTES].copy_from_slice(&s); + } else { + _rng.fill_bytes(&mut randbuf); + } + + hash_sha3_256(&mut buf, &randbuf, KYBER_SYMBYTES); + hash_sha3_256(&mut buf[KYBER_SYMBYTES..], pk, KYBER_512_PUBLICKEYBYTES); + hash_sha3_512(&mut kr, &buf, 2 * KYBER_SYMBYTES); + + indcpa_enc_512(ct, &buf, pk, &kr[KYBER_SYMBYTES..]); + + hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_512_CIPHERTEXTBYTES); + shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); + Ok(()) +} + +pub fn crypto_kem_dec_512(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> () { + let mut buf = [0u8; 2 * KYBER_SYMBYTES]; + let mut kr = [0u8; 2 * KYBER_SYMBYTES]; + let mut cmp = [0u8; KYBER_512_CIPHERTEXTBYTES]; + let mut pk = [0u8; KYBER_512_INDCPA_PUBLICKEYBYTES]; + + pk.copy_from_slice(&sk[KYBER_512_INDCPA_SECRETKEYBYTES..][..KYBER_512_INDCPA_PUBLICKEYBYTES]); + + indcpa_dec_512(&mut buf, ct, sk); + + const START: usize = KYBER_512_SECRETKEYBYTES - 2 * KYBER_SYMBYTES; + const END: usize = KYBER_512_SECRETKEYBYTES - KYBER_SYMBYTES; + buf[KYBER_SYMBYTES..].copy_from_slice(&sk[START..END]); + hash_sha3_512(&mut kr, &buf, 2 * KYBER_SYMBYTES); + + indcpa_enc_512(&mut cmp, &buf, &pk, &kr[KYBER_SYMBYTES..]); + let fail = verify(ct, &cmp, KYBER_512_CIPHERTEXTBYTES); + hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_512_CIPHERTEXTBYTES); + cmov(&mut kr, &sk[END..], KYBER_SYMBYTES, fail); + shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); +} + +pub fn crypto_kem_keypair_1024( + pk: &mut [u8], + sk: &mut [u8], + _rng: &mut R, + _seed: Option<(&[u8], &[u8])>, +) -> Result<(), KyberError> +where + R: RngCore + CryptoRng, +{ + const PK_START: usize = KYBER_1024_SECRETKEYBYTES - (2 * KYBER_SYMBYTES); + const SK_START: usize = KYBER_1024_SECRETKEYBYTES - KYBER_SYMBYTES; + const END: usize = KYBER_1024_INDCPA_PUBLICKEYBYTES + KYBER_1024_INDCPA_SECRETKEYBYTES; + + indcpa_keypair_1024(pk, sk, _seed, _rng)?; + + sk[KYBER_1024_INDCPA_SECRETKEYBYTES..END] + .copy_from_slice(&pk[..KYBER_1024_INDCPA_PUBLICKEYBYTES]); + hash_sha3_256(&mut sk[PK_START..], pk, KYBER_1024_PUBLICKEYBYTES); + + if let Some(s) = _seed { + sk[SK_START..].copy_from_slice(&s.1) + } else { + _rng.fill_bytes(&mut sk[SK_START..SK_START + KYBER_SYMBYTES]); + } + Ok(()) +} + +pub fn crypto_kem_enc_1024( + ct: &mut [u8], + ss: &mut [u8], + pk: &[u8], + _rng: &mut R, + _seed: Option<&[u8]>, +) -> Result<(), KyberError> +where + R: RngCore + CryptoRng, +{ + let mut kr = [0u8; 2 * KYBER_SYMBYTES]; + let mut buf = [0u8; 2 * KYBER_SYMBYTES]; + let mut randbuf = [0u8; 2 * KYBER_SYMBYTES]; + + if let Some(s) = _seed { + randbuf[..KYBER_SYMBYTES].copy_from_slice(&s); + } else { + _rng.fill_bytes(&mut randbuf); + } + + hash_sha3_256(&mut buf, &randbuf, KYBER_SYMBYTES); + hash_sha3_256(&mut buf[KYBER_SYMBYTES..], pk, KYBER_1024_PUBLICKEYBYTES); + hash_sha3_512(&mut kr, &buf, 2 * KYBER_SYMBYTES); + + indcpa_enc_1024(ct, &buf, pk, &kr[KYBER_SYMBYTES..]); + + hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_1024_CIPHERTEXTBYTES); + shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); + Ok(()) +} + +pub fn crypto_kem_dec_1024(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> () { + let mut buf = [0u8; 2 * KYBER_SYMBYTES]; + let mut kr = [0u8; 2 * KYBER_SYMBYTES]; + let mut cmp = [0u8; KYBER_1024_CIPHERTEXTBYTES]; + let mut pk = [0u8; KYBER_1024_INDCPA_PUBLICKEYBYTES]; + + pk.copy_from_slice(&sk[KYBER_1024_INDCPA_SECRETKEYBYTES..][..KYBER_1024_INDCPA_PUBLICKEYBYTES]); + + indcpa_dec_1024(&mut buf, ct, sk); + + const START: usize = KYBER_1024_SECRETKEYBYTES - 2 * KYBER_SYMBYTES; + const END: usize = KYBER_1024_SECRETKEYBYTES - KYBER_SYMBYTES; + buf[KYBER_SYMBYTES..].copy_from_slice(&sk[START..END]); + hash_sha3_512(&mut kr, &buf, 2 * KYBER_SYMBYTES); + + indcpa_enc_1024(&mut cmp, &buf, &pk, &kr[KYBER_SYMBYTES..]); + let fail = verify(ct, &cmp, KYBER_1024_CIPHERTEXTBYTES); + hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_1024_CIPHERTEXTBYTES); + cmov(&mut kr, &sk[END..], KYBER_SYMBYTES, fail); + shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); +} diff --git a/src/kyber/mod.rs b/src/kyber/mod.rs index 1286150..e133a29 100644 --- a/src/kyber/mod.rs +++ b/src/kyber/mod.rs @@ -14,5 +14,22 @@ pub mod verify; pub use api::*; pub use error::KyberError; +pub use indcpa::{ + indcpa_dec, indcpa_dec_1024, indcpa_dec_512, indcpa_enc, indcpa_enc_1024, indcpa_enc_512, + indcpa_keypair, indcpa_keypair_1024, indcpa_keypair_512, +}; +pub use kem::{ + crypto_kem_dec, crypto_kem_dec_1024, crypto_kem_dec_512, crypto_kem_enc, crypto_kem_enc_1024, + crypto_kem_enc_512, crypto_kem_keypair, crypto_kem_keypair_1024, crypto_kem_keypair_512, +}; pub use params::*; +pub use polyvec::{ + polyvec_add, polyvec_add_1024, polyvec_add_512, polyvec_basemul_acc_montgomery, + polyvec_basemul_acc_montgomery_1024, polyvec_basemul_acc_montgomery_512, polyvec_compress, + polyvec_compress_1024, polyvec_compress_512, polyvec_decompress, polyvec_decompress_1024, + polyvec_decompress_512, polyvec_frombytes, polyvec_frombytes_1024, polyvec_frombytes_512, + polyvec_invntt_tomont, polyvec_invntt_tomont_1024, polyvec_invntt_tomont_512, polyvec_ntt, + polyvec_ntt_1024, polyvec_ntt_512, polyvec_reduce, polyvec_reduce_1024, polyvec_reduce_512, + polyvec_tobytes, polyvec_tobytes_1024, polyvec_tobytes_512, Polyvec, Polyvec1024, Polyvec512, +}; pub use rand_core::{CryptoRng, RngCore}; diff --git a/src/kyber/params.rs b/src/kyber/params.rs index 60fe31a..1c5dd1d 100644 --- a/src/kyber/params.rs +++ b/src/kyber/params.rs @@ -24,3 +24,42 @@ pub const KYBER_PUBLICKEYBYTES: usize = KYBER_INDCPA_PUBLICKEYBYTES; pub const KYBER_SECRETKEYBYTES: usize = KYBER_INDCPA_SECRETKEYBYTES + KYBER_INDCPA_PUBLICKEYBYTES + 2 * KYBER_SYMBYTES; pub const KYBER_CIPHERTEXTBYTES: usize = KYBER_INDCPA_BYTES; + +// Kyber-512 constants (k=2) +pub const KYBER_512_K: usize = 2; +pub const KYBER_512_POLYVECBYTES: usize = KYBER_512_K * KYBER_POLYBYTES; +pub const KYBER_512_POLYVECCOMPRESSEDBYTES: usize = KYBER_512_K * 320; +pub const KYBER_512_INDCPA_PUBLICKEYBYTES: usize = KYBER_512_POLYVECBYTES + KYBER_SYMBYTES; +pub const KYBER_512_INDCPA_SECRETKEYBYTES: usize = KYBER_512_POLYVECBYTES; +pub const KYBER_512_INDCPA_BYTES: usize = + KYBER_512_POLYVECCOMPRESSEDBYTES + KYBER_POLYCOMPRESSEDBYTES; +pub const KYBER_512_PUBLICKEYBYTES: usize = KYBER_512_INDCPA_PUBLICKEYBYTES; +pub const KYBER_512_SECRETKEYBYTES: usize = + KYBER_512_INDCPA_SECRETKEYBYTES + KYBER_512_INDCPA_PUBLICKEYBYTES + 2 * KYBER_SYMBYTES; +pub const KYBER_512_CIPHERTEXTBYTES: usize = KYBER_512_INDCPA_BYTES; + +// Kyber-768 constants (k=3) +pub const KYBER_768_K: usize = 3; +pub const KYBER_768_POLYVECBYTES: usize = KYBER_768_K * KYBER_POLYBYTES; +pub const KYBER_768_POLYVECCOMPRESSEDBYTES: usize = KYBER_768_K * 320; +pub const KYBER_768_INDCPA_PUBLICKEYBYTES: usize = KYBER_768_POLYVECBYTES + KYBER_SYMBYTES; +pub const KYBER_768_INDCPA_SECRETKEYBYTES: usize = KYBER_768_POLYVECBYTES; +pub const KYBER_768_INDCPA_BYTES: usize = + KYBER_768_POLYVECCOMPRESSEDBYTES + KYBER_POLYCOMPRESSEDBYTES; +pub const KYBER_768_PUBLICKEYBYTES: usize = KYBER_768_INDCPA_PUBLICKEYBYTES; +pub const KYBER_768_SECRETKEYBYTES: usize = + KYBER_768_INDCPA_SECRETKEYBYTES + KYBER_768_INDCPA_PUBLICKEYBYTES + 2 * KYBER_SYMBYTES; +pub const KYBER_768_CIPHERTEXTBYTES: usize = KYBER_768_INDCPA_BYTES; + +// Kyber-1024 constants (k=4) +pub const KYBER_1024_K: usize = 4; +pub const KYBER_1024_POLYVECBYTES: usize = KYBER_1024_K * KYBER_POLYBYTES; +pub const KYBER_1024_POLYVECCOMPRESSEDBYTES: usize = KYBER_1024_K * 320; +pub const KYBER_1024_INDCPA_PUBLICKEYBYTES: usize = KYBER_1024_POLYVECBYTES + KYBER_SYMBYTES; +pub const KYBER_1024_INDCPA_SECRETKEYBYTES: usize = KYBER_1024_POLYVECBYTES; +pub const KYBER_1024_INDCPA_BYTES: usize = + KYBER_1024_POLYVECCOMPRESSEDBYTES + KYBER_POLYCOMPRESSEDBYTES; +pub const KYBER_1024_PUBLICKEYBYTES: usize = KYBER_1024_INDCPA_PUBLICKEYBYTES; +pub const KYBER_1024_SECRETKEYBYTES: usize = + KYBER_1024_INDCPA_SECRETKEYBYTES + KYBER_1024_INDCPA_PUBLICKEYBYTES + 2 * KYBER_SYMBYTES; +pub const KYBER_1024_CIPHERTEXTBYTES: usize = KYBER_1024_INDCPA_BYTES; diff --git a/src/kyber/polyvec.rs b/src/kyber/polyvec.rs index 00b1e9d..1bbdcb8 100644 --- a/src/kyber/polyvec.rs +++ b/src/kyber/polyvec.rs @@ -2,6 +2,63 @@ use super::params::*; use super::poly::*; +#[derive(Clone, Copy)] +pub struct Polyvec512 { + pub vec: [Poly; KYBER_512_K], +} + +impl Polyvec512 { + pub fn new() -> Self { + Polyvec512 { + vec: [Poly::new(); KYBER_512_K], + } + } +} + +impl Default for Polyvec512 { + fn default() -> Self { + Self::new() + } +} + +#[derive(Clone, Copy)] +pub struct Polyvec768 { + pub vec: [Poly; KYBER_768_K], +} + +impl Polyvec768 { + pub fn new() -> Self { + Polyvec768 { + vec: [Poly::new(); KYBER_768_K], + } + } +} + +impl Default for Polyvec768 { + fn default() -> Self { + Self::new() + } +} + +#[derive(Clone, Copy)] +pub struct Polyvec1024 { + pub vec: [Poly; KYBER_1024_K], +} + +impl Polyvec1024 { + pub fn new() -> Self { + Polyvec1024 { + vec: [Poly::new(); KYBER_1024_K], + } + } +} + +impl Default for Polyvec1024 { + fn default() -> Self { + Self::new() + } +} + #[derive(Clone, Copy)] pub struct Polyvec { pub vec: [Poly; KYBER_K], @@ -15,6 +72,202 @@ impl Polyvec { } } +impl Default for Polyvec { + fn default() -> Self { + Self::new() + } +} + +pub fn polyvec_compress_512(r: &mut [u8], a: Polyvec512) { + let mut t = [0u16; 4]; + let mut idx = 0usize; + const K: usize = KYBER_512_K; + for i in 0..K { + for j in 0..KYBER_N / 4 { + for k in 0..4 { + t[k] = a.vec[i].coeffs[4 * j + k] as u16; + t[k] = t[k].wrapping_add((((t[k] as i16) >> 15) & KYBER_Q as i16) as u16); + t[k] = (((((t[k] as u32) << 10) + KYBER_Q as u32 / 2) / KYBER_Q as u32) & 0x3ff) + as u16; + } + r[idx + 0] = (t[0] >> 0) as u8; + r[idx + 1] = ((t[0] >> 8) | (t[1] << 2)) as u8; + r[idx + 2] = ((t[1] >> 6) | (t[2] << 4)) as u8; + r[idx + 3] = ((t[2] >> 4) | (t[3] << 6)) as u8; + r[idx + 4] = (t[3] >> 2) as u8; + idx += 5; + } + } +} + +pub fn polyvec_decompress_512(r: &mut Polyvec512, a: &[u8]) { + let mut idx = 0usize; + let mut t = [0u16; 4]; + const K: usize = KYBER_512_K; + for i in 0..K { + for j in 0..KYBER_N / 4 { + t[0] = (a[idx + 0] >> 0) as u16 | (a[idx + 1] as u16) << 8; + t[1] = (a[idx + 1] >> 2) as u16 | (a[idx + 2] as u16) << 6; + t[2] = (a[idx + 2] >> 4) as u16 | (a[idx + 3] as u16) << 4; + t[3] = (a[idx + 3] >> 6) as u16 | (a[idx + 4] as u16) << 2; + idx += 5; + + for k in 0..4 { + r.vec[i].coeffs[4 * j + k] = + ((((t[k] as u32) & 0x3FF) * KYBER_Q as u32 + 512) >> 10) as i16; + } + } + } +} + +pub fn polyvec_tobytes_512(r: &mut [u8], a: &Polyvec512) { + const K: usize = KYBER_512_K; + for i in 0..K { + poly_tobytes(&mut r[i * KYBER_POLYBYTES..], a.vec[i]); + } +} + +pub fn polyvec_frombytes_512(r: &mut Polyvec512, a: &[u8]) { + const K: usize = KYBER_512_K; + for i in 0..K { + poly_frombytes(&mut r.vec[i], &a[i * KYBER_POLYBYTES..]); + } +} + +pub fn polyvec_ntt_512(r: &mut Polyvec512) { + const K: usize = KYBER_512_K; + for i in 0..K { + poly_ntt(&mut r.vec[i]); + } +} + +pub fn polyvec_invntt_tomont_512(r: &mut Polyvec512) { + const K: usize = KYBER_512_K; + for i in 0..K { + poly_invntt_tomont(&mut r.vec[i]); + } +} + +pub fn polyvec_basemul_acc_montgomery_512(r: &mut Poly, a: &Polyvec512, b: &Polyvec512) { + const K: usize = KYBER_512_K; + let mut t = Poly::new(); + poly_base_multiply(r, &a.vec[0], &b.vec[0]); + for i in 1..K { + poly_base_multiply(&mut t, &a.vec[i], &b.vec[i]); + poly_add(r, &t); + } + poly_reduce(r); +} + +pub fn polyvec_reduce_512(r: &mut Polyvec512) { + const K: usize = KYBER_512_K; + for i in 0..K { + poly_reduce(&mut r.vec[i]); + } +} + +pub fn polyvec_add_512(r: &mut Polyvec512, b: &Polyvec512) { + const K: usize = KYBER_512_K; + for i in 0..K { + poly_add(&mut r.vec[i], &b.vec[i]); + } +} + +pub fn polyvec_compress_1024(r: &mut [u8], a: Polyvec1024) { + let mut t = [0u16; 4]; + let mut idx = 0usize; + const K: usize = KYBER_1024_K; + for i in 0..K { + for j in 0..KYBER_N / 4 { + for k in 0..4 { + t[k] = a.vec[i].coeffs[4 * j + k] as u16; + t[k] = t[k].wrapping_add((((t[k] as i16) >> 15) & KYBER_Q as i16) as u16); + t[k] = (((((t[k] as u32) << 10) + KYBER_Q as u32 / 2) / KYBER_Q as u32) & 0x3ff) + as u16; + } + r[idx + 0] = (t[0] >> 0) as u8; + r[idx + 1] = ((t[0] >> 8) | (t[1] << 2)) as u8; + r[idx + 2] = ((t[1] >> 6) | (t[2] << 4)) as u8; + r[idx + 3] = ((t[2] >> 4) | (t[3] << 6)) as u8; + r[idx + 4] = (t[3] >> 2) as u8; + idx += 5; + } + } +} + +pub fn polyvec_decompress_1024(r: &mut Polyvec1024, a: &[u8]) { + let mut idx = 0usize; + let mut t = [0u16; 4]; + const K: usize = KYBER_1024_K; + for i in 0..K { + for j in 0..KYBER_N / 4 { + t[0] = (a[idx + 0] >> 0) as u16 | (a[idx + 1] as u16) << 8; + t[1] = (a[idx + 1] >> 2) as u16 | (a[idx + 2] as u16) << 6; + t[2] = (a[idx + 2] >> 4) as u16 | (a[idx + 3] as u16) << 4; + t[3] = (a[idx + 3] >> 6) as u16 | (a[idx + 4] as u16) << 2; + idx += 5; + + for k in 0..4 { + r.vec[i].coeffs[4 * j + k] = + ((((t[k] as u32) & 0x3FF) * KYBER_Q as u32 + 512) >> 10) as i16; + } + } + } +} + +pub fn polyvec_tobytes_1024(r: &mut [u8], a: &Polyvec1024) { + const K: usize = KYBER_1024_K; + for i in 0..K { + poly_tobytes(&mut r[i * KYBER_POLYBYTES..], a.vec[i]); + } +} + +pub fn polyvec_frombytes_1024(r: &mut Polyvec1024, a: &[u8]) { + const K: usize = KYBER_1024_K; + for i in 0..K { + poly_frombytes(&mut r.vec[i], &a[i * KYBER_POLYBYTES..]); + } +} + +pub fn polyvec_ntt_1024(r: &mut Polyvec1024) { + const K: usize = KYBER_1024_K; + for i in 0..K { + poly_ntt(&mut r.vec[i]); + } +} + +pub fn polyvec_invntt_tomont_1024(r: &mut Polyvec1024) { + const K: usize = KYBER_1024_K; + for i in 0..K { + poly_invntt_tomont(&mut r.vec[i]); + } +} + +pub fn polyvec_basemul_acc_montgomery_1024(r: &mut Poly, a: &Polyvec1024, b: &Polyvec1024) { + const K: usize = KYBER_1024_K; + let mut t = Poly::new(); + poly_base_multiply(r, &a.vec[0], &b.vec[0]); + for i in 1..K { + poly_base_multiply(&mut t, &a.vec[i], &b.vec[i]); + poly_add(r, &t); + } + poly_reduce(r); +} + +pub fn polyvec_reduce_1024(r: &mut Polyvec1024) { + const K: usize = KYBER_1024_K; + for i in 0..K { + poly_reduce(&mut r.vec[i]); + } +} + +pub fn polyvec_add_1024(r: &mut Polyvec1024, b: &Polyvec1024) { + const K: usize = KYBER_1024_K; + for i in 0..K { + poly_add(&mut r.vec[i], &b.vec[i]); + } +} + pub fn polyvec_compress(r: &mut [u8], a: Polyvec) { let mut t = [0u16; 4]; let mut idx = 0usize; diff --git a/src/lib.rs b/src/lib.rs index 2dbd87f..cb12aac 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,6 +1,11 @@ pub mod kyber; -use kyber::{decapsulate, encapsulate, keypair}; +use kyber::{ + crypto_kem_dec_1024, crypto_kem_dec_512, crypto_kem_enc_1024, crypto_kem_enc_512, + crypto_kem_keypair_1024, crypto_kem_keypair_512, decapsulate, encapsulate, keypair, + KYBER_1024_CIPHERTEXTBYTES, KYBER_1024_PUBLICKEYBYTES, KYBER_1024_SECRETKEYBYTES, + KYBER_512_CIPHERTEXTBYTES, KYBER_512_PUBLICKEYBYTES, KYBER_512_SECRETKEYBYTES, +}; use pyo3::prelude::*; use rand::thread_rng; @@ -47,6 +52,80 @@ fn decapsulate_key(ct: &[u8], sk: &[u8]) -> PyResult> { } } +/// Generate a Kyber-512 keypair. +/// Returns (public_key, secret_key). +#[pyfunction] +fn generate_keypair_512() -> PyResult<(Vec, Vec)> { + let mut rng = thread_rng(); + let mut pk = vec![0u8; KYBER_512_PUBLICKEYBYTES]; + let mut sk = vec![0u8; KYBER_512_SECRETKEYBYTES]; + match crypto_kem_keypair_512(&mut pk, &mut sk, &mut rng, None) { + Ok(()) => Ok((pk, sk)), + Err(e) => Err(PyErr::new::( + e.to_string(), + )), + } +} + +/// Generate a Kyber-1024 keypair. +/// Returns (public_key, secret_key). +#[pyfunction] +fn generate_keypair_1024() -> PyResult<(Vec, Vec)> { + let mut rng = thread_rng(); + let mut pk = vec![0u8; KYBER_1024_PUBLICKEYBYTES]; + let mut sk = vec![0u8; KYBER_1024_SECRETKEYBYTES]; + match crypto_kem_keypair_1024(&mut pk, &mut sk, &mut rng, None) { + Ok(()) => Ok((pk, sk)), + Err(e) => Err(PyErr::new::( + e.to_string(), + )), + } +} + +/// Encapsulate a shared secret using a Kyber-512 public key. +#[pyfunction] +fn encapsulate_key_512(pk: &[u8]) -> PyResult<(Vec, Vec)> { + let mut rng = thread_rng(); + let mut ct = vec![0u8; KYBER_512_CIPHERTEXTBYTES]; + let mut ss = vec![0u8; 32]; + match crypto_kem_enc_512(&mut ct, &mut ss, pk, &mut rng, None) { + Ok(()) => Ok((ct, ss)), + Err(e) => Err(PyErr::new::( + e.to_string(), + )), + } +} + +/// Encapsulate a shared secret using a Kyber-1024 public key. +#[pyfunction] +fn encapsulate_key_1024(pk: &[u8]) -> PyResult<(Vec, Vec)> { + let mut rng = thread_rng(); + let mut ct = vec![0u8; KYBER_1024_CIPHERTEXTBYTES]; + let mut ss = vec![0u8; 32]; + match crypto_kem_enc_1024(&mut ct, &mut ss, pk, &mut rng, None) { + Ok(()) => Ok((ct, ss)), + Err(e) => Err(PyErr::new::( + e.to_string(), + )), + } +} + +/// Decapsulate a shared secret using a Kyber-512 ciphertext and secret key. +#[pyfunction] +fn decapsulate_key_512(ct: &[u8], sk: &[u8]) -> PyResult> { + let mut ss = vec![0u8; 32]; + crypto_kem_dec_512(&mut ss, ct, sk); + Ok(ss) +} + +/// Decapsulate a shared secret using a Kyber-1024 ciphertext and secret key. +#[pyfunction] +fn decapsulate_key_1024(ct: &[u8], sk: &[u8]) -> PyResult> { + let mut ss = vec![0u8; 32]; + crypto_kem_dec_1024(&mut ss, ct, sk); + Ok(ss) +} + #[cfg(test)] mod tests { use super::*; @@ -302,7 +381,7 @@ mod _pykyber { #[pyfunction] pub fn _keypair_512() -> PyResult<(Vec, Vec)> { - super::generate_keypair() + super::generate_keypair_512() } #[pyfunction] @@ -312,12 +391,12 @@ mod _pykyber { #[pyfunction] pub fn _keypair_1024() -> PyResult<(Vec, Vec)> { - super::generate_keypair() + super::generate_keypair_1024() } #[pyfunction] pub fn _encapsulate_512(pk: &[u8]) -> PyResult<(Vec, Vec)> { - super::encapsulate_key(pk) + super::encapsulate_key_512(pk) } #[pyfunction] @@ -327,12 +406,12 @@ mod _pykyber { #[pyfunction] pub fn _encapsulate_1024(pk: &[u8]) -> PyResult<(Vec, Vec)> { - super::encapsulate_key(pk) + super::encapsulate_key_1024(pk) } #[pyfunction] pub fn _decapsulate_512(ct: &[u8], sk: &[u8]) -> PyResult> { - super::decapsulate_key(ct, sk) + super::decapsulate_key_512(ct, sk) } #[pyfunction] @@ -342,6 +421,6 @@ mod _pykyber { #[pyfunction] pub fn _decapsulate_1024(ct: &[u8], sk: &[u8]) -> PyResult> { - super::decapsulate_key(ct, sk) + super::decapsulate_key_1024(ct, sk) } } From 1ff327454eb85cba087f4f7aab40af5326da40a1 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 21 Feb 2026 00:19:53 +0200 Subject: [PATCH 11/47] Better rust testing --- Cargo.toml | 7 +- src/lib.rs | 234 --------------------------------------- tests/api_kem.rs | 225 +++++++++++++++++++++++++++++++++++++ tests/integration_kem.rs | 192 ++++++++++++++++++++++++++++++++ tests/unit_params.rs | 55 +++++++++ 5 files changed, 477 insertions(+), 236 deletions(-) create mode 100644 tests/api_kem.rs create mode 100644 tests/integration_kem.rs create mode 100644 tests/unit_params.rs diff --git a/Cargo.toml b/Cargo.toml index 8b84fde..3685186 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,14 +4,17 @@ version = "0.1.0" edition = "2021" [lib] -name = "_pykyber" -crate-type = ["cdylib"] +name = "pykyber" +crate-type = ["lib", "cdylib"] [dependencies] pyo3 = "0.27.0" rand = "0.8" rand_core = "0.6" +[dev-dependencies] +rand = "0.8" + [profile.dev] opt-level = 0 diff --git a/src/lib.rs b/src/lib.rs index cb12aac..253e8f4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -126,240 +126,6 @@ fn decapsulate_key_1024(ct: &[u8], sk: &[u8]) -> PyResult> { Ok(ss) } -#[cfg(test)] -mod tests { - use super::*; - use kyber::api::{derive, public}; - use kyber::params::*; - - #[test] - fn test_keypair_generation() { - let mut rng = thread_rng(); - let result = keypair(&mut rng); - assert!(result.is_ok()); - let keys = result.unwrap(); - assert_eq!(keys.public.len(), KYBER_PUBLICKEYBYTES); - assert_eq!(keys.secret.len(), KYBER_SECRETKEYBYTES); - } - - #[test] - fn test_encapsulate_decapsulate() { - let mut rng = thread_rng(); - let keys = keypair(&mut rng).unwrap(); - - let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); - assert_eq!(ct.len(), KYBER_CIPHERTEXTBYTES); - assert_eq!(ss.len(), KYBER_SSBYTES); - - let ss2 = decapsulate(&ct, &keys.secret).unwrap(); - assert_eq!(ss, ss2); - } - - #[test] - fn test_invalid_public_key_length() { - let result = encapsulate(b"short", &mut thread_rng()); - assert!(result.is_err()); - } - - #[test] - fn test_invalid_ciphertext_length() { - let result = decapsulate(b"short", &[0u8; KYBER_SECRETKEYBYTES]); - assert!(result.is_err()); - } - - #[test] - fn test_invalid_secret_key_length() { - let result = decapsulate(&[0u8; KYBER_CIPHERTEXTBYTES], b"short"); - assert!(result.is_err()); - } - - #[test] - fn test_different_keypairs_produce_different_secrets() { - let keys1 = keypair(&mut thread_rng()).unwrap(); - let keys2 = keypair(&mut thread_rng()).unwrap(); - - let (ct1, ss1) = encapsulate(&keys1.public, &mut thread_rng()).unwrap(); - let (ct2, ss2) = encapsulate(&keys2.public, &mut thread_rng()).unwrap(); - - let ss1_dec = decapsulate(&ct1, &keys1.secret).unwrap(); - let ss2_dec = decapsulate(&ct2, &keys2.secret).unwrap(); - - assert_eq!(ss1, ss1_dec); - assert_eq!(ss2, ss2_dec); - assert_ne!(ss1, ss2); - } - - #[test] - fn test_wrong_secret_key_fails() { - let keys = keypair(&mut thread_rng()).unwrap(); - let wrong_keys = keypair(&mut thread_rng()).unwrap(); - - let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); - let ss_wrong = decapsulate(&ct, &wrong_keys.secret).unwrap(); - - assert_ne!(ss, ss_wrong); - } - - #[test] - fn test_keypair_struct() { - let keys = kyber::api::keypair(&mut thread_rng()).unwrap(); - assert_eq!(keys.public.len(), KYBER_PUBLICKEYBYTES); - assert_eq!(keys.secret.len(), KYBER_SECRETKEYBYTES); - } - - #[test] - fn test_keypair_generate_method() { - let keys = kyber::api::Keypair::generate(&mut thread_rng()).unwrap(); - assert_eq!(keys.public.len(), KYBER_PUBLICKEYBYTES); - assert_eq!(keys.secret.len(), KYBER_SECRETKEYBYTES); - } - - #[test] - fn test_derive_keypair() { - let seed = [0u8; 64]; - let result = derive(&seed); - assert!(result.is_ok()); - let keys = result.unwrap(); - assert_eq!(keys.public.len(), KYBER_PUBLICKEYBYTES); - assert_eq!(keys.secret.len(), KYBER_SECRETKEYBYTES); - } - - #[test] - fn test_derive_invalid_seed_length() { - let seed = [0u8; 32]; - let result = derive(&seed); - assert!(result.is_err()); - } - - #[test] - fn test_public_key_extraction() { - let keys = keypair(&mut thread_rng()).unwrap(); - let extracted_pub = public(&keys.secret); - assert_eq!(extracted_pub.len(), KYBER_INDCPA_PUBLICKEYBYTES); - } - - #[test] - fn test_empty_public_key() { - let result = encapsulate(&[], &mut thread_rng()); - assert!(result.is_err()); - } - - #[test] - fn test_empty_ciphertext() { - let keys = keypair(&mut thread_rng()).unwrap(); - let result = decapsulate(&[], &keys.secret); - assert!(result.is_err()); - } - - #[test] - fn test_empty_secret_key() { - let keys = keypair(&mut thread_rng()).unwrap(); - let (ct, _) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); - let result = decapsulate(&ct, &[]); - assert!(result.is_err()); - } - - #[test] - fn test_multiple_encapsulations_same_pk() { - let keys = keypair(&mut thread_rng()).unwrap(); - - // Test multiple encapsulations - let mut ciphertexts = Vec::new(); - let mut secrets = Vec::new(); - - for _ in 0..5 { - let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); - ciphertexts.push(ct); - secrets.push(ss); - } - - // All ciphertexts should be different (random) - let mut all_different = false; - for i in 0..ciphertexts.len() { - for j in 0..i { - if ciphertexts[i] != ciphertexts[j] { - all_different = true; - } - } - } - assert!(all_different); - - // But all should decapsulate correctly - for (ct, ss) in ciphertexts.iter().zip(secrets.iter()) { - let decapsulated = decapsulate(ct, &keys.secret).unwrap(); - assert_eq!(*ss, decapsulated); - } - } - - #[test] - fn test_deterministic_decapsulation() { - let keys = keypair(&mut thread_rng()).unwrap(); - let (ct, _) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); - - let ss1 = decapsulate(&ct, &keys.secret).unwrap(); - let ss2 = decapsulate(&ct, &keys.secret).unwrap(); - let ss3 = decapsulate(&ct, &keys.secret).unwrap(); - - assert_eq!(ss1, ss2); - assert_eq!(ss2, ss3); - } - - #[test] - fn test_all_zero_keypair() { - let mut rng = thread_rng(); - let keys = keypair(&mut rng).unwrap(); - - // Keys should not be all zeros - assert!(keys.public.iter().any(|&x| x != 0)); - assert!(keys.secret.iter().any(|&x| x != 0)); - } - - #[test] - fn test_shared_secret_all_zeros() { - let keys = keypair(&mut thread_rng()).unwrap(); - let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); - - // Shared secret should not be all zeros - assert!(ss.iter().any(|&x| x != 0)); - - // Decapsulated should also not be all zeros - let ss2 = decapsulate(&ct, &keys.secret).unwrap(); - assert!(ss2.iter().any(|&x| x != 0)); - } - - #[test] - fn test_boundary_public_key_length() { - // Test with public key that's 1 byte too short - let keys = keypair(&mut thread_rng()).unwrap(); - let mut short_pk = keys.public.to_vec(); - short_pk.pop(); - - let result = encapsulate(&short_pk, &mut thread_rng()); - assert!(result.is_err()); - } - - #[test] - fn test_boundary_secret_key_length() { - let keys = keypair(&mut thread_rng()).unwrap(); - let (ct, _) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); - - let mut short_sk = keys.secret.to_vec(); - short_sk.pop(); - - let result = decapsulate(&ct, &short_sk); - assert!(result.is_err()); - } - - #[test] - fn test_boundary_ciphertext_length() { - let keys = keypair(&mut thread_rng()).unwrap(); - let short_ct = vec![0u8; KYBER_CIPHERTEXTBYTES - 1]; - - let result = decapsulate(&short_ct, &keys.secret); - assert!(result.is_err()); - } -} - #[pymodule] mod _pykyber { use pyo3::prelude::*; diff --git a/tests/api_kem.rs b/tests/api_kem.rs new file mode 100644 index 0000000..508419b --- /dev/null +++ b/tests/api_kem.rs @@ -0,0 +1,225 @@ +//! API tests for Kyber KEM - equivalent to src/lib.rs tests + +use pykyber::kyber::api::{decapsulate, derive, encapsulate, keypair, public, Keypair}; +use pykyber::kyber::params::*; +use rand::thread_rng; + +#[test] +fn test_keypair_generation() { + let mut rng = thread_rng(); + let result = keypair(&mut rng); + assert!(result.is_ok()); + let keys = result.unwrap(); + assert_eq!(keys.public.len(), KYBER_PUBLICKEYBYTES); + assert_eq!(keys.secret.len(), KYBER_SECRETKEYBYTES); +} + +#[test] +fn test_encapsulate_decapsulate() { + let mut rng = thread_rng(); + let keys = keypair(&mut rng).unwrap(); + + let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + assert_eq!(ct.len(), KYBER_CIPHERTEXTBYTES); + assert_eq!(ss.len(), KYBER_SSBYTES); + + let ss2 = decapsulate(&ct, &keys.secret).unwrap(); + assert_eq!(ss, ss2); +} + +#[test] +fn test_invalid_public_key_length() { + let result = encapsulate(b"short", &mut thread_rng()); + assert!(result.is_err()); +} + +#[test] +fn test_invalid_ciphertext_length() { + let result = decapsulate(b"short", &[0u8; KYBER_SECRETKEYBYTES]); + assert!(result.is_err()); +} + +#[test] +fn test_invalid_secret_key_length() { + let result = decapsulate(&[0u8; KYBER_CIPHERTEXTBYTES], b"short"); + assert!(result.is_err()); +} + +#[test] +fn test_different_keypairs_produce_different_secrets() { + let keys1 = keypair(&mut thread_rng()).unwrap(); + let keys2 = keypair(&mut thread_rng()).unwrap(); + + let (ct1, ss1) = encapsulate(&keys1.public, &mut thread_rng()).unwrap(); + let (ct2, ss2) = encapsulate(&keys2.public, &mut thread_rng()).unwrap(); + + let ss1_dec = decapsulate(&ct1, &keys1.secret).unwrap(); + let ss2_dec = decapsulate(&ct2, &keys2.secret).unwrap(); + + assert_eq!(ss1, ss1_dec); + assert_eq!(ss2, ss2_dec); + assert_ne!(ss1, ss2); +} + +#[test] +fn test_wrong_secret_key_fails() { + let keys = keypair(&mut thread_rng()).unwrap(); + let wrong_keys = keypair(&mut thread_rng()).unwrap(); + + let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + let ss_wrong = decapsulate(&ct, &wrong_keys.secret).unwrap(); + + assert_ne!(ss, ss_wrong); +} + +#[test] +fn test_keypair_struct() { + let keys = keypair(&mut thread_rng()).unwrap(); + assert_eq!(keys.public.len(), KYBER_PUBLICKEYBYTES); + assert_eq!(keys.secret.len(), KYBER_SECRETKEYBYTES); +} + +#[test] +fn test_keypair_generate_method() { + let keys = Keypair::generate(&mut thread_rng()).unwrap(); + assert_eq!(keys.public.len(), KYBER_PUBLICKEYBYTES); + assert_eq!(keys.secret.len(), KYBER_SECRETKEYBYTES); +} + +#[test] +fn test_derive_keypair() { + let seed = [0u8; 64]; + let result = derive(&seed); + assert!(result.is_ok()); + let keys = result.unwrap(); + assert_eq!(keys.public.len(), KYBER_PUBLICKEYBYTES); + assert_eq!(keys.secret.len(), KYBER_SECRETKEYBYTES); +} + +#[test] +fn test_derive_invalid_seed_length() { + let seed = [0u8; 32]; + let result = derive(&seed); + assert!(result.is_err()); +} + +#[test] +fn test_public_key_extraction() { + let keys = keypair(&mut thread_rng()).unwrap(); + let extracted_pub = public(&keys.secret); + assert_eq!(extracted_pub.len(), KYBER_INDCPA_PUBLICKEYBYTES); +} + +#[test] +fn test_empty_public_key() { + let result = encapsulate(&[], &mut thread_rng()); + assert!(result.is_err()); +} + +#[test] +fn test_empty_ciphertext() { + let keys = keypair(&mut thread_rng()).unwrap(); + let result = decapsulate(&[], &keys.secret); + assert!(result.is_err()); +} + +#[test] +fn test_empty_secret_key() { + let keys = keypair(&mut thread_rng()).unwrap(); + let (ct, _) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + let result = decapsulate(&ct, &[]); + assert!(result.is_err()); +} + +#[test] +fn test_multiple_encapsulations_same_pk() { + let keys = keypair(&mut thread_rng()).unwrap(); + + let mut ciphertexts = Vec::new(); + let mut secrets = Vec::new(); + + for _ in 0..5 { + let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + ciphertexts.push(ct); + secrets.push(ss); + } + + let mut all_different = false; + for i in 0..ciphertexts.len() { + for j in 0..i { + if ciphertexts[i] != ciphertexts[j] { + all_different = true; + } + } + } + assert!(all_different); + + for (ct, ss) in ciphertexts.iter().zip(secrets.iter()) { + let decapsulated = decapsulate(ct, &keys.secret).unwrap(); + assert_eq!(*ss, decapsulated); + } +} + +#[test] +fn test_deterministic_decapsulation() { + let keys = keypair(&mut thread_rng()).unwrap(); + let (ct, _) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + + let ss1 = decapsulate(&ct, &keys.secret).unwrap(); + let ss2 = decapsulate(&ct, &keys.secret).unwrap(); + let ss3 = decapsulate(&ct, &keys.secret).unwrap(); + + assert_eq!(ss1, ss2); + assert_eq!(ss2, ss3); +} + +#[test] +fn test_all_zero_keypair() { + let mut rng = thread_rng(); + let keys = keypair(&mut rng).unwrap(); + + assert!(keys.public.iter().any(|&x| x != 0)); + assert!(keys.secret.iter().any(|&x| x != 0)); +} + +#[test] +fn test_shared_secret_all_zeros() { + let keys = keypair(&mut thread_rng()).unwrap(); + let (ct, ss) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + + assert!(ss.iter().any(|&x| x != 0)); + + let ss2 = decapsulate(&ct, &keys.secret).unwrap(); + assert!(ss2.iter().any(|&x| x != 0)); +} + +#[test] +fn test_boundary_public_key_length() { + let keys = keypair(&mut thread_rng()).unwrap(); + let mut short_pk = keys.public.to_vec(); + short_pk.pop(); + + let result = encapsulate(&short_pk, &mut thread_rng()); + assert!(result.is_err()); +} + +#[test] +fn test_boundary_secret_key_length() { + let keys = keypair(&mut thread_rng()).unwrap(); + let (ct, _) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + + let mut short_sk = keys.secret.to_vec(); + short_sk.pop(); + + let result = decapsulate(&ct, &short_sk); + assert!(result.is_err()); +} + +#[test] +fn test_boundary_ciphertext_length() { + let keys = keypair(&mut thread_rng()).unwrap(); + let short_ct = vec![0u8; KYBER_CIPHERTEXTBYTES - 1]; + + let result = decapsulate(&short_ct, &keys.secret); + assert!(result.is_err()); +} diff --git a/tests/integration_kem.rs b/tests/integration_kem.rs new file mode 100644 index 0000000..c8b222f --- /dev/null +++ b/tests/integration_kem.rs @@ -0,0 +1,192 @@ +//! Integration tests for Kyber KEM + +use pykyber::kyber::api::{decapsulate, encapsulate, keypair, Keypair}; +use pykyber::kyber::crypto_kem_dec_1024; +use pykyber::kyber::crypto_kem_dec_512; +use pykyber::kyber::crypto_kem_enc_1024; +use pykyber::kyber::crypto_kem_enc_512; +use pykyber::kyber::crypto_kem_keypair_1024; +use pykyber::kyber::crypto_kem_keypair_512; +use pykyber::kyber::params::*; +use rand::thread_rng; + +#[test] +fn test_kyber_512_keypair_sizes() { + let mut rng = thread_rng(); + let mut pk = vec![0u8; KYBER_512_PUBLICKEYBYTES]; + let mut sk = vec![0u8; KYBER_512_SECRETKEYBYTES]; + crypto_kem_keypair_512(&mut pk, &mut sk, &mut rng, None).unwrap(); + + assert_eq!(pk.len(), KYBER_512_PUBLICKEYBYTES); + assert_eq!(sk.len(), KYBER_512_SECRETKEYBYTES); +} + +#[test] +fn test_kyber_768_keypair_sizes() { + let mut rng = thread_rng(); + let keys = keypair(&mut rng).unwrap(); + + assert_eq!(keys.public.len(), KYBER_768_PUBLICKEYBYTES); + assert_eq!(keys.secret.len(), KYBER_768_SECRETKEYBYTES); +} + +#[test] +fn test_kyber_1024_keypair_sizes() { + let mut rng = thread_rng(); + let mut pk = vec![0u8; KYBER_1024_PUBLICKEYBYTES]; + let mut sk = vec![0u8; KYBER_1024_SECRETKEYBYTES]; + crypto_kem_keypair_1024(&mut pk, &mut sk, &mut rng, None).unwrap(); + + assert_eq!(pk.len(), KYBER_1024_PUBLICKEYBYTES); + assert_eq!(sk.len(), KYBER_1024_SECRETKEYBYTES); +} + +#[test] +fn test_kyber_512_encapsulate_decapsulate() { + let mut rng = thread_rng(); + let mut pk = vec![0u8; KYBER_512_PUBLICKEYBYTES]; + let mut sk = vec![0u8; KYBER_512_SECRETKEYBYTES]; + crypto_kem_keypair_512(&mut pk, &mut sk, &mut rng, None).unwrap(); + + let mut ct = vec![0u8; KYBER_512_CIPHERTEXTBYTES]; + let mut ss = vec![0u8; KYBER_SSBYTES]; + crypto_kem_enc_512(&mut ct, &mut ss, &pk, &mut rng, None).unwrap(); + + assert_eq!(ct.len(), KYBER_512_CIPHERTEXTBYTES); + assert_eq!(ss.len(), KYBER_SSBYTES); + + let mut ss2 = vec![0u8; KYBER_SSBYTES]; + crypto_kem_dec_512(&mut ss2, &ct, &sk); + assert_eq!(ss, ss2); +} + +#[test] +fn test_kyber_768_encapsulate_decapsulate() { + let mut rng = thread_rng(); + let keys = keypair(&mut rng).unwrap(); + + let (ct, ss) = encapsulate(&keys.public, &mut rng).unwrap(); + assert_eq!(ct.len(), KYBER_768_CIPHERTEXTBYTES); + assert_eq!(ss.len(), KYBER_SSBYTES); + + let ss2 = decapsulate(&ct, &keys.secret).unwrap(); + assert_eq!(ss.to_vec(), ss2.to_vec()); +} + +#[test] +fn test_kyber_1024_encapsulate_decapsulate() { + let mut rng = thread_rng(); + let mut pk = vec![0u8; KYBER_1024_PUBLICKEYBYTES]; + let mut sk = vec![0u8; KYBER_1024_SECRETKEYBYTES]; + crypto_kem_keypair_1024(&mut pk, &mut sk, &mut rng, None).unwrap(); + + let mut ct = vec![0u8; KYBER_1024_CIPHERTEXTBYTES]; + let mut ss = vec![0u8; KYBER_SSBYTES]; + crypto_kem_enc_1024(&mut ct, &mut ss, &pk, &mut rng, None).unwrap(); + + assert_eq!(ct.len(), KYBER_1024_CIPHERTEXTBYTES); + assert_eq!(ss.len(), KYBER_SSBYTES); + + let mut ss2 = vec![0u8; KYBER_SSBYTES]; + crypto_kem_dec_1024(&mut ss2, &ct, &sk); + assert_eq!(ss, ss2); +} + +#[test] +fn test_different_keypairs_produce_different_secrets() { + let mut rng = thread_rng(); + let keys1 = keypair(&mut rng).unwrap(); + let keys2 = keypair(&mut rng).unwrap(); + + let (ct1, ss1) = encapsulate(&keys1.public, &mut rng).unwrap(); + let (ct2, ss2) = encapsulate(&keys2.public, &mut rng).unwrap(); + + let ss1_dec = decapsulate(&ct1, &keys1.secret).unwrap(); + let ss2_dec = decapsulate(&ct2, &keys2.secret).unwrap(); + + assert_eq!(ss1.to_vec(), ss1_dec.to_vec()); + assert_eq!(ss2.to_vec(), ss2_dec.to_vec()); + assert_ne!(ss1.to_vec(), ss2.to_vec()); +} + +#[test] +fn test_wrong_key_fails() { + let mut rng = thread_rng(); + let keys = keypair(&mut rng).unwrap(); + let wrong_keys = keypair(&mut rng).unwrap(); + + let (ct, ss) = encapsulate(&keys.public, &mut rng).unwrap(); + let ss_wrong = decapsulate(&ct, &wrong_keys.secret).unwrap(); + + assert_ne!(ss.to_vec(), ss_wrong.to_vec()); +} + +#[test] +fn test_decapsulation_is_deterministic() { + let mut rng = thread_rng(); + let keys = keypair(&mut rng).unwrap(); + + let (ct, _) = encapsulate(&keys.public, &mut rng).unwrap(); + + for _ in 0..5 { + let ss = decapsulate(&ct, &keys.secret).unwrap(); + assert_eq!( + ss.to_vec(), + decapsulate(&ct, &keys.secret).unwrap().to_vec(), + "decapsulation should be deterministic" + ); + } +} + +#[test] +fn test_invalid_public_key_length() { + let result = encapsulate(b"short", &mut thread_rng()); + assert!(result.is_err()); +} + +#[test] +fn test_invalid_ciphertext_length() { + let keys = keypair(&mut thread_rng()).unwrap(); + let result = decapsulate(b"short", &keys.secret); + assert!(result.is_err()); +} + +#[test] +fn test_invalid_secret_key_length() { + let keys = keypair(&mut thread_rng()).unwrap(); + let (ct, _) = encapsulate(&keys.public, &mut thread_rng()).unwrap(); + let result = decapsulate(&ct, b"short"); + assert!(result.is_err()); +} + +#[test] +fn test_empty_public_key() { + let result = encapsulate(&[], &mut thread_rng()); + assert!(result.is_err()); +} + +#[test] +fn test_empty_ciphertext() { + let keys = keypair(&mut thread_rng()).unwrap(); + let result = decapsulate(&[], &keys.secret); + assert!(result.is_err()); +} + +#[test] +fn test_keypair_not_all_zeros() { + let keys = keypair(&mut thread_rng()).unwrap(); + assert!(keys.public.iter().any(|&x| x != 0)); + assert!(keys.secret.iter().any(|&x| x != 0)); +} + +#[test] +fn test_shared_secret_not_all_zeros() { + let mut rng = thread_rng(); + let keys = keypair(&mut rng).unwrap(); + let (ct, ss) = encapsulate(&keys.public, &mut rng).unwrap(); + + assert!(ss.iter().any(|&x| x != 0)); + + let ss2 = decapsulate(&ct, &keys.secret).unwrap(); + assert!(ss2.iter().any(|&x| x != 0)); +} diff --git a/tests/unit_params.rs b/tests/unit_params.rs new file mode 100644 index 0000000..ee39958 --- /dev/null +++ b/tests/unit_params.rs @@ -0,0 +1,55 @@ +//! Unit tests for Kyber parameters + +use pykyber::kyber::params::*; + +#[test] +fn test_kyber_512_params() { + assert_eq!(KYBER_512_K, 2); + assert_eq!(KYBER_512_POLYVECBYTES, 2 * 384); + assert_eq!(KYBER_512_POLYVECCOMPRESSEDBYTES, 2 * 320); + assert_eq!(KYBER_512_INDCPA_PUBLICKEYBYTES, 2 * 384 + 32); + assert_eq!(KYBER_512_PUBLICKEYBYTES, 800); + assert_eq!(KYBER_512_SECRETKEYBYTES, 2 * 384 + (2 * 384 + 32) + 2 * 32); + assert_eq!(KYBER_512_CIPHERTEXTBYTES, 2 * 320 + 128); +} + +#[test] +fn test_kyber_768_params() { + assert_eq!(KYBER_768_K, 3); + assert_eq!(KYBER_768_POLYVECBYTES, 3 * 384); + assert_eq!(KYBER_768_POLYVECCOMPRESSEDBYTES, 3 * 320); + assert_eq!(KYBER_768_INDCPA_PUBLICKEYBYTES, 3 * 384 + 32); + assert_eq!(KYBER_768_PUBLICKEYBYTES, 1184); + assert_eq!(KYBER_768_SECRETKEYBYTES, 3 * 384 + (3 * 384 + 32) + 2 * 32); + assert_eq!(KYBER_768_CIPHERTEXTBYTES, 3 * 320 + 128); +} + +#[test] +fn test_kyber_1024_params() { + assert_eq!(KYBER_1024_K, 4); + assert_eq!(KYBER_1024_POLYVECBYTES, 4 * 384); + assert_eq!(KYBER_1024_POLYVECCOMPRESSEDBYTES, 4 * 320); + assert_eq!(KYBER_1024_INDCPA_PUBLICKEYBYTES, 4 * 384 + 32); + assert_eq!(KYBER_1024_PUBLICKEYBYTES, 1568); + assert_eq!(KYBER_1024_SECRETKEYBYTES, 4 * 384 + (4 * 384 + 32) + 2 * 32); + assert_eq!(KYBER_1024_CIPHERTEXTBYTES, 4 * 320 + 128); +} + +#[test] +fn test_common_params() { + assert_eq!(KYBER_N, 256); + assert_eq!(KYBER_Q, 3329); + assert_eq!(KYBER_ETA1, 2); + assert_eq!(KYBER_ETA2, 2); + assert_eq!(KYBER_SYMBYTES, 32); + assert_eq!(KYBER_SSBYTES, 32); + assert_eq!(KYBER_POLYBYTES, 384); + assert_eq!(KYBER_POLYCOMPRESSEDBYTES, 128); +} + +#[test] +fn test_default_kyber_k() { + assert_eq!(KYBER_K, 3); + assert_eq!(KYBER_POLYVECBYTES, KYBER_K * KYBER_POLYBYTES); + assert_eq!(KYBER_PUBLICKEYBYTES, KYBER_INDCPA_PUBLICKEYBYTES); +} From fca21b10406ac05f2739c7f1a29ef2e748a3eda7 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 21 Feb 2026 00:30:34 +0200 Subject: [PATCH 12/47] Better README.md --- README.md | 122 +++++++++++++----------------------------------------- 1 file changed, 28 insertions(+), 94 deletions(-) diff --git a/README.md b/README.md index 9ed1754..d43a81d 100644 --- a/README.md +++ b/README.md @@ -8,125 +8,59 @@ A Python library for Kyber post-quantum key encapsulation, implemented in Rust. pip install pykyber ``` -Or for development: - -```bash -pip install maturin -maturin develop -``` - ## Quick Start ```python import pykyber -# Generate a keypair -keypair = pykyber.Kyber768KeyPair.generate() - -# Encapsulate (create shared secret) -ciphertext, shared_secret = keypair.encapsulate() - -# Decapsulate (recover shared secret) -shared_secret2 = keypair.decapsulate(ciphertext) - -print(f"Shared secrets match: {shared_secret == shared_secret2}") -``` - -## API Reference - -### Classes - -#### Kyber768KeyPair, Kyber512KeyPair, Kyber1024KeyPair - -Key pair classes with methods for encapsulation/decapsulation. +# Generate a keypair (Alice) +alice_keypair = pykyber.Kyber768() -```python -# Generate a new keypair -keypair = pykyber.Kyber768KeyPair.generate() - -# Or from existing keys -keypair = pykyber.Kyber768KeyPair.from_bytes(public_key, secret_key) +# Encapsulate - create shared secret (Bob) +bob_result = pykyber.Kyber768.encapsulate(alice_keypair.public_key) -# Encapsulate - returns (ciphertext, shared_secret) -ciphertext, shared_secret = keypair.encapsulate() +# Decapsulate - recover shared secret (Alice) +shared_secret = alice_keypair.decapsulate(bob_result.ciphertext) -# Decapsulate -shared_secret = keypair.decapsulate(ciphertext) +# Both parties now share the same secret +print(f"Match: {bob_result.shared_secret == shared_secret}") ``` -#### Kyber, Kyber512, Kyber768, Kyber1024 - -Module-level functions for each security level. - -```python -# Generate keypair -public_key, secret_key = pykyber.Kyber.generate_keypair() - -# Or for specific variant -public_key, secret_key = pykyber.Kyber512.generate_keypair() -public_key, secret_key = pykyber.Kyber768.generate_keypair() -public_key, secret_key = pykyber.Kyber1024.generate_keypair() - -# Encapsulate -ciphertext, shared_secret = pykyber.Kyber.encapsulate(public_key) - -# Decapsulate -shared_secret = pykyber.Kyber.decapsulate(ciphertext, secret_key) -``` +## API Usage -### Functions +### Class-based API (Recommended) -The raw functions are also available directly: +The simplest way to use Kyber: ```python import pykyber -# Generate keypair (Kyber768 by default) -public_key, secret_key = pykyber.generate_keypair() +# Create a keypair - instant generation on class instantiation +keypair = pykyber.Kyber512() # ~AES-128 security +keypair = pykyber.Kyber768() # ~AES-192 security +keypair = pykyber.Kyber1024() # ~AES-256 security -# Or specific variants -public_key, secret_key = pykyber.keypair_512() -public_key, secret_key = pykyber.keypair_768() -public_key, secret_key = pykyber.keypair_1024() +# Access raw key bytes +public_key = keypair.public_key # bytes +secret_key = keypair.secret_key # bytes -# Encapsulate -ciphertext, shared_secret = pykyber.encapsulate(public_key) +# Encapsulate - create ciphertext and shared secret +result = keypair.encapsulate() +# result.ciphertext - bytes to send to receiver +# result.shared_secret - 32 bytes shared secret -# Decapsulate -shared_secret = pykyber.decapsulate(ciphertext, secret_key) +# Decapsulate - recover shared secret from ciphertext +shared_secret = keypair.decapsulate(result.ciphertext) ``` -### Key Sizes +## Key Sizes -| Variant | Public Key | Secret Key | Ciphertext | Shared Secret | -|----------|------------|------------|------------|---------------| +| Variant | Public Key | Secret Key | Ciphertext | Shared Secret | +|-----------|------------|------------|------------|---------------| | Kyber-512 | 800 bytes | 1632 bytes | 768 bytes | 32 bytes | | Kyber-768 | 1184 bytes | 2400 bytes | 1088 bytes | 32 bytes | -| Kyber-1024 | 1568 bytes | 3168 bytes | 1568 bytes | 32 bytes | - -Note: Currently all variants use Kyber-768 implementation. - -## Development - -### Build +| Kyber-1024| 1568 bytes | 3168 bytes | 1408 bytes | 32 bytes | -```bash -# Build Rust extension -cargo build - -# Build Python package -maturin develop -``` - -### Tests - -```bash -# Rust tests -cargo test - -# Python tests -pytest python/pykyber/test_kyber.py -v -``` ## License From f8736cc877b613221c51b90eff05f3e0d99efd12 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 21 Feb 2026 01:01:29 +0200 Subject: [PATCH 13/47] Ready for PyPI --- pyproject.toml | 17 +++++++++++++---- requirements.txt | 1 + 2 files changed, 14 insertions(+), 4 deletions(-) create mode 100644 requirements.txt diff --git a/pyproject.toml b/pyproject.toml index e9340eb..b0758ea 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,14 +4,23 @@ build-backend = "maturin" [project] name = "pykyber" +version = "0.1.0" +description = "Kyber post-quantum key encapsulation in Rust" +readme = "README.md" requires-python = ">=3.8" +license = {text = "MIT"} +authors = [ + {name = "PyKyber Contributors"} +] +keywords = ["kyber", "post-quantum", "cryptography", "pqc", "key-encapsulation"] classifiers = [ + "Programming Language :: Python :: 3", "Programming Language :: Rust", - "Programming Language :: Python :: Implementation :: CPython", - "Programming Language :: Python :: Implementation :: PyPy", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", ] -dynamic = ["version"] +project_urls = {Homepage = "https://github.com/Zikithezikit/pykyber"} [tool.maturin] python-source = "python" -module-name = "pykyber._pykyber" \ No newline at end of file +module-name = "pykyber._pykyber" diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..4c1eabb --- /dev/null +++ b/requirements.txt @@ -0,0 +1 @@ +# No runtime dependencies - pure Rust extension From 0e71ae1ad005adf11a6478baa42e8d7360c63223 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 21 Feb 2026 07:10:40 +0200 Subject: [PATCH 14/47] Add Python 3.8+ support with abi3 --- .github/workflows/CI.yml | 13 ++++--------- Cargo.lock | 2 +- Cargo.toml | 4 ++-- pyproject.toml | 2 +- 4 files changed, 8 insertions(+), 13 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 0f362f6..c025dea 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -39,7 +39,7 @@ jobs: - uses: actions/checkout@v6 - uses: actions/setup-python@v6 with: - python-version: 3.x + python-version: '3.12' - name: Build wheels uses: PyO3/maturin-action@v1 with: @@ -70,7 +70,7 @@ jobs: - uses: actions/checkout@v6 - uses: actions/setup-python@v6 with: - python-version: 3.x + python-version: '3.12' - name: Build wheels uses: PyO3/maturin-action@v1 with: @@ -102,7 +102,7 @@ jobs: - uses: actions/checkout@v6 - uses: actions/setup-python@v6 with: - python-version: 3.13 + python-version: '3.12' architecture: ${{ matrix.platform.python_arch }} - name: Build wheels uses: PyO3/maturin-action@v1 @@ -129,18 +129,13 @@ jobs: - uses: actions/checkout@v6 - uses: actions/setup-python@v6 with: - python-version: 3.x + python-version: '3.12' - name: Build wheels uses: PyO3/maturin-action@v1 with: target: ${{ matrix.platform.target }} args: --release --out dist --find-interpreter sccache: ${{ !startsWith(github.ref, 'refs/tags/') }} - - name: Upload wheels - uses: actions/upload-artifact@v5 - with: - name: wheels-macos-${{ matrix.platform.target }} - path: dist sdist: runs-on: ubuntu-latest diff --git a/Cargo.lock b/Cargo.lock index 4d165cd..0d11807 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -87,7 +87,7 @@ dependencies = [ [[package]] name = "pykyber" -version = "0.1.0" +version = "0.1.1" dependencies = [ "pyo3", "rand", diff --git a/Cargo.toml b/Cargo.toml index 3685186..74de378 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pykyber" -version = "0.1.0" +version = "0.1.1" edition = "2021" [lib] @@ -8,7 +8,7 @@ name = "pykyber" crate-type = ["lib", "cdylib"] [dependencies] -pyo3 = "0.27.0" +pyo3 = { version = "0.27.0", features = ["abi3-py38"] } rand = "0.8" rand_core = "0.6" diff --git a/pyproject.toml b/pyproject.toml index b0758ea..c6717f9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "maturin" [project] name = "pykyber" -version = "0.1.0" +version = "0.1.1" description = "Kyber post-quantum key encapsulation in Rust" readme = "README.md" requires-python = ">=3.8" From 611722a3636e75e7b64e989f6b939175f908238a Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 21 Feb 2026 07:48:52 +0200 Subject: [PATCH 15/47] v0.1.2 - Add Python 3.8+ support and Termux (aarch64, armv7) --- .github/workflows/CI.yml | 26 +++++++++++++++++++++++++- Cargo.toml | 2 +- pyproject.toml | 2 +- 3 files changed, 27 insertions(+), 3 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index c025dea..7012597 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -137,6 +137,30 @@ jobs: args: --release --out dist --find-interpreter sccache: ${{ !startsWith(github.ref, 'refs/tags/') }} + termux: + runs-on: ubuntu-latest + strategy: + matrix: + target: + - aarch64-unknown-linux-gnu + - armv7-unknown-linux-gnueabihf + steps: + - uses: actions/checkout@v6 + - uses: actions/setup-python@v6 + with: + python-version: '3.12' + - name: Build wheels + uses: PyO3/maturin-action@v1 + with: + target: ${{ matrix.target }} + args: --release --out dist --find-interpreter + manylinux: auto + - name: Upload wheels + uses: actions/upload-artifact@v5 + with: + name: wheels-termux-${{ matrix.target }} + path: dist + sdist: runs-on: ubuntu-latest steps: @@ -156,7 +180,7 @@ jobs: name: Release runs-on: ubuntu-latest if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }} - needs: [linux, musllinux, windows, macos, sdist] + needs: [linux, musllinux, windows, macos, termux, sdist] permissions: # Use to sign the release artifacts id-token: write diff --git a/Cargo.toml b/Cargo.toml index 74de378..a970b30 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pykyber" -version = "0.1.1" +version = "0.1.2" edition = "2021" [lib] diff --git a/pyproject.toml b/pyproject.toml index c6717f9..2674bfa 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "maturin" [project] name = "pykyber" -version = "0.1.1" +version = "0.1.2" description = "Kyber post-quantum key encapsulation in Rust" readme = "README.md" requires-python = ">=3.8" From 03e0d084d14d39bb2c49383629b5bf1af3f39a00 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sun, 22 Feb 2026 18:04:38 +0200 Subject: [PATCH 16/47] lsp syntax support --- Cargo.toml | 2 +- pyproject.toml | 2 +- python/pykyber/__init__.py | 2 ++ 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index a970b30..90fcb5e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pykyber" -version = "0.1.2" +version = "0.1.3" edition = "2021" [lib] diff --git a/pyproject.toml b/pyproject.toml index 2674bfa..7f49159 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "maturin" [project] name = "pykyber" -version = "0.1.2" +version = "0.1.3" description = "Kyber post-quantum key encapsulation in Rust" readme = "README.md" requires-python = ">=3.8" diff --git a/python/pykyber/__init__.py b/python/pykyber/__init__.py index 9639633..a709b7f 100644 --- a/python/pykyber/__init__.py +++ b/python/pykyber/__init__.py @@ -6,6 +6,8 @@ Kyber1024, ) +__all__ = ["Kyber512", "Kyber768", "Kyber1024"] + # Import underscored functions from Rust from ._pykyber import ( _generate_keypair, From 857fcf136a2532901faf7a30e1820e10a646d389 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sun, 22 Feb 2026 19:05:17 +0200 Subject: [PATCH 17/47] initial proper error handling in python --- Cargo.lock | 2 +- python/pykyber/__init__.py | 41 ++-- python/pykyber/_kyber.py | 52 ++++- python/tests/test_kyber.py | 387 +++++++++++++++++++++++++++++++++++++ src/kyber/api.rs | 25 ++- src/kyber/error.rs | 36 +++- src/kyber/kem.rs | 63 +++++- src/lib.rs | 131 ++++++------- 8 files changed, 629 insertions(+), 108 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0d11807..6a0b370 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -87,7 +87,7 @@ dependencies = [ [[package]] name = "pykyber" -version = "0.1.1" +version = "0.1.3" dependencies = [ "pyo3", "rand", diff --git a/python/pykyber/__init__.py b/python/pykyber/__init__.py index a709b7f..a6b3bd9 100644 --- a/python/pykyber/__init__.py +++ b/python/pykyber/__init__.py @@ -1,25 +1,32 @@ """Kyber post-quantum key encapsulation.""" + + + + from ._kyber import ( Kyber768, Kyber512, Kyber1024, + KyberError, + _wrap_encapsulate, + _wrap_decapsulate, + _wrap_keypair, ) -__all__ = ["Kyber512", "Kyber768", "Kyber1024"] - -# Import underscored functions from Rust -from ._pykyber import ( - _generate_keypair, - _encapsulate, - _decapsulate, - _keypair_512, - _keypair_768, - _keypair_1024, - _encapsulate_512, - _encapsulate_768, - _encapsulate_1024, - _decapsulate_512, - _decapsulate_768, - _decapsulate_1024, -) +__all__ = ["Kyber512", "Kyber768", "Kyber1024", "KyberError"] + +from . import _pykyber + +_generate_keypair = _wrap_keypair(_pykyber._generate_keypair) +_encapsulate = _wrap_encapsulate(_pykyber._encapsulate) +_decapsulate = _wrap_decapsulate(_pykyber._decapsulate) +_keypair_512 = _wrap_keypair(_pykyber._keypair_512) +_keypair_768 = _wrap_keypair(_pykyber._keypair_768) +_keypair_1024 = _wrap_keypair(_pykyber._keypair_1024) +_encapsulate_512 = _wrap_encapsulate(_pykyber._encapsulate_512) +_encapsulate_768 = _wrap_encapsulate(_pykyber._encapsulate_768) +_encapsulate_1024 = _wrap_encapsulate(_pykyber._encapsulate_1024) +_decapsulate_512 = _wrap_decapsulate(_pykyber._decapsulate_512) +_decapsulate_768 = _wrap_decapsulate(_pykyber._decapsulate_768) +_decapsulate_1024 = _wrap_decapsulate(_pykyber._decapsulate_1024) diff --git a/python/pykyber/_kyber.py b/python/pykyber/_kyber.py index b6750ac..d5012df 100644 --- a/python/pykyber/_kyber.py +++ b/python/pykyber/_kyber.py @@ -4,6 +4,40 @@ from typing import Tuple, Callable +class KyberError(Exception): + """Kyber error exception - raised when invalid input is provided.""" + pass + +def _wrap_encapsulate(fn: Callable[[bytes], Tuple[bytes, bytes]]) -> Callable[[bytes], Tuple[bytes, bytes]]: + """Wrap a Rust encapsulate function to raise KyberError on failure.""" + def wrapper(pk: bytes) -> Tuple[bytes, bytes]: + try: + return fn(pk) + except Exception as e: + raise KyberError(str(e)) from e + return wrapper + + +def _wrap_decapsulate(fn: Callable[[bytes, bytes], bytes]) -> Callable[[bytes, bytes], bytes]: + """Wrap a Rust decapsulate function to raise KyberError on failure.""" + def wrapper(ct: bytes, sk: bytes) -> bytes: + try: + return fn(ct, sk) + except Exception as e: + raise KyberError(str(e)) from e + return wrapper + + +def _wrap_keypair(fn: Callable[[], Tuple[bytes, bytes]]) -> Callable[[], Tuple[bytes, bytes]]: + """Wrap a Rust keypair function to raise KyberError on failure.""" + def wrapper() -> Tuple[bytes, bytes]: + try: + return fn() + except Exception as e: + raise KyberError(str(e)) from e + return wrapper + + @dataclass(frozen=True) class EncapsulationResult: """Result of a Kyber encapsulation.""" @@ -61,14 +95,14 @@ class Kyber512: def __new__(cls) -> Keypair: """Generate a new key pair.""" from . import _pykyber - pk, sk = _pykyber._keypair_512() - return Keypair(sk, pk, _pykyber._encapsulate_512, _pykyber._decapsulate_512) + pk, sk = _wrap_keypair(_pykyber._keypair_512)() + return Keypair(sk, pk, _wrap_encapsulate(_pykyber._encapsulate_512), _wrap_decapsulate(_pykyber._decapsulate_512)) @staticmethod def encapsulate(public_key: bytes) -> EncapsulationResult: """Encapsulate a shared secret using a public key (no keypair needed).""" from . import _pykyber - return EncapsulationResult(*_pykyber._encapsulate_512(public_key)) + return EncapsulationResult(*_wrap_encapsulate(_pykyber._encapsulate_512)(public_key)) class Kyber768: @@ -82,14 +116,14 @@ class Kyber768: def __new__(cls) -> Keypair: """Generate a new key pair.""" from . import _pykyber - pk, sk = _pykyber._keypair_768() - return Keypair(sk, pk, _pykyber._encapsulate_768, _pykyber._decapsulate_768) + pk, sk = _wrap_keypair(_pykyber._keypair_768)() + return Keypair(sk, pk, _wrap_encapsulate(_pykyber._encapsulate_768), _wrap_decapsulate(_pykyber._decapsulate_768)) @staticmethod def encapsulate(public_key: bytes) -> EncapsulationResult: """Encapsulate a shared secret using a public key (no keypair needed).""" from . import _pykyber - return EncapsulationResult(*_pykyber._encapsulate_768(public_key)) + return EncapsulationResult(*_wrap_encapsulate(_pykyber._encapsulate_768)(public_key)) class Kyber1024: @@ -103,11 +137,11 @@ class Kyber1024: def __new__(cls) -> Keypair: """Generate a new key pair.""" from . import _pykyber - pk, sk = _pykyber._keypair_1024() - return Keypair(sk, pk, _pykyber._encapsulate_1024, _pykyber._decapsulate_1024) + pk, sk = _wrap_keypair(_pykyber._keypair_1024)() + return Keypair(sk, pk, _wrap_encapsulate(_pykyber._encapsulate_1024), _wrap_decapsulate(_pykyber._decapsulate_1024)) @staticmethod def encapsulate(public_key: bytes) -> EncapsulationResult: """Encapsulate a shared secret using a public key (no keypair needed).""" from . import _pykyber - return EncapsulationResult(*_pykyber._encapsulate_1024(public_key)) + return EncapsulationResult(*_wrap_encapsulate(_pykyber._encapsulate_1024)(public_key)) diff --git a/python/tests/test_kyber.py b/python/tests/test_kyber.py index f9206e8..656aac8 100644 --- a/python/tests/test_kyber.py +++ b/python/tests/test_kyber.py @@ -456,3 +456,390 @@ def test_encapsulate_static_method_kyber1024(): ss = keypair.decapsulate(result.ciphertext) assert ss == result.shared_secret + + +# Error handling tests - comprehensive + +def test_kyber_error_can_be_imported(): + """Test that KyberError can be imported.""" + assert pykyber.KyberError is not None + assert issubclass(pykyber.KyberError, Exception) + + +def test_invalid_public_key_length_raises_error(): + """Test that invalid public key length raises KyberError.""" + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._encapsulate(b"short") + assert "Invalid input for 'pk'" in str(exc_info.value) + + +def test_invalid_ciphertext_length_raises_error(): + """Test that invalid ciphertext length raises KyberError.""" + sk = bytes(2400) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate(b"short", sk) + assert "Invalid input for 'ct'" in str(exc_info.value) + + +def test_invalid_secret_key_length_raises_error(): + """Test that invalid secret key length raises KyberError.""" + ct = bytes(1088) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate(ct, b"short") + assert "Invalid input for 'sk'" in str(exc_info.value) + + +def test_empty_public_key_raises_error(): + """Test that empty public key raises KyberError.""" + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._encapsulate(b"") + assert "Invalid input for 'pk'" in str(exc_info.value) + + +def test_empty_ciphertext_raises_error(): + """Test that empty ciphertext raises KyberError.""" + pk, sk = pykyber._generate_keypair() + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate(b"", sk) + assert "Invalid input for 'ct'" in str(exc_info.value) + + +def test_empty_secret_key_raises_error(): + """Test that empty secret key raises KyberError.""" + pk, sk = pykyber._generate_keypair() + ct, _ = pykyber._encapsulate(pk) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate(ct, b"") + assert "Invalid input for 'sk'" in str(exc_info.value) + + +def test_very_long_input_raises_error(): + """Test that too long inputs raise KyberError.""" + pk, sk = pykyber._generate_keypair() + long_pk = pk + b"extra" + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._encapsulate(long_pk) + assert "Invalid input for 'pk'" in str(exc_info.value) + + +def test_kyber512_invalid_public_key_length(): + """Test Kyber512 with invalid public key length.""" + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._encapsulate_512(b"short") + assert "Invalid input for 'pk'" in str(exc_info.value) + + +def test_kyber512_invalid_ciphertext_length(): + """Test Kyber512 with invalid ciphertext length.""" + sk = bytes(1632) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate_512(b"short", sk) + assert "Invalid input for 'ct'" in str(exc_info.value) + + +def test_kyber512_invalid_secret_key_length(): + """Test Kyber512 with invalid secret key length.""" + ct = bytes(768) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate_512(ct, b"short") + assert "Invalid input for 'sk'" in str(exc_info.value) + + +def test_kyber1024_invalid_public_key_length(): + """Test Kyber1024 with invalid public key length.""" + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._encapsulate_1024(b"short") + assert "Invalid input for 'pk'" in str(exc_info.value) + + +def test_kyber1024_invalid_ciphertext_length(): + """Test Kyber1024 with invalid ciphertext length.""" + sk = bytes(3168) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate_1024(b"short", sk) + assert "Invalid input for 'ct'" in str(exc_info.value) + + +def test_kyber1024_invalid_secret_key_length(): + """Test Kyber1024 with invalid secret key length.""" + ct = bytes(1408) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate_1024(ct, b"short") + assert "Invalid input for 'sk'" in str(exc_info.value) + + +def test_boundary_public_key_length_512(): + """Test with Kyber512 public key that's 1 byte too short.""" + pk, _ = pykyber._keypair_512() + short_pk = pk[:-1] + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._encapsulate_512(short_pk) + assert "Invalid input for 'pk'" in str(exc_info.value) + assert "800" in str(exc_info.value) + assert "799" in str(exc_info.value) + + +def test_boundary_public_key_length_768(): + """Test with Kyber768 public key that's 1 byte too short.""" + pk, _ = pykyber._keypair_768() + short_pk = pk[:-1] + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._encapsulate(short_pk) + assert "Invalid input for 'pk'" in str(exc_info.value) + assert "1184" in str(exc_info.value) + assert "1183" in str(exc_info.value) + + +def test_boundary_public_key_length_1024(): + """Test with Kyber1024 public key that's 1 byte too short.""" + pk, _ = pykyber._keypair_1024() + short_pk = pk[:-1] + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._encapsulate_1024(short_pk) + assert "Invalid input for 'pk'" in str(exc_info.value) + assert "1568" in str(exc_info.value) + assert "1567" in str(exc_info.value) + + +def test_boundary_secret_key_length_512(): + """Test with Kyber512 secret key that's 1 byte too short.""" + _, sk = pykyber._keypair_512() + ct, _ = pykyber._encapsulate_512(sk[:800]) + short_sk = sk[:-1] + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate_512(ct, short_sk) + assert "Invalid input for 'sk'" in str(exc_info.value) + + +def test_boundary_secret_key_length_768(): + """Test with Kyber768 secret key that's 1 byte too short.""" + pk, sk = pykyber._generate_keypair() + ct, _ = pykyber._encapsulate(pk) + short_sk = sk[:-1] + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate(ct, short_sk) + assert "Invalid input for 'sk'" in str(exc_info.value) + + +def test_boundary_secret_key_length_1024(): + """Test with Kyber1024 secret key that's 1 byte too short.""" + pk, sk = pykyber._keypair_1024() + ct, _ = pykyber._encapsulate_1024(pk) + short_sk = sk[:-1] + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate_1024(ct, short_sk) + assert "Invalid input for 'sk'" in str(exc_info.value) + + +def test_boundary_ciphertext_length_512(): + """Test with Kyber512 ciphertext that's 1 byte too short.""" + pk, sk = pykyber._keypair_512() + ct, _ = pykyber._encapsulate_512(pk) + short_ct = ct[:-1] + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate_512(short_ct, sk) + assert "Invalid input for 'ct'" in str(exc_info.value) + + +def test_boundary_ciphertext_length_768(): + """Test with Kyber768 ciphertext that's 1 byte too short.""" + pk, sk = pykyber._generate_keypair() + ct, _ = pykyber._encapsulate(pk) + short_ct = ct[:-1] + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate(short_ct, sk) + assert "Invalid input for 'ct'" in str(exc_info.value) + + +def test_boundary_ciphertext_length_1024(): + """Test with Kyber1024 ciphertext that's 1 byte too short.""" + pk, sk = pykyber._keypair_1024() + ct, _ = pykyber._encapsulate_1024(pk) + short_ct = ct[:-1] + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate_1024(short_ct, sk) + assert "Invalid input for 'ct'" in str(exc_info.value) + + +def test_error_can_be_caught_as_exception(): + """Test that KyberError can be caught as generic Exception.""" + try: + pykyber._encapsulate(b"short") + assert False, "Should have raised" + except Exception as e: + assert isinstance(e, pykyber.KyberError) + + +def test_error_message_contains_useful_info(): + """Test that error messages contain parameter name and sizes.""" + pk, sk = pykyber._generate_keypair() + + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._encapsulate(b"x" * 100) + msg = str(exc_info.value) + assert "pk" in msg + assert "expected" in msg or "bytes" in msg + + ct, _ = pykyber._encapsulate(pk) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate(ct, b"x" * 100) + msg = str(exc_info.value) + assert "sk" in msg + + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber._decapsulate(b"x" * 100, sk) + msg = str(exc_info.value) + assert "ct" in msg + + +def test_wrong_key_type_raises_error(): + """Test that passing wrong types raises appropriate error.""" + with pytest.raises((pykyber.KyberError, TypeError)): + pykyber._encapsulate(12345) + + with pytest.raises((pykyber.KyberError, TypeError)): + pykyber._decapsulate(None, None) + + +def test_all_variants_of_error(): + """Test that different error variants produce appropriate messages.""" + with pytest.raises(pykyber.KyberError): + pykyber._encapsulate(b"") + + with pytest.raises(pykyber.KyberError): + pk, _ = pykyber._generate_keypair() + pykyber._decapsulate(pk, b"") + + +def test_multiple_error_types_in_sequence(): + """Test catching different errors in sequence.""" + errors = [] + + try: + pykyber._encapsulate(b"x") + except pykyber.KyberError: + errors.append("invalid_pk") + + pk, sk = pykyber._generate_keypair() + try: + pykyber._decapsulate(b"x", sk) + except pykyber.KyberError: + errors.append("invalid_ct") + + try: + pykyber._decapsulate(pk, b"x") + except pykyber.KyberError: + errors.append("invalid_sk") + + assert len(errors) == 3 + assert "invalid_pk" in errors + assert "invalid_ct" in errors + assert "invalid_sk" in errors + + +def test_error_is_subclass_of_exception(): + """Test that KyberError is properly a subclass of Exception.""" + assert issubclass(pykyber.KyberError, Exception) + e = pykyber.KyberError("test") + assert isinstance(e, Exception) + assert str(e) == "test" + + +def test_class_api_error_handling_kyber512(): + """Test error handling in Kyber512 class API.""" + keypair = pykyber.Kyber512() + + with pytest.raises(pykyber.KyberError): + pykyber.Kyber512.encapsulate(b"short") + + with pytest.raises(pykyber.KyberError): + keypair.decapsulate(b"short") + + +def test_class_api_error_handling_kyber768(): + """Test error handling in Kyber768 class API.""" + keypair = pykyber.Kyber768() + + with pytest.raises(pykyber.KyberError): + pykyber.Kyber768.encapsulate(b"short") + + with pytest.raises(pykyber.KyberError): + keypair.decapsulate(b"short") + + +def test_class_api_error_handling_kyber1024(): + """Test error handling in Kyber1024 class API.""" + keypair = pykyber.Kyber1024() + + with pytest.raises(pykyber.KyberError): + pykyber.Kyber1024.encapsulate(b"short") + + with pytest.raises(pykyber.KyberError): + keypair.decapsulate(b"short") + + +def test_error_with_none_values(): + """Test that None values raise appropriate errors.""" + with pytest.raises((pykyber.KyberError, TypeError)): + pykyber._encapsulate(None) + + with pytest.raises((pykyber.KyberError, TypeError)): + pykyber._decapsulate(None, b"x" * 2400) + + with pytest.raises((pykyber.KyberError, TypeError)): + pykyber._decapsulate(b"x" * 1088, None) + + +def test_error_with_list_input(): + """Test that list input raises appropriate error.""" + with pytest.raises((pykyber.KyberError, TypeError)): + pykyber._encapsulate([1, 2, 3]) + + with pytest.raises((pykyber.KyberError, TypeError)): + pykyber._decapsulate([1, 2, 3], b"x" * 2400) + + +def test_error_with_integer_input(): + """Test that integer input raises appropriate error.""" + with pytest.raises((pykyber.KyberError, TypeError)): + pykyber._encapsulate(12345) + + with pytest.raises((pykyber.KyberError, TypeError)): + pykyber._decapsulate(12345, b"x" * 2400) + + +def test_keypair_functions_error_handling(): + """Test that keypair functions still work correctly.""" + pk, sk = pykyber._keypair_512() + assert len(pk) == 800 + assert len(sk) == 1632 + + pk, sk = pykyber._keypair_768() + assert len(pk) == 1184 + assert len(sk) == 2400 + + pk, sk = pykyber._keypair_1024() + assert len(pk) == 1568 + assert len(sk) == 3168 + + +def test_user_can_handle_error_gracefully(): + """Test that a user can handle the error gracefully.""" + def safe_encapsulate(public_key): + """Example of user handling the error.""" + try: + return pykyber._encapsulate(public_key) + except pykyber.KyberError as e: + return f"Error: {e}" + except Exception as e: + return f"Unexpected error: {e}" + + result = safe_encapsulate(b"short") + assert "Error:" in result + assert "Invalid input" in result + + pk, _ = pykyber._generate_keypair() + result = safe_encapsulate(pk) + ct, ss = result + assert len(ct) == 1088 + assert len(ss) == 32 diff --git a/src/kyber/api.rs b/src/kyber/api.rs index 4d807d2..df04cff 100644 --- a/src/kyber/api.rs +++ b/src/kyber/api.rs @@ -18,7 +18,11 @@ where R: CryptoRng + RngCore, { if pk.len() != KYBER_PUBLICKEYBYTES { - return Err(KyberError::InvalidInput); + return Err(KyberError::invalid_input( + "pk", + KYBER_PUBLICKEYBYTES, + pk.len(), + )); } let mut ct = [0u8; KYBER_CIPHERTEXTBYTES]; let mut ss = [0u8; KYBER_SSBYTES]; @@ -27,11 +31,22 @@ where } pub fn decapsulate(ct: &[u8], sk: &[u8]) -> Decapsulated { - if ct.len() != KYBER_CIPHERTEXTBYTES || sk.len() != KYBER_SECRETKEYBYTES { - return Err(KyberError::InvalidInput); + if ct.len() != KYBER_CIPHERTEXTBYTES { + return Err(KyberError::invalid_input( + "ct", + KYBER_CIPHERTEXTBYTES, + ct.len(), + )); + } + if sk.len() != KYBER_SECRETKEYBYTES { + return Err(KyberError::invalid_input( + "sk", + KYBER_SECRETKEYBYTES, + sk.len(), + )); } let mut ss = [0u8; KYBER_SSBYTES]; - crypto_kem_dec(&mut ss, ct, sk); + crypto_kem_dec(&mut ss, ct, sk)?; Ok(ss) } @@ -69,7 +84,7 @@ pub fn derive(seed: &[u8]) -> Result { let mut secret = [0u8; KYBER_SECRETKEYBYTES]; let mut _rng = DummyRng {}; if seed.len() != 64 { - return Err(KyberError::InvalidInput); + return Err(KyberError::invalid_input("seed", 64, seed.len())); } crypto_kem_keypair( &mut public, diff --git a/src/kyber/error.rs b/src/kyber/error.rs index 2882086..2dba3e8 100644 --- a/src/kyber/error.rs +++ b/src/kyber/error.rs @@ -1,21 +1,45 @@ #[derive(Debug, PartialEq)] pub enum KyberError { - InvalidInput, + InvalidInput { + param: &'static str, + expected: usize, + actual: usize, + }, Decapsulation, RandomBytesGeneration, } +impl KyberError { + pub fn invalid_input(param: &'static str, expected: usize, actual: usize) -> Self { + KyberError::InvalidInput { + param, + expected, + actual, + } + } +} + impl core::fmt::Display for KyberError { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { match *self { - KyberError::InvalidInput => write!(f, "Function input is of incorrect length"), + KyberError::InvalidInput { + param, + expected, + actual, + } => { + write!( + f, + "Invalid input for '{}': expected {} bytes, got {}", + param, expected, actual + ) + } KyberError::Decapsulation => write!( f, - "Decapsulation Failure, unable to obtain shared secret from ciphertext" + "Decapsulation Failure: unable to obtain shared secret from ciphertext" ), - KyberError::RandomBytesGeneration => { - write!(f, "Random bytes generation function failed") - } + KyberError::RandomBytesGeneration => write!(f, "Random bytes generation failed"), } } } + +impl std::error::Error for KyberError {} diff --git a/src/kyber/kem.rs b/src/kyber/kem.rs index 62a217d..8e243a6 100644 --- a/src/kyber/kem.rs +++ b/src/kyber/kem.rs @@ -65,7 +65,25 @@ where Ok(()) } -pub fn crypto_kem_dec(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> () { +pub fn crypto_kem_dec(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> Result<(), KyberError> { + if ct.len() != KYBER_CIPHERTEXTBYTES { + return Err(KyberError::invalid_input( + "ct", + KYBER_CIPHERTEXTBYTES, + ct.len(), + )); + } + if sk.len() != KYBER_SECRETKEYBYTES { + return Err(KyberError::invalid_input( + "sk", + KYBER_SECRETKEYBYTES, + sk.len(), + )); + } + if ss.len() != KYBER_SSBYTES { + return Err(KyberError::invalid_input("ss", KYBER_SSBYTES, ss.len())); + } + let mut buf = [0u8; 2 * KYBER_SYMBYTES]; let mut kr = [0u8; 2 * KYBER_SYMBYTES]; let mut cmp = [0u8; KYBER_CIPHERTEXTBYTES]; @@ -85,6 +103,7 @@ pub fn crypto_kem_dec(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> () { hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_CIPHERTEXTBYTES); cmov(&mut kr, &sk[END..], KYBER_SYMBYTES, fail); shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); + Ok(()) } pub fn crypto_kem_keypair_512( @@ -145,7 +164,25 @@ where Ok(()) } -pub fn crypto_kem_dec_512(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> () { +pub fn crypto_kem_dec_512(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> Result<(), KyberError> { + if ct.len() != KYBER_512_CIPHERTEXTBYTES { + return Err(KyberError::invalid_input( + "ct", + KYBER_512_CIPHERTEXTBYTES, + ct.len(), + )); + } + if sk.len() != KYBER_512_SECRETKEYBYTES { + return Err(KyberError::invalid_input( + "sk", + KYBER_512_SECRETKEYBYTES, + sk.len(), + )); + } + if ss.len() != KYBER_SSBYTES { + return Err(KyberError::invalid_input("ss", KYBER_SSBYTES, ss.len())); + } + let mut buf = [0u8; 2 * KYBER_SYMBYTES]; let mut kr = [0u8; 2 * KYBER_SYMBYTES]; let mut cmp = [0u8; KYBER_512_CIPHERTEXTBYTES]; @@ -165,6 +202,7 @@ pub fn crypto_kem_dec_512(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> () { hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_512_CIPHERTEXTBYTES); cmov(&mut kr, &sk[END..], KYBER_SYMBYTES, fail); shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); + Ok(()) } pub fn crypto_kem_keypair_1024( @@ -225,7 +263,25 @@ where Ok(()) } -pub fn crypto_kem_dec_1024(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> () { +pub fn crypto_kem_dec_1024(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> Result<(), KyberError> { + if ct.len() != KYBER_1024_CIPHERTEXTBYTES { + return Err(KyberError::invalid_input( + "ct", + KYBER_1024_CIPHERTEXTBYTES, + ct.len(), + )); + } + if sk.len() != KYBER_1024_SECRETKEYBYTES { + return Err(KyberError::invalid_input( + "sk", + KYBER_1024_SECRETKEYBYTES, + sk.len(), + )); + } + if ss.len() != KYBER_SSBYTES { + return Err(KyberError::invalid_input("ss", KYBER_SSBYTES, ss.len())); + } + let mut buf = [0u8; 2 * KYBER_SYMBYTES]; let mut kr = [0u8; 2 * KYBER_SYMBYTES]; let mut cmp = [0u8; KYBER_1024_CIPHERTEXTBYTES]; @@ -245,4 +301,5 @@ pub fn crypto_kem_dec_1024(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> () { hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_1024_CIPHERTEXTBYTES); cmov(&mut kr, &sk[END..], KYBER_SYMBYTES, fail); shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); + Ok(()) } diff --git a/src/lib.rs b/src/lib.rs index 253e8f4..eeb406a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -2,128 +2,125 @@ pub mod kyber; use kyber::{ crypto_kem_dec_1024, crypto_kem_dec_512, crypto_kem_enc_1024, crypto_kem_enc_512, - crypto_kem_keypair_1024, crypto_kem_keypair_512, decapsulate, encapsulate, keypair, - KYBER_1024_CIPHERTEXTBYTES, KYBER_1024_PUBLICKEYBYTES, KYBER_1024_SECRETKEYBYTES, + crypto_kem_keypair_1024, crypto_kem_keypair_512, decapsulate, encapsulate, error::KyberError, + keypair, KYBER_1024_CIPHERTEXTBYTES, KYBER_1024_PUBLICKEYBYTES, KYBER_1024_SECRETKEYBYTES, KYBER_512_CIPHERTEXTBYTES, KYBER_512_PUBLICKEYBYTES, KYBER_512_SECRETKEYBYTES, }; +use pyo3::exceptions::PyException; use pyo3::prelude::*; use rand::thread_rng; -/// Generate a Kyber-768 keypair. -/// Returns (public_key, secret_key). +fn make_kyber_error(msg: &str) -> PyErr { + PyException::new_err(msg.to_string()) +} + #[pyfunction] fn generate_keypair() -> PyResult<(Vec, Vec)> { let mut rng = thread_rng(); - match keypair(&mut rng) { - Ok(keys) => Ok((keys.public.to_vec(), keys.secret.to_vec())), - Err(e) => Err(PyErr::new::( - e.to_string(), - )), - } + keypair(&mut rng) + .map(|keys| (keys.public.to_vec(), keys.secret.to_vec())) + .map_err(|e| make_kyber_error(&e.to_string())) } -/// Encapsulate a shared secret using a public key. -/// Args: -/// pk: public key bytes -/// Returns (ciphertext, shared_secret). #[pyfunction] fn encapsulate_key(pk: &[u8]) -> PyResult<(Vec, Vec)> { let mut rng = thread_rng(); - match encapsulate(pk, &mut rng) { - Ok((ct, ss)) => Ok((ct.to_vec(), ss.to_vec())), - Err(e) => Err(PyErr::new::( - e.to_string(), - )), - } + encapsulate(pk, &mut rng) + .map(|(ct, ss)| (ct.to_vec(), ss.to_vec())) + .map_err(|e| make_kyber_error(&e.to_string())) } -/// Decapsulate a shared secret using a ciphertext and secret key. -/// Args: -/// ct: ciphertext bytes -/// sk: secret key bytes -/// Returns shared_secret bytes. #[pyfunction] fn decapsulate_key(ct: &[u8], sk: &[u8]) -> PyResult> { - match decapsulate(ct, sk) { - Ok(ss) => Ok(ss.to_vec()), - Err(e) => Err(PyErr::new::( - e.to_string(), - )), - } + decapsulate(ct, sk) + .map(|ss| ss.to_vec()) + .map_err(|e| make_kyber_error(&e.to_string())) } -/// Generate a Kyber-512 keypair. -/// Returns (public_key, secret_key). #[pyfunction] fn generate_keypair_512() -> PyResult<(Vec, Vec)> { let mut rng = thread_rng(); let mut pk = vec![0u8; KYBER_512_PUBLICKEYBYTES]; let mut sk = vec![0u8; KYBER_512_SECRETKEYBYTES]; - match crypto_kem_keypair_512(&mut pk, &mut sk, &mut rng, None) { - Ok(()) => Ok((pk, sk)), - Err(e) => Err(PyErr::new::( - e.to_string(), - )), - } + crypto_kem_keypair_512(&mut pk, &mut sk, &mut rng, None) + .map(|_| (pk, sk)) + .map_err(|e| make_kyber_error(&e.to_string())) } -/// Generate a Kyber-1024 keypair. -/// Returns (public_key, secret_key). #[pyfunction] fn generate_keypair_1024() -> PyResult<(Vec, Vec)> { let mut rng = thread_rng(); let mut pk = vec![0u8; KYBER_1024_PUBLICKEYBYTES]; let mut sk = vec![0u8; KYBER_1024_SECRETKEYBYTES]; - match crypto_kem_keypair_1024(&mut pk, &mut sk, &mut rng, None) { - Ok(()) => Ok((pk, sk)), - Err(e) => Err(PyErr::new::( - e.to_string(), - )), - } + crypto_kem_keypair_1024(&mut pk, &mut sk, &mut rng, None) + .map(|_| (pk, sk)) + .map_err(|e| make_kyber_error(&e.to_string())) } -/// Encapsulate a shared secret using a Kyber-512 public key. #[pyfunction] fn encapsulate_key_512(pk: &[u8]) -> PyResult<(Vec, Vec)> { + if pk.len() != KYBER_512_PUBLICKEYBYTES { + return Err(make_kyber_error( + &KyberError::invalid_input("pk", KYBER_512_PUBLICKEYBYTES, pk.len()).to_string(), + )); + } let mut rng = thread_rng(); let mut ct = vec![0u8; KYBER_512_CIPHERTEXTBYTES]; let mut ss = vec![0u8; 32]; - match crypto_kem_enc_512(&mut ct, &mut ss, pk, &mut rng, None) { - Ok(()) => Ok((ct, ss)), - Err(e) => Err(PyErr::new::( - e.to_string(), - )), - } + crypto_kem_enc_512(&mut ct, &mut ss, pk, &mut rng, None) + .map(|_| (ct, ss)) + .map_err(|e| make_kyber_error(&e.to_string())) } -/// Encapsulate a shared secret using a Kyber-1024 public key. #[pyfunction] fn encapsulate_key_1024(pk: &[u8]) -> PyResult<(Vec, Vec)> { + if pk.len() != KYBER_1024_PUBLICKEYBYTES { + return Err(make_kyber_error( + &KyberError::invalid_input("pk", KYBER_1024_PUBLICKEYBYTES, pk.len()).to_string(), + )); + } let mut rng = thread_rng(); let mut ct = vec![0u8; KYBER_1024_CIPHERTEXTBYTES]; let mut ss = vec![0u8; 32]; - match crypto_kem_enc_1024(&mut ct, &mut ss, pk, &mut rng, None) { - Ok(()) => Ok((ct, ss)), - Err(e) => Err(PyErr::new::( - e.to_string(), - )), - } + crypto_kem_enc_1024(&mut ct, &mut ss, pk, &mut rng, None) + .map(|_| (ct, ss)) + .map_err(|e| make_kyber_error(&e.to_string())) } -/// Decapsulate a shared secret using a Kyber-512 ciphertext and secret key. #[pyfunction] fn decapsulate_key_512(ct: &[u8], sk: &[u8]) -> PyResult> { + if ct.len() != KYBER_512_CIPHERTEXTBYTES { + return Err(make_kyber_error( + &KyberError::invalid_input("ct", KYBER_512_CIPHERTEXTBYTES, ct.len()).to_string(), + )); + } + if sk.len() != KYBER_512_SECRETKEYBYTES { + return Err(make_kyber_error( + &KyberError::invalid_input("sk", KYBER_512_SECRETKEYBYTES, sk.len()).to_string(), + )); + } let mut ss = vec![0u8; 32]; - crypto_kem_dec_512(&mut ss, ct, sk); - Ok(ss) + crypto_kem_dec_512(&mut ss, ct, sk) + .map(|_| ss) + .map_err(|e| make_kyber_error(&e.to_string())) } -/// Decapsulate a shared secret using a Kyber-1024 ciphertext and secret key. #[pyfunction] fn decapsulate_key_1024(ct: &[u8], sk: &[u8]) -> PyResult> { + if ct.len() != KYBER_1024_CIPHERTEXTBYTES { + return Err(make_kyber_error( + &KyberError::invalid_input("ct", KYBER_1024_CIPHERTEXTBYTES, ct.len()).to_string(), + )); + } + if sk.len() != KYBER_1024_SECRETKEYBYTES { + return Err(make_kyber_error( + &KyberError::invalid_input("sk", KYBER_1024_SECRETKEYBYTES, sk.len()).to_string(), + )); + } let mut ss = vec![0u8; 32]; - crypto_kem_dec_1024(&mut ss, ct, sk); - Ok(ss) + crypto_kem_dec_1024(&mut ss, ct, sk) + .map(|_| ss) + .map_err(|e| make_kyber_error(&e.to_string())) } #[pymodule] From e445d4d8c32755a6614b2a030746244c66bc8208 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sun, 22 Feb 2026 19:29:12 +0200 Subject: [PATCH 18/47] more panic tests and error handling --- python/tests/test_kyber.py | 291 +++++++++++++++++++++++++++++++++++++ tests/integration_kem.rs | 6 +- 2 files changed, 294 insertions(+), 3 deletions(-) diff --git a/python/tests/test_kyber.py b/python/tests/test_kyber.py index 656aac8..a75c183 100644 --- a/python/tests/test_kyber.py +++ b/python/tests/test_kyber.py @@ -843,3 +843,294 @@ def safe_encapsulate(public_key): ct, ss = result assert len(ct) == 1088 assert len(ss) == 32 + + +# Additional panic prevention tests + +def test_all_zero_public_key_512(): + """Test encapsulation with all-zero public key (Kyber512).""" + zero_pk = bytes(800) + ct, ss = pykyber._encapsulate_512(zero_pk) + assert len(ct) == 768 + assert len(ss) == 32 + + +def test_all_zero_public_key_768(): + """Test encapsulation with all-zero public key (Kyber768).""" + zero_pk = bytes(1184) + ct, ss = pykyber._encapsulate(zero_pk) + assert len(ct) == 1088 + assert len(ss) == 32 + + +def test_all_zero_public_key_1024(): + """Test encapsulation with all-zero public key (Kyber1024).""" + zero_pk = bytes(1568) + ct, ss = pykyber._encapsulate_1024(zero_pk) + assert len(ct) == 1408 + assert len(ss) == 32 + + +def test_all_ones_public_key_512(): + """Test encapsulation with all-ones public key (Kyber512).""" + ones_pk = bytes([255] * 800) + ct, ss = pykyber._encapsulate_512(ones_pk) + assert len(ct) == 768 + assert len(ss) == 32 + + +def test_all_ones_public_key_768(): + """Test encapsulation with all-ones public key (Kyber768).""" + ones_pk = bytes([255] * 1184) + ct, ss = pykyber._encapsulate(ones_pk) + assert len(ct) == 1088 + assert len(ss) == 32 + + +def test_all_ones_public_key_1024(): + """Test encapsulation with all-ones public key (Kyber1024).""" + ones_pk = bytes([255] * 1568) + ct, ss = pykyber._encapsulate_1024(ones_pk) + assert len(ct) == 1408 + assert len(ss) == 32 + + +def test_alternating_bits_public_key(): + """Test encapsulation with alternating bits public key.""" + alternating_pk = bytes([i % 2 for i in range(1184)]) + ct, ss = pykyber._encapsulate(alternating_pk) + assert len(ct) == 1088 + assert len(ss) == 32 + + +def test_decapsulate_with_all_zero_ciphertext_512(): + """Test decapsulation with all-zero ciphertext (Kyber512).""" + pk, sk = pykyber._keypair_512() + zero_ct = bytes(768) + ss = pykyber._decapsulate_512(zero_ct, sk) + assert len(ss) == 32 + + +def test_decapsulate_with_all_zero_ciphertext_768(): + """Test decapsulation with all-zero ciphertext (Kyber768).""" + pk, sk = pykyber._generate_keypair() + zero_ct = bytes(1088) + ss = pykyber._decapsulate(zero_ct, sk) + assert len(ss) == 32 + + +def test_decapsulate_with_all_zero_ciphertext_1024(): + """Test decapsulation with all-zero ciphertext (Kyber1024).""" + pk, sk = pykyber._keypair_1024() + zero_ct = bytes(1408) + ss = pykyber._decapsulate_1024(zero_ct, sk) + assert len(ss) == 32 + + +def test_decapsulate_with_all_ones_ciphertext(): + """Test decapsulation with all-ones ciphertext.""" + pk, sk = pykyber._generate_keypair() + ones_ct = bytes([255] * 1088) + ss = pykyber._decapsulate(ones_ct, sk) + assert len(ss) == 32 + + +def test_wrong_variant_ciphertext_decapsulate_512_with_768_ct(): + """Test using 768 ciphertext with 512 decapsulate - should fail gracefully.""" + pk_768, sk_768 = pykyber._generate_keypair() + pk_512, sk_512 = pykyber._keypair_512() + ct_768, _ = pykyber._encapsulate(pk_768) + with pytest.raises(pykyber.KyberError): + pykyber._decapsulate_512(ct_768, sk_512) + + +def test_wrong_variant_ciphertext_decapsulate_1024_with_768_ct(): + """Test using 768 ciphertext with 1024 decapsulate - should fail gracefully.""" + pk_768, sk_768 = pykyber._generate_keypair() + pk_1024, sk_1024 = pykyber._keypair_1024() + ct_768, _ = pykyber._encapsulate(pk_768) + with pytest.raises(pykyber.KyberError): + pykyber._decapsulate_1024(ct_768, sk_1024) + + +def test_wrong_variant_ciphertext_decapsulate_768_with_512_ct(): + """Test using 512 ciphertext with 768 decapsulate - should fail gracefully.""" + pk_512, sk_512 = pykyber._keypair_512() + pk_768, sk_768 = pykyber._generate_keypair() + ct_512, _ = pykyber._encapsulate_512(pk_512) + with pytest.raises(pykyber.KyberError): + pykyber._decapsulate(ct_512, sk_768) + + +def test_mismatched_keypair_ciphertext(): + """Test decapsulating ciphertext from different keypair.""" + keypair1 = pykyber.Kyber768() + keypair2 = pykyber.Kyber768() + result = keypair1.encapsulate() + ss_dec = keypair2.decapsulate(result.ciphertext) + assert ss_dec != result.shared_secret + + +def test_repeated_keypair_generation(): + """Test multiple rapid keypair generations don't panic.""" + for _ in range(100): + pk, sk = pykyber._generate_keypair() + assert len(pk) == 1184 + assert len(sk) == 2400 + + +def test_repeated_encapsulation(): + """Test multiple rapid encapsulations don't panic.""" + pk, _ = pykyber._generate_keypair() + for _ in range(100): + ct, ss = pykyber._encapsulate(pk) + assert len(ct) == 1088 + assert len(ss) == 32 + + +def test_repeated_decapsulation(): + """Test multiple rapid decapsulations don't panic.""" + pk, sk = pykyber._generate_keypair() + ct, _ = pykyber._encapsulate(pk) + for _ in range(100): + ss = pykyber._decapsulate(ct, sk) + assert len(ss) == 32 + + +def test_very_large_valid_size_public_key(): + """Test with a public key that's much larger than expected - should fail gracefully.""" + huge_pk = bytes(10000) + with pytest.raises(pykyber.KyberError): + pykyber._encapsulate(huge_pk) + + +def test_very_large_valid_size_secret_key(): + """Test with a secret key that's much larger than expected - should fail gracefully.""" + pk, sk = pykyber._generate_keypair() + ct, _ = pykyber._encapsulate(pk) + huge_sk = sk + bytes(10000) + with pytest.raises(pykyber.KyberError): + pykyber._decapsulate(ct, huge_sk) + + +def test_very_large_valid_size_ciphertext(): + """Test with a ciphertext that's much larger than expected - should fail gracefully.""" + pk, sk = pykyber._generate_keypair() + ct, _ = pykyber._encapsulate(pk) + huge_ct = ct + bytes(10000) + with pytest.raises(pykyber.KyberError): + pykyber._decapsulate(huge_ct, sk) + + +def test_boundary_minus_one_ciphertext_512(): + """Test with ciphertext that's 1 byte less than minimum (Kyber512).""" + pk, sk = pykyber._keypair_512() + ct, _ = pykyber._encapsulate_512(pk) + short_ct = ct[:-1] + with pytest.raises(pykyber.KyberError): + pykyber._decapsulate_512(short_ct, sk) + + +def test_boundary_minus_one_ciphertext_768(): + """Test with ciphertext that's 1 byte less than minimum (Kyber768).""" + pk, sk = pykyber._generate_keypair() + ct, _ = pykyber._encapsulate(pk) + short_ct = ct[:-1] + with pytest.raises(pykyber.KyberError): + pykyber._decapsulate(short_ct, sk) + + +def test_boundary_minus_one_ciphertext_1024(): + """Test with ciphertext that's 1 byte less than minimum (Kyber1024).""" + pk, sk = pykyber._keypair_1024() + ct, _ = pykyber._encapsulate_1024(pk) + short_ct = ct[:-1] + with pytest.raises(pykyber.KyberError): + pykyber._decapsulate_1024(short_ct, sk) + + +def test_max_uint8_values_secret_key(): + """Test decapsulation with max uint8 values in secret key - should not panic.""" + pk, sk = pykyber._generate_keypair() + max_sk = bytes([255] * len(sk)) + ct, _ = pykyber._encapsulate(pk) + ss = pykyber._decapsulate(ct, max_sk) + assert len(ss) == 32 + + +def test_max_uint8_values_ciphertext(): + """Test decapsulation with max uint8 values in ciphertext - should not panic.""" + pk, sk = pykyber._generate_keypair() + max_ct = bytes([255] * 1088) + ss = pykyber._decapsulate(max_ct, sk) + assert len(ss) == 32 + + +def test_interleaved_key_generation_and_encapsulation(): + """Test interleaved key generation and encapsulation.""" + for i in range(50): + if i % 3 == 0: + pk, _ = pykyber._keypair_512() + ct, ss = pykyber._encapsulate_512(pk) + elif i % 3 == 1: + pk, _ = pykyber._generate_keypair() + ct, ss = pykyber._encapsulate(pk) + else: + pk, _ = pykyber._keypair_1024() + ct, ss = pykyber._encapsulate_1024(pk) + assert len(ct) > 0 + assert len(ss) == 32 + + +def test_encapsulate_with_known_vector_512(): + """Test encapsulation produces expected output format.""" + pk = bytes(800) + ct, ss = pykyber._encapsulate_512(pk) + assert isinstance(ct, bytes) + assert isinstance(ss, bytes) + assert len(ct) == 768 + assert len(ss) == 32 + + +def test_keypair_with_specific_seed_issue(): + """Test that various seed patterns don't cause panic.""" + seeds = [ + bytes(32), + bytes([0] * 32), + bytes([255] * 32), + bytes([i for i in range(32)]), + bytes([31 - i for i in range(32)]), + ] + for seed in seeds: + pk, sk = pykyber._generate_keypair() + assert len(pk) == 1184 + assert len(sk) == 2400 + + +def test_concurrent_error_handling(): + """Test that error handling works correctly in sequence.""" + error_inputs = [ + (b"", b""), + (b"x", b"x" * 2400), + (b"x" * 1088, b"x"), + (b"x" * 100, b"x" * 100), + ] + for pk_test, sk_test in error_inputs: + try: + pykyber._encapsulate(pk_test) + except pykyber.KyberError: + pass + except Exception as e: + if "panicked" not in str(e).lower(): + raise AssertionError(f"Unexpected non-panic error: {e}") + + pk, sk = pykyber._generate_keypair() + ct, _ = pykyber._encapsulate(pk) + for ct_test, sk_test in error_inputs: + try: + pykyber._decapsulate(ct_test, sk_test) + except pykyber.KyberError: + pass + except Exception as e: + if "panicked" not in str(e).lower(): + raise AssertionError(f"Unexpected non-panic error: {e}") diff --git a/tests/integration_kem.rs b/tests/integration_kem.rs index c8b222f..543b067 100644 --- a/tests/integration_kem.rs +++ b/tests/integration_kem.rs @@ -1,6 +1,6 @@ //! Integration tests for Kyber KEM -use pykyber::kyber::api::{decapsulate, encapsulate, keypair, Keypair}; +use pykyber::kyber::api::{decapsulate, encapsulate, keypair}; use pykyber::kyber::crypto_kem_dec_1024; use pykyber::kyber::crypto_kem_dec_512; use pykyber::kyber::crypto_kem_enc_1024; @@ -56,7 +56,7 @@ fn test_kyber_512_encapsulate_decapsulate() { assert_eq!(ss.len(), KYBER_SSBYTES); let mut ss2 = vec![0u8; KYBER_SSBYTES]; - crypto_kem_dec_512(&mut ss2, &ct, &sk); + crypto_kem_dec_512(&mut ss2, &ct, &sk).unwrap(); assert_eq!(ss, ss2); } @@ -88,7 +88,7 @@ fn test_kyber_1024_encapsulate_decapsulate() { assert_eq!(ss.len(), KYBER_SSBYTES); let mut ss2 = vec![0u8; KYBER_SSBYTES]; - crypto_kem_dec_1024(&mut ss2, &ct, &sk); + crypto_kem_dec_1024(&mut ss2, &ct, &sk).unwrap(); assert_eq!(ss, ss2); } From 2780216a77499d9efe6432ee83d6805a6db5b138 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sun, 22 Feb 2026 20:07:24 +0200 Subject: [PATCH 19/47] more verbose errors --- Cargo.toml | 2 +- python/pykyber/__init__.py | 20 +++++++------- python/pykyber/_kyber.py | 55 ++++++++++++++++++++++++++++---------- python/tests/test_kyber.py | 34 +++++++++++------------ 4 files changed, 69 insertions(+), 42 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 90fcb5e..53284f4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,7 +8,7 @@ name = "pykyber" crate-type = ["lib", "cdylib"] [dependencies] -pyo3 = { version = "0.27.0", features = ["abi3-py38"] } +pyo3 = { version = "0.27.0", features = ["extension-module", "abi3-py38"] } rand = "0.8" rand_core = "0.6" diff --git a/python/pykyber/__init__.py b/python/pykyber/__init__.py index a6b3bd9..381cdc2 100644 --- a/python/pykyber/__init__.py +++ b/python/pykyber/__init__.py @@ -9,8 +9,8 @@ Kyber512, Kyber1024, KyberError, - _wrap_encapsulate, - _wrap_decapsulate, + _validate_encapsulate, + _validate_decapsulate, _wrap_keypair, ) @@ -19,14 +19,14 @@ from . import _pykyber _generate_keypair = _wrap_keypair(_pykyber._generate_keypair) -_encapsulate = _wrap_encapsulate(_pykyber._encapsulate) -_decapsulate = _wrap_decapsulate(_pykyber._decapsulate) +_encapsulate = _validate_encapsulate(_pykyber._encapsulate, 1184, "_generate_keypair") +_decapsulate = _validate_decapsulate(_pykyber._decapsulate, 1088, "_generate_keypair") _keypair_512 = _wrap_keypair(_pykyber._keypair_512) _keypair_768 = _wrap_keypair(_pykyber._keypair_768) _keypair_1024 = _wrap_keypair(_pykyber._keypair_1024) -_encapsulate_512 = _wrap_encapsulate(_pykyber._encapsulate_512) -_encapsulate_768 = _wrap_encapsulate(_pykyber._encapsulate_768) -_encapsulate_1024 = _wrap_encapsulate(_pykyber._encapsulate_1024) -_decapsulate_512 = _wrap_decapsulate(_pykyber._decapsulate_512) -_decapsulate_768 = _wrap_decapsulate(_pykyber._decapsulate_768) -_decapsulate_1024 = _wrap_decapsulate(_pykyber._decapsulate_1024) +_encapsulate_512 = _validate_encapsulate(_pykyber._encapsulate_512, Kyber512.PUBLIC_KEY_SIZE, "_encapsulate_512") +_encapsulate_768 = _validate_encapsulate(_pykyber._encapsulate_768, Kyber768.PUBLIC_KEY_SIZE, "_encapsulate_768") +_encapsulate_1024 = _validate_encapsulate(_pykyber._encapsulate_1024, Kyber1024.PUBLIC_KEY_SIZE, "_encapsulate_1024") +_decapsulate_512 = _validate_decapsulate(_pykyber._decapsulate_512, Kyber512.CIPHERTEXT_SIZE, "_decapsulate_512") +_decapsulate_768 = _validate_decapsulate(_pykyber._decapsulate_768, Kyber768.CIPHERTEXT_SIZE, "_decapsulate_768") +_decapsulate_1024 = _validate_decapsulate(_pykyber._decapsulate_1024, Kyber1024.CIPHERTEXT_SIZE, "_decapsulate_1024") diff --git a/python/pykyber/_kyber.py b/python/pykyber/_kyber.py index d5012df..73c47cc 100644 --- a/python/pykyber/_kyber.py +++ b/python/pykyber/_kyber.py @@ -8,23 +8,44 @@ class KyberError(Exception): """Kyber error exception - raised when invalid input is provided.""" pass -def _wrap_encapsulate(fn: Callable[[bytes], Tuple[bytes, bytes]]) -> Callable[[bytes], Tuple[bytes, bytes]]: - """Wrap a Rust encapsulate function to raise KyberError on failure.""" +def _validate_pk(pk: bytes, expected_size: int, method_name: str) -> None: + """Validate public key length with a clear error message.""" + actual_size = len(pk) + if actual_size != expected_size: + raise KyberError( + f"Invalid public key for {method_name}: expected {expected_size} bytes, got {actual_size}. " + f"Ensure you're using the correct Kyber variant (Kyber512={800}, Kyber768={1184}, Kyber1024={1568})." + ) + + +def _validate_encapsulate(fn: Callable[[bytes], Tuple[bytes, bytes]], expected_pk_size: int, method_name: str) -> Callable[[bytes], Tuple[bytes, bytes]]: + """Validate public key and call Rust encapsulate function.""" def wrapper(pk: bytes) -> Tuple[bytes, bytes]: + _validate_pk(pk, expected_pk_size, method_name) try: return fn(pk) except Exception as e: - raise KyberError(str(e)) from e + raise KyberError(str(e)) from None return wrapper -def _wrap_decapsulate(fn: Callable[[bytes, bytes], bytes]) -> Callable[[bytes, bytes], bytes]: - """Wrap a Rust decapsulate function to raise KyberError on failure.""" +def _validate_ct(ct: bytes, expected_size: int, method_name: str) -> None: + """Validate ciphertext length with a clear error message.""" + actual_size = len(ct) + if actual_size != expected_size: + raise KyberError( + f"Invalid ciphertext for {method_name}: expected {expected_size} bytes, got {actual_size}." + ) + + +def _validate_decapsulate(fn: Callable[[bytes, bytes], bytes], expected_ct_size: int, method_name: str) -> Callable[[bytes, bytes], bytes]: + """Validate ciphertext and call Rust decapsulate function.""" def wrapper(ct: bytes, sk: bytes) -> bytes: + _validate_ct(ct, expected_ct_size, method_name) try: return fn(ct, sk) except Exception as e: - raise KyberError(str(e)) from e + raise KyberError(str(e)) from None return wrapper @@ -34,7 +55,7 @@ def wrapper() -> Tuple[bytes, bytes]: try: return fn() except Exception as e: - raise KyberError(str(e)) from e + raise KyberError(str(e)) from None return wrapper @@ -96,13 +117,15 @@ def __new__(cls) -> Keypair: """Generate a new key pair.""" from . import _pykyber pk, sk = _wrap_keypair(_pykyber._keypair_512)() - return Keypair(sk, pk, _wrap_encapsulate(_pykyber._encapsulate_512), _wrap_decapsulate(_pykyber._decapsulate_512)) + return Keypair(sk, pk, + _validate_encapsulate(_pykyber._encapsulate_512, Kyber512.PUBLIC_KEY_SIZE, "Kyber512"), + _validate_decapsulate(_pykyber._decapsulate_512, Kyber512.CIPHERTEXT_SIZE, "Kyber512")) @staticmethod def encapsulate(public_key: bytes) -> EncapsulationResult: """Encapsulate a shared secret using a public key (no keypair needed).""" from . import _pykyber - return EncapsulationResult(*_wrap_encapsulate(_pykyber._encapsulate_512)(public_key)) + return EncapsulationResult(*_validate_encapsulate(_pykyber._encapsulate_512, Kyber512.PUBLIC_KEY_SIZE, "Kyber512.encapsulate")(public_key)) class Kyber768: @@ -117,13 +140,15 @@ def __new__(cls) -> Keypair: """Generate a new key pair.""" from . import _pykyber pk, sk = _wrap_keypair(_pykyber._keypair_768)() - return Keypair(sk, pk, _wrap_encapsulate(_pykyber._encapsulate_768), _wrap_decapsulate(_pykyber._decapsulate_768)) + return Keypair(sk, pk, + _validate_encapsulate(_pykyber._encapsulate_768, Kyber768.PUBLIC_KEY_SIZE, "Kyber768"), + _validate_decapsulate(_pykyber._decapsulate_768, Kyber768.CIPHERTEXT_SIZE, "Kyber768")) @staticmethod def encapsulate(public_key: bytes) -> EncapsulationResult: """Encapsulate a shared secret using a public key (no keypair needed).""" from . import _pykyber - return EncapsulationResult(*_wrap_encapsulate(_pykyber._encapsulate_768)(public_key)) + return EncapsulationResult(*_validate_encapsulate(_pykyber._encapsulate_768, Kyber768.PUBLIC_KEY_SIZE, "Kyber768.encapsulate")(public_key)) class Kyber1024: @@ -131,17 +156,19 @@ class Kyber1024: PUBLIC_KEY_SIZE = 1568 SECRET_KEY_SIZE = 3168 - CIPHERTEXT_SIZE = 1568 + CIPHERTEXT_SIZE = 1408 SHARED_SECRET_SIZE = 32 def __new__(cls) -> Keypair: """Generate a new key pair.""" from . import _pykyber pk, sk = _wrap_keypair(_pykyber._keypair_1024)() - return Keypair(sk, pk, _wrap_encapsulate(_pykyber._encapsulate_1024), _wrap_decapsulate(_pykyber._decapsulate_1024)) + return Keypair(sk, pk, + _validate_encapsulate(_pykyber._encapsulate_1024, Kyber1024.PUBLIC_KEY_SIZE, "Kyber1024"), + _validate_decapsulate(_pykyber._decapsulate_1024, Kyber1024.CIPHERTEXT_SIZE, "Kyber1024")) @staticmethod def encapsulate(public_key: bytes) -> EncapsulationResult: """Encapsulate a shared secret using a public key (no keypair needed).""" from . import _pykyber - return EncapsulationResult(*_wrap_encapsulate(_pykyber._encapsulate_1024)(public_key)) + return EncapsulationResult(*_validate_encapsulate(_pykyber._encapsulate_1024, Kyber1024.PUBLIC_KEY_SIZE, "Kyber1024.encapsulate")(public_key)) diff --git a/python/tests/test_kyber.py b/python/tests/test_kyber.py index a75c183..643d085 100644 --- a/python/tests/test_kyber.py +++ b/python/tests/test_kyber.py @@ -470,7 +470,7 @@ def test_invalid_public_key_length_raises_error(): """Test that invalid public key length raises KyberError.""" with pytest.raises(pykyber.KyberError) as exc_info: pykyber._encapsulate(b"short") - assert "Invalid input for 'pk'" in str(exc_info.value) + assert "Invalid public key" in str(exc_info.value) def test_invalid_ciphertext_length_raises_error(): @@ -478,7 +478,7 @@ def test_invalid_ciphertext_length_raises_error(): sk = bytes(2400) with pytest.raises(pykyber.KyberError) as exc_info: pykyber._decapsulate(b"short", sk) - assert "Invalid input for 'ct'" in str(exc_info.value) + assert "Invalid ciphertext" in str(exc_info.value) def test_invalid_secret_key_length_raises_error(): @@ -493,7 +493,7 @@ def test_empty_public_key_raises_error(): """Test that empty public key raises KyberError.""" with pytest.raises(pykyber.KyberError) as exc_info: pykyber._encapsulate(b"") - assert "Invalid input for 'pk'" in str(exc_info.value) + assert "Invalid public key" in str(exc_info.value) def test_empty_ciphertext_raises_error(): @@ -501,7 +501,7 @@ def test_empty_ciphertext_raises_error(): pk, sk = pykyber._generate_keypair() with pytest.raises(pykyber.KyberError) as exc_info: pykyber._decapsulate(b"", sk) - assert "Invalid input for 'ct'" in str(exc_info.value) + assert "Invalid ciphertext" in str(exc_info.value) def test_empty_secret_key_raises_error(): @@ -519,14 +519,14 @@ def test_very_long_input_raises_error(): long_pk = pk + b"extra" with pytest.raises(pykyber.KyberError) as exc_info: pykyber._encapsulate(long_pk) - assert "Invalid input for 'pk'" in str(exc_info.value) + assert "Invalid public key" in str(exc_info.value) def test_kyber512_invalid_public_key_length(): """Test Kyber512 with invalid public key length.""" with pytest.raises(pykyber.KyberError) as exc_info: pykyber._encapsulate_512(b"short") - assert "Invalid input for 'pk'" in str(exc_info.value) + assert "Invalid public key" in str(exc_info.value) def test_kyber512_invalid_ciphertext_length(): @@ -534,7 +534,7 @@ def test_kyber512_invalid_ciphertext_length(): sk = bytes(1632) with pytest.raises(pykyber.KyberError) as exc_info: pykyber._decapsulate_512(b"short", sk) - assert "Invalid input for 'ct'" in str(exc_info.value) + assert "Invalid ciphertext" in str(exc_info.value) def test_kyber512_invalid_secret_key_length(): @@ -549,7 +549,7 @@ def test_kyber1024_invalid_public_key_length(): """Test Kyber1024 with invalid public key length.""" with pytest.raises(pykyber.KyberError) as exc_info: pykyber._encapsulate_1024(b"short") - assert "Invalid input for 'pk'" in str(exc_info.value) + assert "Invalid public key" in str(exc_info.value) def test_kyber1024_invalid_ciphertext_length(): @@ -557,7 +557,7 @@ def test_kyber1024_invalid_ciphertext_length(): sk = bytes(3168) with pytest.raises(pykyber.KyberError) as exc_info: pykyber._decapsulate_1024(b"short", sk) - assert "Invalid input for 'ct'" in str(exc_info.value) + assert "Invalid ciphertext" in str(exc_info.value) def test_kyber1024_invalid_secret_key_length(): @@ -574,7 +574,7 @@ def test_boundary_public_key_length_512(): short_pk = pk[:-1] with pytest.raises(pykyber.KyberError) as exc_info: pykyber._encapsulate_512(short_pk) - assert "Invalid input for 'pk'" in str(exc_info.value) + assert "Invalid public key" in str(exc_info.value) assert "800" in str(exc_info.value) assert "799" in str(exc_info.value) @@ -585,7 +585,7 @@ def test_boundary_public_key_length_768(): short_pk = pk[:-1] with pytest.raises(pykyber.KyberError) as exc_info: pykyber._encapsulate(short_pk) - assert "Invalid input for 'pk'" in str(exc_info.value) + assert "Invalid public key" in str(exc_info.value) assert "1184" in str(exc_info.value) assert "1183" in str(exc_info.value) @@ -596,7 +596,7 @@ def test_boundary_public_key_length_1024(): short_pk = pk[:-1] with pytest.raises(pykyber.KyberError) as exc_info: pykyber._encapsulate_1024(short_pk) - assert "Invalid input for 'pk'" in str(exc_info.value) + assert "Invalid public key" in str(exc_info.value) assert "1568" in str(exc_info.value) assert "1567" in str(exc_info.value) @@ -638,7 +638,7 @@ def test_boundary_ciphertext_length_512(): short_ct = ct[:-1] with pytest.raises(pykyber.KyberError) as exc_info: pykyber._decapsulate_512(short_ct, sk) - assert "Invalid input for 'ct'" in str(exc_info.value) + assert "Invalid ciphertext" in str(exc_info.value) def test_boundary_ciphertext_length_768(): @@ -648,7 +648,7 @@ def test_boundary_ciphertext_length_768(): short_ct = ct[:-1] with pytest.raises(pykyber.KyberError) as exc_info: pykyber._decapsulate(short_ct, sk) - assert "Invalid input for 'ct'" in str(exc_info.value) + assert "Invalid ciphertext" in str(exc_info.value) def test_boundary_ciphertext_length_1024(): @@ -658,7 +658,7 @@ def test_boundary_ciphertext_length_1024(): short_ct = ct[:-1] with pytest.raises(pykyber.KyberError) as exc_info: pykyber._decapsulate_1024(short_ct, sk) - assert "Invalid input for 'ct'" in str(exc_info.value) + assert "Invalid ciphertext" in str(exc_info.value) def test_error_can_be_caught_as_exception(): @@ -677,7 +677,7 @@ def test_error_message_contains_useful_info(): with pytest.raises(pykyber.KyberError) as exc_info: pykyber._encapsulate(b"x" * 100) msg = str(exc_info.value) - assert "pk" in msg + assert "public key" in msg assert "expected" in msg or "bytes" in msg ct, _ = pykyber._encapsulate(pk) @@ -836,7 +836,7 @@ def safe_encapsulate(public_key): result = safe_encapsulate(b"short") assert "Error:" in result - assert "Invalid input" in result + assert "Invalid" in result pk, _ = pykyber._generate_keypair() result = safe_encapsulate(pk) From 0cc07aed40c2487084cbf5b5b10e72c66c924e53 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sun, 22 Feb 2026 20:29:20 +0200 Subject: [PATCH 20/47] Better python file structure --- .gitignore | 1 + python/pykyber/__init__.py | 10 +-- python/pykyber/_error.py | 6 ++ python/pykyber/_kyber.py | 112 ++-------------------------------- python/pykyber/_types.py | 49 +++++++++++++++ python/pykyber/_validation.py | 56 +++++++++++++++++ 6 files changed, 123 insertions(+), 111 deletions(-) create mode 100644 python/pykyber/_error.py create mode 100644 python/pykyber/_types.py create mode 100644 python/pykyber/_validation.py diff --git a/.gitignore b/.gitignore index 8174a46..b499415 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,4 @@ __pycache__/ .vscode/ *.so *.pyi +.pytest_cache/ diff --git a/python/pykyber/__init__.py b/python/pykyber/__init__.py index 381cdc2..5e5e15a 100644 --- a/python/pykyber/__init__.py +++ b/python/pykyber/__init__.py @@ -11,19 +11,19 @@ KyberError, _validate_encapsulate, _validate_decapsulate, - _wrap_keypair, + _validate_keypair, ) __all__ = ["Kyber512", "Kyber768", "Kyber1024", "KyberError"] from . import _pykyber -_generate_keypair = _wrap_keypair(_pykyber._generate_keypair) +_generate_keypair = _validate_keypair(_pykyber._generate_keypair) _encapsulate = _validate_encapsulate(_pykyber._encapsulate, 1184, "_generate_keypair") _decapsulate = _validate_decapsulate(_pykyber._decapsulate, 1088, "_generate_keypair") -_keypair_512 = _wrap_keypair(_pykyber._keypair_512) -_keypair_768 = _wrap_keypair(_pykyber._keypair_768) -_keypair_1024 = _wrap_keypair(_pykyber._keypair_1024) +_keypair_512 = _validate_keypair(_pykyber._keypair_512) +_keypair_768 = _validate_keypair(_pykyber._keypair_768) +_keypair_1024 = _validate_keypair(_pykyber._keypair_1024) _encapsulate_512 = _validate_encapsulate(_pykyber._encapsulate_512, Kyber512.PUBLIC_KEY_SIZE, "_encapsulate_512") _encapsulate_768 = _validate_encapsulate(_pykyber._encapsulate_768, Kyber768.PUBLIC_KEY_SIZE, "_encapsulate_768") _encapsulate_1024 = _validate_encapsulate(_pykyber._encapsulate_1024, Kyber1024.PUBLIC_KEY_SIZE, "_encapsulate_1024") diff --git a/python/pykyber/_error.py b/python/pykyber/_error.py new file mode 100644 index 0000000..997c1da --- /dev/null +++ b/python/pykyber/_error.py @@ -0,0 +1,6 @@ +"""Kyber error exception.""" + + +class KyberError(Exception): + """Kyber error exception - raised when invalid input is provided.""" + pass diff --git a/python/pykyber/_kyber.py b/python/pykyber/_kyber.py index 73c47cc..2ae13d6 100644 --- a/python/pykyber/_kyber.py +++ b/python/pykyber/_kyber.py @@ -1,108 +1,8 @@ """Kyber post-quantum key encapsulation.""" -from dataclasses import dataclass -from typing import Tuple, Callable - - -class KyberError(Exception): - """Kyber error exception - raised when invalid input is provided.""" - pass - -def _validate_pk(pk: bytes, expected_size: int, method_name: str) -> None: - """Validate public key length with a clear error message.""" - actual_size = len(pk) - if actual_size != expected_size: - raise KyberError( - f"Invalid public key for {method_name}: expected {expected_size} bytes, got {actual_size}. " - f"Ensure you're using the correct Kyber variant (Kyber512={800}, Kyber768={1184}, Kyber1024={1568})." - ) - - -def _validate_encapsulate(fn: Callable[[bytes], Tuple[bytes, bytes]], expected_pk_size: int, method_name: str) -> Callable[[bytes], Tuple[bytes, bytes]]: - """Validate public key and call Rust encapsulate function.""" - def wrapper(pk: bytes) -> Tuple[bytes, bytes]: - _validate_pk(pk, expected_pk_size, method_name) - try: - return fn(pk) - except Exception as e: - raise KyberError(str(e)) from None - return wrapper - - -def _validate_ct(ct: bytes, expected_size: int, method_name: str) -> None: - """Validate ciphertext length with a clear error message.""" - actual_size = len(ct) - if actual_size != expected_size: - raise KyberError( - f"Invalid ciphertext for {method_name}: expected {expected_size} bytes, got {actual_size}." - ) - - -def _validate_decapsulate(fn: Callable[[bytes, bytes], bytes], expected_ct_size: int, method_name: str) -> Callable[[bytes, bytes], bytes]: - """Validate ciphertext and call Rust decapsulate function.""" - def wrapper(ct: bytes, sk: bytes) -> bytes: - _validate_ct(ct, expected_ct_size, method_name) - try: - return fn(ct, sk) - except Exception as e: - raise KyberError(str(e)) from None - return wrapper - - -def _wrap_keypair(fn: Callable[[], Tuple[bytes, bytes]]) -> Callable[[], Tuple[bytes, bytes]]: - """Wrap a Rust keypair function to raise KyberError on failure.""" - def wrapper() -> Tuple[bytes, bytes]: - try: - return fn() - except Exception as e: - raise KyberError(str(e)) from None - return wrapper - - -@dataclass(frozen=True) -class EncapsulationResult: - """Result of a Kyber encapsulation.""" - - ciphertext: bytes - shared_secret: bytes - - def __repr__(self) -> str: - return ( - f"EncapsulationResult(" - f"ciphertext={len(self.ciphertext)} bytes, " - f"shared_secret={len(self.shared_secret)} bytes)" - ) - - -@dataclass -class Keypair: - """Keypair containing private key material with decapsulate method.""" - _secret_key: bytes - _public_key: bytes - _encapsulate_fn: Callable[[bytes], Tuple[bytes, bytes]] - _decapsulate_fn: Callable[[bytes, bytes], bytes] - - def encapsulate(self) -> EncapsulationResult: - """Encapsulate a shared secret using the public key.""" - return EncapsulationResult(*self._encapsulate_fn(self._public_key)) - - - def decapsulate(self, ciphertext: bytes) -> bytes: - """Decapsulate a shared secret using ciphertext.""" - return self._decapsulate_fn(ciphertext, self._secret_key) - - @property - def secret_key(self) -> bytes: - """Return the raw secret key bytes.""" - return self._secret_key - - @property - def public_key(self) -> bytes: - """Return the raw public key bytes.""" - return self._public_key - - def __repr__(self) -> str: - return f"Keypair(secret_key={len(self._secret_key)} bytes, public_key={len(self._public_key)} bytes)" +from ._error import KyberError +from ._types import EncapsulationResult, Keypair +from ._validation import _validate_encapsulate, _validate_decapsulate, _validate_keypair class Kyber512: @@ -116,7 +16,7 @@ class Kyber512: def __new__(cls) -> Keypair: """Generate a new key pair.""" from . import _pykyber - pk, sk = _wrap_keypair(_pykyber._keypair_512)() + pk, sk = _validate_keypair(_pykyber._keypair_512)() return Keypair(sk, pk, _validate_encapsulate(_pykyber._encapsulate_512, Kyber512.PUBLIC_KEY_SIZE, "Kyber512"), _validate_decapsulate(_pykyber._decapsulate_512, Kyber512.CIPHERTEXT_SIZE, "Kyber512")) @@ -139,7 +39,7 @@ class Kyber768: def __new__(cls) -> Keypair: """Generate a new key pair.""" from . import _pykyber - pk, sk = _wrap_keypair(_pykyber._keypair_768)() + pk, sk = _validate_keypair(_pykyber._keypair_768)() return Keypair(sk, pk, _validate_encapsulate(_pykyber._encapsulate_768, Kyber768.PUBLIC_KEY_SIZE, "Kyber768"), _validate_decapsulate(_pykyber._decapsulate_768, Kyber768.CIPHERTEXT_SIZE, "Kyber768")) @@ -162,7 +62,7 @@ class Kyber1024: def __new__(cls) -> Keypair: """Generate a new key pair.""" from . import _pykyber - pk, sk = _wrap_keypair(_pykyber._keypair_1024)() + pk, sk = _validate_keypair(_pykyber._keypair_1024)() return Keypair(sk, pk, _validate_encapsulate(_pykyber._encapsulate_1024, Kyber1024.PUBLIC_KEY_SIZE, "Kyber1024"), _validate_decapsulate(_pykyber._decapsulate_1024, Kyber1024.CIPHERTEXT_SIZE, "Kyber1024")) diff --git a/python/pykyber/_types.py b/python/pykyber/_types.py new file mode 100644 index 0000000..40c3ea9 --- /dev/null +++ b/python/pykyber/_types.py @@ -0,0 +1,49 @@ +"""Kyber types and data structures.""" + +from dataclasses import dataclass +from typing import Tuple, Callable + + +@dataclass(frozen=True) +class EncapsulationResult: + """Result of a Kyber encapsulation.""" + + ciphertext: bytes + shared_secret: bytes + + def __repr__(self) -> str: + return ( + f"EncapsulationResult(" + f"ciphertext={len(self.ciphertext)} bytes, " + f"shared_secret={len(self.shared_secret)} bytes)" + ) + + +@dataclass +class Keypair: + """Keypair containing private key material with decapsulate method.""" + _secret_key: bytes + _public_key: bytes + _encapsulate_fn: Callable[[bytes], Tuple[bytes, bytes]] + _decapsulate_fn: Callable[[bytes, bytes], bytes] + + def encapsulate(self) -> EncapsulationResult: + """Encapsulate a shared secret using the public key.""" + return EncapsulationResult(*self._encapsulate_fn(self._public_key)) + + def decapsulate(self, ciphertext: bytes) -> bytes: + """Decapsulate a shared secret using ciphertext.""" + return self._decapsulate_fn(ciphertext, self._secret_key) + + @property + def secret_key(self) -> bytes: + """Return the raw secret key bytes.""" + return self._secret_key + + @property + def public_key(self) -> bytes: + """Return the raw public key bytes.""" + return self._public_key + + def __repr__(self) -> str: + return f"Keypair(secret_key={len(self._secret_key)} bytes, public_key={len(self._public_key)} bytes)" diff --git a/python/pykyber/_validation.py b/python/pykyber/_validation.py new file mode 100644 index 0000000..8c07e41 --- /dev/null +++ b/python/pykyber/_validation.py @@ -0,0 +1,56 @@ +"""Kyber validation helpers.""" + +from typing import Tuple, Callable + +from ._error import KyberError + + +def _validate_pk(pk: bytes, expected_size: int, method_name: str) -> None: + """Validate public key length with a clear error message.""" + actual_size = len(pk) + if actual_size != expected_size: + raise KyberError( + f"Invalid public key for {method_name}: expected {expected_size} bytes, got {actual_size}. " + f"Ensure you're using the correct Kyber variant (Kyber512={800}, Kyber768={1184}, Kyber1024={1568})." + ) + + +def _validate_encapsulate(fn: Callable[[bytes], Tuple[bytes, bytes]], expected_pk_size: int, method_name: str) -> Callable[[bytes], Tuple[bytes, bytes]]: + """Validate public key and call Rust encapsulate function.""" + def wrapper(pk: bytes) -> Tuple[bytes, bytes]: + _validate_pk(pk, expected_pk_size, method_name) + try: + return fn(pk) + except Exception as e: + raise KyberError(str(e)) from None + return wrapper + + +def _validate_ct(ct: bytes, expected_size: int, method_name: str) -> None: + """Validate ciphertext length with a clear error message.""" + actual_size = len(ct) + if actual_size != expected_size: + raise KyberError( + f"Invalid ciphertext for {method_name}: expected {expected_size} bytes, got {actual_size}." + ) + + +def _validate_decapsulate(fn: Callable[[bytes, bytes], bytes], expected_ct_size: int, method_name: str) -> Callable[[bytes, bytes], bytes]: + """Validate ciphertext and call Rust decapsulate function.""" + def wrapper(ct: bytes, sk: bytes) -> bytes: + _validate_ct(ct, expected_ct_size, method_name) + try: + return fn(ct, sk) + except Exception as e: + raise KyberError(str(e)) from None + return wrapper + + +def _validate_keypair(fn: Callable[[], Tuple[bytes, bytes]]) -> Callable[[], Tuple[bytes, bytes]]: + """Wrap a Rust keypair function to raise KyberError on failure.""" + def wrapper() -> Tuple[bytes, bytes]: + try: + return fn() + except Exception as e: + raise KyberError(str(e)) from None + return wrapper From 36b5fe0eef6c872c205e073c019dad36dcf106d0 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sun, 22 Feb 2026 20:31:00 +0200 Subject: [PATCH 21/47] Bump version to 0.1.4 --- Cargo.lock | 2 +- Cargo.toml | 2 +- pyproject.toml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 6a0b370..5932e54 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -87,7 +87,7 @@ dependencies = [ [[package]] name = "pykyber" -version = "0.1.3" +version = "0.1.4" dependencies = [ "pyo3", "rand", diff --git a/Cargo.toml b/Cargo.toml index 53284f4..eb52936 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pykyber" -version = "0.1.3" +version = "0.1.4" edition = "2021" [lib] diff --git a/pyproject.toml b/pyproject.toml index 7f49159..d8f7c98 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "maturin" [project] name = "pykyber" -version = "0.1.3" +version = "0.1.4" description = "Kyber post-quantum key encapsulation in Rust" readme = "README.md" requires-python = ">=3.8" From 80c04110f95c56486959e4b105ecaee74a01a71e Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sun, 22 Feb 2026 20:38:11 +0200 Subject: [PATCH 22/47] Add error handling section to README --- README.md | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index d43a81d..d5fc4b0 100644 --- a/README.md +++ b/README.md @@ -28,10 +28,6 @@ print(f"Match: {bob_result.shared_secret == shared_secret}") ## API Usage -### Class-based API (Recommended) - -The simplest way to use Kyber: - ```python import pykyber @@ -62,6 +58,27 @@ shared_secret = keypair.decapsulate(result.ciphertext) | Kyber-1024| 1568 bytes | 3168 bytes | 1408 bytes | 32 bytes | +## Error Handling + +All operations raise `KyberError` when invalid input is provided: + +```python +import pykyber + +try: + pykyber.Kyber768.encapsulate(b"too_short") +except pykyber.KyberError as e: + print(e) +# Output: Invalid public key for Kyber768.encapsulate: expected 1184 bytes, got 10. +# Ensure you're using the correct Kyber variant (Kyber512=800, Kyber768=1184, Kyber1024=1568). +``` + +Common error cases: +- **Invalid public key size**: Wrong number of bytes for the Kyber variant +- **Invalid ciphertext size**: Wrong number of bytes when decapsulating +- **Invalid secret key size**: Wrong number of bytes for the Kyber variant + + ## License MIT From 6a7228bf4eb31b776e6998ffe389d8447e51bb1b Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sun, 22 Feb 2026 20:58:37 +0200 Subject: [PATCH 23/47] Bump version to 0.1.5 --- Cargo.lock | 2 +- Cargo.toml | 2 +- pyproject.toml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 5932e54..4a037fc 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -87,7 +87,7 @@ dependencies = [ [[package]] name = "pykyber" -version = "0.1.4" +version = "0.1.5" dependencies = [ "pyo3", "rand", diff --git a/Cargo.toml b/Cargo.toml index eb52936..41a8778 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pykyber" -version = "0.1.4" +version = "0.1.5" edition = "2021" [lib] diff --git a/pyproject.toml b/pyproject.toml index d8f7c98..649a5bf 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "maturin" [project] name = "pykyber" -version = "0.1.4" +version = "0.1.5" description = "Kyber post-quantum key encapsulation in Rust" readme = "README.md" requires-python = ">=3.8" From f886d7011ee8d4eb3803533f727998aed2e763b3 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Mon, 23 Feb 2026 13:04:51 +0200 Subject: [PATCH 24/47] Added new decapsulate feature You can now decapsulate with your own custom private key. ```python shared_secret = pykyber.Kyber768.decapsulate(ciphertext, secret_key) ``` --- Cargo.lock | 2 +- Cargo.toml | 2 +- README.md | 8 +++ pyproject.toml | 4 +- python/pykyber/_kyber.py | 18 +++++++ python/tests/test_kyber.py | 101 +++++++++++++++++++++++++++++++++++++ 6 files changed, 131 insertions(+), 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 4a037fc..92c189f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -87,7 +87,7 @@ dependencies = [ [[package]] name = "pykyber" -version = "0.1.5" +version = "0.1.6" dependencies = [ "pyo3", "rand", diff --git a/Cargo.toml b/Cargo.toml index 41a8778..86177a1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pykyber" -version = "0.1.5" +version = "0.1.6" edition = "2021" [lib] diff --git a/README.md b/README.md index d5fc4b0..9836e89 100644 --- a/README.md +++ b/README.md @@ -47,6 +47,14 @@ result = keypair.encapsulate() # Decapsulate - recover shared secret from ciphertext shared_secret = keypair.decapsulate(result.ciphertext) + +# Static methods - use without creating a keypair instance + +# Encapsulate with just a public key +result = pykyber.Kyber768.encapsulate(public_key) + +# Decapsulate with just ciphertext and secret key +shared_secret = pykyber.Kyber768.decapsulate(ciphertext, secret_key) ``` ## Key Sizes diff --git a/pyproject.toml b/pyproject.toml index 649a5bf..4b548f9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,13 +4,13 @@ build-backend = "maturin" [project] name = "pykyber" -version = "0.1.5" +version = "0.1.6" description = "Kyber post-quantum key encapsulation in Rust" readme = "README.md" requires-python = ">=3.8" license = {text = "MIT"} authors = [ - {name = "PyKyber Contributors"} + {name = "Yoav Haimov"} ] keywords = ["kyber", "post-quantum", "cryptography", "pqc", "key-encapsulation"] classifiers = [ diff --git a/python/pykyber/_kyber.py b/python/pykyber/_kyber.py index 2ae13d6..404633e 100644 --- a/python/pykyber/_kyber.py +++ b/python/pykyber/_kyber.py @@ -26,6 +26,12 @@ def encapsulate(public_key: bytes) -> EncapsulationResult: """Encapsulate a shared secret using a public key (no keypair needed).""" from . import _pykyber return EncapsulationResult(*_validate_encapsulate(_pykyber._encapsulate_512, Kyber512.PUBLIC_KEY_SIZE, "Kyber512.encapsulate")(public_key)) + + @staticmethod + def decapsulate(ciphertext: bytes, secret_key: bytes) -> bytes: + """Decapsulate a shared secret using ciphertext and secret key (no keypair needed).""" + from . import _pykyber + return _validate_decapsulate(_pykyber._decapsulate_512, Kyber512.CIPHERTEXT_SIZE, "Kyber512.decapsulate")(ciphertext, secret_key) class Kyber768: @@ -49,6 +55,12 @@ def encapsulate(public_key: bytes) -> EncapsulationResult: """Encapsulate a shared secret using a public key (no keypair needed).""" from . import _pykyber return EncapsulationResult(*_validate_encapsulate(_pykyber._encapsulate_768, Kyber768.PUBLIC_KEY_SIZE, "Kyber768.encapsulate")(public_key)) + + @staticmethod + def decapsulate(ciphertext: bytes, secret_key: bytes) -> bytes: + """Decapsulate a shared secret using ciphertext and secret key (no keypair needed).""" + from . import _pykyber + return _validate_decapsulate(_pykyber._decapsulate_768, Kyber768.CIPHERTEXT_SIZE, "Kyber768.decapsulate")(ciphertext, secret_key) class Kyber1024: @@ -72,3 +84,9 @@ def encapsulate(public_key: bytes) -> EncapsulationResult: """Encapsulate a shared secret using a public key (no keypair needed).""" from . import _pykyber return EncapsulationResult(*_validate_encapsulate(_pykyber._encapsulate_1024, Kyber1024.PUBLIC_KEY_SIZE, "Kyber1024.encapsulate")(public_key)) + + @staticmethod + def decapsulate(ciphertext: bytes, secret_key: bytes) -> bytes: + """Decapsulate a shared secret using ciphertext and secret key (no keypair needed).""" + from . import _pykyber + return _validate_decapsulate(_pykyber._decapsulate_1024, Kyber1024.CIPHERTEXT_SIZE, "Kyber1024.decapsulate")(ciphertext, secret_key) diff --git a/python/tests/test_kyber.py b/python/tests/test_kyber.py index 643d085..f420f38 100644 --- a/python/tests/test_kyber.py +++ b/python/tests/test_kyber.py @@ -1134,3 +1134,104 @@ def test_concurrent_error_handling(): except Exception as e: if "panicked" not in str(e).lower(): raise AssertionError(f"Unexpected non-panic error: {e}") + + +# Static decapsulate method tests + +def test_static_decapsulate_kyber512(): + """Test static decapsulate method for Kyber512.""" + pk, sk = pykyber._keypair_512() + ct, ss = pykyber._encapsulate_512(pk) + ss_dec = pykyber.Kyber512.decapsulate(ct, sk) + assert ss == ss_dec + + +def test_static_decapsulate_kyber768(): + """Test static decapsulate method for Kyber768.""" + pk, sk = pykyber._keypair_768() + ct, ss = pykyber._encapsulate_768(pk) + ss_dec = pykyber.Kyber768.decapsulate(ct, sk) + assert ss == ss_dec + + +def test_static_decapsulate_kyber1024(): + """Test static decapsulate method for Kyber1024.""" + pk, sk = pykyber._keypair_1024() + ct, ss = pykyber._encapsulate_1024(pk) + ss_dec = pykyber.Kyber1024.decapsulate(ct, sk) + assert ss == ss_dec + + +def test_static_decapsulate_vs_instance_decapsulate_kyber512(): + """Test that static and instance decapsulate produce same result (Kyber512).""" + keypair = pykyber.Kyber512() + result = keypair.encapsulate() + ss_instance = keypair.decapsulate(result.ciphertext) + ss_static = pykyber.Kyber512.decapsulate(result.ciphertext, keypair.secret_key) + assert ss_instance == ss_static + + +def test_static_decapsulate_vs_instance_decapsulate_kyber768(): + """Test that static and instance decapsulate produce same result (Kyber768).""" + keypair = pykyber.Kyber768() + result = keypair.encapsulate() + ss_instance = keypair.decapsulate(result.ciphertext) + ss_static = pykyber.Kyber768.decapsulate(result.ciphertext, keypair.secret_key) + assert ss_instance == ss_static + + +def test_static_decapsulate_vs_instance_decapsulate_kyber1024(): + """Test that static and instance decapsulate produce same result (Kyber1024).""" + keypair = pykyber.Kyber1024() + result = keypair.encapsulate() + ss_instance = keypair.decapsulate(result.ciphertext) + ss_static = pykyber.Kyber1024.decapsulate(result.ciphertext, keypair.secret_key) + assert ss_instance == ss_static + + +def test_static_decapsulate_invalid_ciphertext_length_kyber512(): + """Test static decapsulate with invalid ciphertext length (Kyber512).""" + sk = bytes(1632) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber.Kyber512.decapsulate(b"short", sk) + assert "Invalid ciphertext" in str(exc_info.value) + + +def test_static_decapsulate_invalid_secret_key_length_kyber512(): + """Test static decapsulate with invalid secret key length (Kyber512).""" + ct = bytes(768) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber.Kyber512.decapsulate(ct, b"short") + assert "Invalid input for 'sk'" in str(exc_info.value) + + +def test_static_decapsulate_invalid_ciphertext_length_kyber768(): + """Test static decapsulate with invalid ciphertext length (Kyber768).""" + sk = bytes(2400) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber.Kyber768.decapsulate(b"short", sk) + assert "Invalid ciphertext" in str(exc_info.value) + + +def test_static_decapsulate_invalid_secret_key_length_kyber768(): + """Test static decapsulate with invalid secret key length (Kyber768).""" + ct = bytes(1088) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber.Kyber768.decapsulate(ct, b"short") + assert "Invalid input for 'sk'" in str(exc_info.value) + + +def test_static_decapsulate_invalid_ciphertext_length_kyber1024(): + """Test static decapsulate with invalid ciphertext length (Kyber1024).""" + sk = bytes(3168) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber.Kyber1024.decapsulate(b"short", sk) + assert "Invalid ciphertext" in str(exc_info.value) + + +def test_static_decapsulate_invalid_secret_key_length_kyber1024(): + """Test static decapsulate with invalid secret key length (Kyber1024).""" + ct = bytes(1408) + with pytest.raises(pykyber.KyberError) as exc_info: + pykyber.Kyber1024.decapsulate(ct, b"short") + assert "Invalid input for 'sk'" in str(exc_info.value) From f726e397606bb4418f8f7b4e3c3092b24d39d59b Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Mon, 23 Feb 2026 13:41:38 +0200 Subject: [PATCH 25/47] Added stress tests and grpahs from it --- Makefile | 5 +- README.md | 31 +++ performance-tests/benchmark.py | 238 ++++++++++++++++ performance-tests/operation_breakdown.png | Bin 0 -> 54603 bytes performance-tests/performance_comparison.png | Bin 0 -> 55960 bytes performance-tests/scalability.png | Bin 0 -> 113130 bytes performance-tests/throughput.png | Bin 0 -> 71679 bytes python/tests/test_kyber.py | 271 +++++++++++++++++++ 8 files changed, 544 insertions(+), 1 deletion(-) create mode 100644 performance-tests/benchmark.py create mode 100644 performance-tests/operation_breakdown.png create mode 100644 performance-tests/performance_comparison.png create mode 100644 performance-tests/scalability.png create mode 100644 performance-tests/throughput.png diff --git a/Makefile b/Makefile index 65f4ef6..bcb3b2d 100644 --- a/Makefile +++ b/Makefile @@ -12,4 +12,7 @@ dev-build-pyi: dev-build-package clean: rm ./python/pykyber/*.so rm ./python/pykyber/_pykyber.pyi - rm -rf ./target/ \ No newline at end of file + rm -rf ./target/ + +benchmark: + .venv/bin/python performance-tests/benchmark.py \ No newline at end of file diff --git a/README.md b/README.md index 9836e89..1ed309d 100644 --- a/README.md +++ b/README.md @@ -87,6 +87,37 @@ Common error cases: - **Invalid secret key size**: Wrong number of bytes for the Kyber variant +## Performance + +Performance benchmarks (100 iterations each): + +| Variant | Keypair | Encapsulate | Decapsulate | +|---------|---------|-------------|-------------| +| Kyber512 | 0.27 ms (3,667/s) | 0.39 ms (2,548/s) | 0.48 ms (2,101/s) | +| Kyber768 | 0.48 ms (2,069/s) | 0.62 ms (1,605/s) | 0.78 ms (1,279/s) | +| Kyber1024 | 0.78 ms (1,289/s) | 0.94 ms (1,064/s) | 1.04 ms (959/s) | + +Run benchmarks and generate graphs: + +```bash +make benchmark +``` + +Generated graphs: + +### Performance Comparison +![Performance Comparison](performance-tests/performance_comparison.png) + +### Operation Breakdown +![Operation Breakdown](performance-tests/operation_breakdown.png) + +### Scalability +![Scalability](performance-tests/scalability.png) + +### Throughput +![Throughput](performance-tests/throughput.png) + + ## License MIT diff --git a/performance-tests/benchmark.py b/performance-tests/benchmark.py new file mode 100644 index 0000000..e50c5b2 --- /dev/null +++ b/performance-tests/benchmark.py @@ -0,0 +1,238 @@ +#!/usr/bin/env python3 +"""Performance benchmarking and graphing script for pykyber. + +This script runs the performance tests from python/tests/test_kyber.py +and generates graphs from the results. +""" + +import subprocess +import re +import matplotlib.pyplot as plt + + +def run_performance_tests(): + """Run pytest performance tests and parse results.""" + result = subprocess.run( + ['.venv/bin/python', '-m', 'pytest', + 'python/tests/test_kyber.py', + '-v', '-k', 'performance', + '--tb=no', '-q', '-s'], + capture_output=True, + text=True + ) + + output = result.stdout + result.stderr + + results = { + 'Kyber512': {}, + 'Kyber768': {}, + 'Kyber1024': {} + } + + pattern = r'Kyber(\d+)\s+(keypair generation|encapsulation|decapsulation|full key exchange.*?):\s+([\d.]+)\s+ms/op' + + for match in re.finditer(pattern, output): + variant = f"Kyber{match.group(1)}" + operation = match.group(2).strip() + time_ms = float(match.group(3)) + + if 'keypair generation' in operation: + results[variant]['keypair'] = time_ms + elif 'encapsulation' in operation: + results[variant]['encapsulate'] = time_ms + elif 'decapsulation' in operation: + results[variant]['decapsulate'] = time_ms + elif 'class API' in operation: + results[variant]['class_api'] = time_ms + elif 'static methods' in operation: + results[variant]['static_methods'] = time_ms + + return results + + +def create_comparison_chart(results): + """Create a comparison chart across all variants and operations.""" + variants = ['Kyber512', 'Kyber768', 'Kyber1024'] + + x = range(len(variants)) + width = 0.25 + + fig, ax = plt.subplots(figsize=(12, 6)) + + keypair_times = [results[v]['keypair'] for v in variants] + encapsulate_times = [results[v]['encapsulate'] for v in variants] + decapsulate_times = [results[v]['decapsulate'] for v in variants] + + bars1 = ax.bar([i - width for i in x], keypair_times, width, label='Keypair Generation', color='#2ecc71') + bars2 = ax.bar(x, encapsulate_times, width, label='Encapsulation', color='#3498db') + bars3 = ax.bar([i + width for i in x], decapsulate_times, width, label='Decapsulation', color='#e74c3c') + + ax.set_xlabel('Kyber Variant', fontsize=12) + ax.set_ylabel('Time (ms)', fontsize=12) + ax.set_title('PyKyber Performance Comparison', fontsize=14, fontweight='bold') + ax.set_xticks(x) + ax.set_xticklabels(variants) + ax.legend() + ax.grid(axis='y', alpha=0.3) + + for bars in [bars1, bars2, bars3]: + for bar in bars: + height = bar.get_height() + ax.annotate(f'{height:.2f}', + xy=(bar.get_x() + bar.get_width() / 2, height), + xytext=(0, 3), + textcoords="offset points", + ha='center', va='bottom', fontsize=8) + + plt.tight_layout() + plt.savefig('performance-tests/performance_comparison.png', dpi=150) + print("Saved: performance-tests/performance_comparison.png") + plt.close() + + +def create_operation_breakdown(results): + """Create individual charts for each operation.""" + variants = ['Kyber512', 'Kyber768', 'Kyber1024'] + colors = ['#2ecc71', '#3498db', '#e74c3c'] + + fig, axes = plt.subplots(1, 3, figsize=(15, 5)) + + operations = ['keypair', 'encapsulate', 'decapsulate'] + titles = ['Keypair Generation', 'Encapsulation', 'Decapsulation'] + + for idx, (op, title) in enumerate(zip(operations, titles)): + times = [results[v][op] for v in variants] + bars = axes[idx].bar(variants, times, color=colors) + axes[idx].set_title(title, fontsize=12, fontweight='bold') + axes[idx].set_ylabel('Time (ms)') + axes[idx].grid(axis='y', alpha=0.3) + + for bar in bars: + height = bar.get_height() + axes[idx].annotate(f'{height:.2f}', + xy=(bar.get_x() + bar.get_width() / 2, height), + xytext=(0, 3), + textcoords="offset points", + ha='center', va='bottom', fontsize=10) + + plt.tight_layout() + plt.savefig('performance-tests/operation_breakdown.png', dpi=150) + print("Saved: performance-tests/operation_breakdown.png") + plt.close() + + +def create_scalability_chart(results): + """Create a chart showing how performance scales with security level.""" + variants = ['Kyber512', 'Kyber768', 'Kyber1024'] + security_levels = ['~AES-128', '~AES-192', '~AES-256'] + + keypair_times = [results[v]['keypair'] for v in variants] + encapsulate_times = [results[v]['encapsulate'] for v in variants] + decapsulate_times = [results[v]['decapsulate'] for v in variants] + + fig, ax = plt.subplots(figsize=(10, 6)) + + x = range(len(variants)) + + ax.plot(x, keypair_times, 'o-', linewidth=2, markersize=8, label='Keypair Generation', color='#2ecc71') + ax.plot(x, encapsulate_times, 's-', linewidth=2, markersize=8, label='Encapsulation', color='#3498db') + ax.plot(x, decapsulate_times, '^-', linewidth=2, markersize=8, label='Decapsulation', color='#e74c3c') + + ax.set_xticks(x) + ax.set_xticklabels([f'{v}\n({s})' for v, s in zip(variants, security_levels)]) + ax.set_xlabel('Kyber Variant (Security Level)', fontsize=12) + ax.set_ylabel('Time (ms)', fontsize=12) + ax.set_title('PyKyber Performance Scalability', fontsize=14, fontweight='bold') + ax.legend() + ax.grid(alpha=0.3) + + for i, variant in enumerate(variants): + for j, (data, label) in enumerate([(keypair_times, 'keypair'), + (encapsulate_times, 'encapsulate'), + (decapsulate_times, 'decapsulate')]): + ax.annotate(f'{data[i]:.2f}', + (i, data[i]), + textcoords="offset points", + xytext=(0, 10), + ha='center', fontsize=8) + + plt.tight_layout() + plt.savefig('performance-tests/scalability.png', dpi=150) + print("Saved: performance-tests/scalability.png") + plt.close() + + +def create_throughput_chart(results): + """Create a throughput chart showing operations per second.""" + variants = ['Kyber512', 'Kyber768', 'Kyber1024'] + + keypair_ops = [1000 / results[v]['keypair'] for v in variants] + encapsulate_ops = [1000 / results[v]['encapsulate'] for v in variants] + decapsulate_ops = [1000 / results[v]['decapsulate'] for v in variants] + + fig, ax = plt.subplots(figsize=(10, 6)) + + x = range(len(variants)) + width = 0.25 + + bars1 = ax.bar([i - width for i in x], keypair_ops, width, label='Keypair Generation', color='#2ecc71') + bars2 = ax.bar(x, encapsulate_ops, width, label='Encapsulation', color='#3498db') + bars3 = ax.bar([i + width for i in x], decapsulate_ops, width, label='Decapsulation', color='#e74c3c') + + ax.set_xlabel('Kyber Variant', fontsize=12) + ax.set_ylabel('Operations per Second', fontsize=12) + ax.set_title('PyKyber Throughput (Operations per Second)', fontsize=14, fontweight='bold') + ax.set_xticks(x) + ax.set_xticklabels(variants) + ax.legend() + ax.grid(axis='y', alpha=0.3) + + for bars in [bars1, bars2, bars3]: + for bar in bars: + height = bar.get_height() + ax.annotate(f'{int(height)}', + xy=(bar.get_x() + bar.get_width() / 2, height), + xytext=(0, 3), + textcoords="offset points", + ha='center', va='bottom', fontsize=8) + + plt.tight_layout() + plt.savefig('performance-tests/throughput.png', dpi=150) + print("Saved: performance-tests/throughput.png") + plt.close() + + +def print_summary(results): + """Print a summary table of results.""" + print("\n" + "=" * 60) + print("PyKyber Performance Summary (100 iterations each)") + print("=" * 60) + print(f"{'Variant':<12} {'Keypair (ms)':<15} {'Encapsulate (ms)':<18} {'Decapsulate (ms)':<18}") + print("-" * 60) + for variant in ['Kyber512', 'Kyber768', 'Kyber1024']: + r = results[variant] + print(f"{variant:<12} {r['keypair']:<15.3f} {r['encapsulate']:<18.3f} {r['decapsulate']:<18.3f}") + print("=" * 60) + + print("\nThroughput (operations/second):") + print("-" * 60) + print(f"{'Variant':<12} {'Keypair/s':<15} {'Encapsulate/s':<18} {'Decapsulate/s':<18}") + print("-" * 60) + for variant in ['Kyber512', 'Kyber768', 'Kyber1024']: + r = results[variant] + kp_ops = int(1000 / r['keypair']) + enc_ops = int(1000 / r['encapsulate']) + dec_ops = int(1000 / r['decapsulate']) + print(f"{variant:<12} {kp_ops:<15} {enc_ops:<18} {dec_ops:<18}") + print("=" * 60) + + +if __name__ == '__main__': + print("Running performance tests from python/tests/test_kyber.py...") + results = run_performance_tests() + print_summary(results) + create_comparison_chart(results) + create_operation_breakdown(results) + create_scalability_chart(results) + create_throughput_chart(results) + print("\nAll graphs saved in performance-tests/") diff --git a/performance-tests/operation_breakdown.png b/performance-tests/operation_breakdown.png new file mode 100644 index 0000000000000000000000000000000000000000..4e4fd0cde47dcb0d32854fb26cdb8b3117c134b4 GIT binary patch literal 54603 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

Z_XIgQ^1&n~0(~v&H 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 literal 0 HcmV?d00001 diff --git a/performance-tests/scalability.png b/performance-tests/scalability.png new file mode 100644 index 0000000000000000000000000000000000000000..4a1f742cfe4584f68fcdbdeaf950d70ba6bce3bc GIT binary patch literal 113130 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 literal 0 HcmV?d00001 diff --git a/performance-tests/throughput.png b/performance-tests/throughput.png new file mode 100644 index 0000000000000000000000000000000000000000..3eb36cd6c8794c8b2555a58335f06ba055b43dc2 GIT binary patch literal 71679 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 literal 0 HcmV?d00001 diff --git a/python/tests/test_kyber.py b/python/tests/test_kyber.py index f420f38..fb7792c 100644 --- a/python/tests/test_kyber.py +++ b/python/tests/test_kyber.py @@ -1235,3 +1235,274 @@ def test_static_decapsulate_invalid_secret_key_length_kyber1024(): with pytest.raises(pykyber.KyberError) as exc_info: pykyber.Kyber1024.decapsulate(ct, b"short") assert "Invalid input for 'sk'" in str(exc_info.value) + + +# Stress tests + +def test_stress_kyber512_many_operations(): + """Stress test: many keypair generations and encapsulations (Kyber512).""" + for _ in range(1000): + pk, sk = pykyber._keypair_512() + ct, ss = pykyber._encapsulate_512(pk) + ss_dec = pykyber._decapsulate_512(ct, sk) + assert ss == ss_dec + + +def test_stress_kyber768_many_operations(): + """Stress test: many keypair generations and encapsulations (Kyber768).""" + for _ in range(1000): + pk, sk = pykyber._keypair_768() + ct, ss = pykyber._encapsulate_768(pk) + ss_dec = pykyber._decapsulate_768(ct, sk) + assert ss == ss_dec + + +def test_stress_kyber1024_many_operations(): + """Stress test: many keypair generations and encapsulations (Kyber1024).""" + for _ in range(1000): + pk, sk = pykyber._keypair_1024() + ct, ss = pykyber._encapsulate_1024(pk) + ss_dec = pykyber._decapsulate_1024(ct, sk) + assert ss == ss_dec + + +def test_stress_class_api_kyber512(): + """Stress test: class API with many operations (Kyber512).""" + for _ in range(1000): + keypair = pykyber.Kyber512() + result = keypair.encapsulate() + ss = keypair.decapsulate(result.ciphertext) + assert result.shared_secret == ss + + +def test_stress_class_api_kyber768(): + """Stress test: class API with many operations (Kyber768).""" + for _ in range(1000): + keypair = pykyber.Kyber768() + result = keypair.encapsulate() + ss = keypair.decapsulate(result.ciphertext) + assert result.shared_secret == ss + + +def test_stress_class_api_kyber1024(): + """Stress test: class API with many operations (Kyber1024).""" + for _ in range(1000): + keypair = pykyber.Kyber1024() + result = keypair.encapsulate() + ss = keypair.decapsulate(result.ciphertext) + assert result.shared_secret == ss + + +def test_stress_static_methods_kyber512(): + """Stress test: static methods without keypair (Kyber512).""" + for _ in range(1000): + pk, sk = pykyber._keypair_512() + result = pykyber.Kyber512.encapsulate(pk) + ss = pykyber.Kyber512.decapsulate(result.ciphertext, sk) + assert result.shared_secret == ss + + +def test_stress_static_methods_kyber768(): + """Stress test: static methods without keypair (Kyber768).""" + for _ in range(1000): + pk, sk = pykyber._keypair_768() + result = pykyber.Kyber768.encapsulate(pk) + ss = pykyber.Kyber768.decapsulate(result.ciphertext, sk) + assert result.shared_secret == ss + + +def test_stress_static_methods_kyber1024(): + """Stress test: static methods without keypair (Kyber1024).""" + for _ in range(1000): + pk, sk = pykyber._keypair_1024() + result = pykyber.Kyber1024.encapsulate(pk) + ss = pykyber.Kyber1024.decapsulate(result.ciphertext, sk) + assert result.shared_secret == ss + + +def test_stress_mixed_variants(): + """Stress test: mixed variants in sequence.""" + for _ in range(333): + pk_512, sk_512 = pykyber._keypair_512() + ct_512, ss_512 = pykyber._encapsulate_512(pk_512) + ss_512_dec = pykyber._decapsulate_512(ct_512, sk_512) + assert ss_512 == ss_512_dec + + pk_768, sk_768 = pykyber._keypair_768() + ct_768, ss_768 = pykyber._encapsulate_768(pk_768) + ss_768_dec = pykyber._decapsulate_768(ct_768, sk_768) + assert ss_768 == ss_768_dec + + pk_1024, sk_1024 = pykyber._keypair_1024() + ct_1024, ss_1024 = pykyber._encapsulate_1024(pk_1024) + ss_1024_dec = pykyber._decapsulate_1024(ct_1024, sk_1024) + assert ss_1024 == ss_1024_dec + + +# Performance tests + +def test_performance_kyber512_keypair_generation(): + """Performance test: measure time for 100 keypair generations (Kyber512).""" + import time + iterations = 100 + + start = time.perf_counter() + for _ in range(iterations): + pykyber._keypair_512() + elapsed = time.perf_counter() - start + + print(f"\nKyber512 keypair generation: {elapsed/iterations*1000:.3f} ms/op ({iterations} iterations)") + assert elapsed < 5.0 # Should complete 100 iterations in under 5 seconds + + +def test_performance_kyber768_keypair_generation(): + """Performance test: measure time for 100 keypair generations (Kyber768).""" + import time + iterations = 100 + + start = time.perf_counter() + for _ in range(iterations): + pykyber._keypair_768() + elapsed = time.perf_counter() - start + + print(f"\nKyber768 keypair generation: {elapsed/iterations*1000:.3f} ms/op ({iterations} iterations)") + assert elapsed < 5.0 + + +def test_performance_kyber1024_keypair_generation(): + """Performance test: measure time for 100 keypair generations (Kyber1024).""" + import time + iterations = 100 + + start = time.perf_counter() + for _ in range(iterations): + pykyber._keypair_1024() + elapsed = time.perf_counter() - start + + print(f"\nKyber1024 keypair generation: {elapsed/iterations*1000:.3f} ms/op ({iterations} iterations)") + assert elapsed < 5.0 + + +def test_performance_kyber512_encapsulation(): + """Performance test: measure time for 100 encapsulations (Kyber512).""" + import time + pk, _ = pykyber._keypair_512() + iterations = 100 + + start = time.perf_counter() + for _ in range(iterations): + pykyber._encapsulate_512(pk) + elapsed = time.perf_counter() - start + + print(f"\nKyber512 encapsulation: {elapsed/iterations*1000:.3f} ms/op ({iterations} iterations)") + assert elapsed < 5.0 + + +def test_performance_kyber768_encapsulation(): + """Performance test: measure time for 100 encapsulations (Kyber768).""" + import time + pk, _ = pykyber._keypair_768() + iterations = 100 + + start = time.perf_counter() + for _ in range(iterations): + pykyber._encapsulate_768(pk) + elapsed = time.perf_counter() - start + + print(f"\nKyber768 encapsulation: {elapsed/iterations*1000:.3f} ms/op ({iterations} iterations)") + assert elapsed < 5.0 + + +def test_performance_kyber1024_encapsulation(): + """Performance test: measure time for 100 encapsulations (Kyber1024).""" + import time + pk, _ = pykyber._keypair_1024() + iterations = 100 + + start = time.perf_counter() + for _ in range(iterations): + pykyber._encapsulate_1024(pk) + elapsed = time.perf_counter() - start + + print(f"\nKyber1024 encapsulation: {elapsed/iterations*1000:.3f} ms/op ({iterations} iterations)") + assert elapsed < 5.0 + + +def test_performance_kyber512_decapsulation(): + """Performance test: measure time for 100 decapsulations (Kyber512).""" + import time + pk, sk = pykyber._keypair_512() + ct, _ = pykyber._encapsulate_512(pk) + iterations = 100 + + start = time.perf_counter() + for _ in range(iterations): + pykyber._decapsulate_512(ct, sk) + elapsed = time.perf_counter() - start + + print(f"\nKyber512 decapsulation: {elapsed/iterations*1000:.3f} ms/op ({iterations} iterations)") + assert elapsed < 5.0 + + +def test_performance_kyber768_decapsulation(): + """Performance test: measure time for 100 decapsulations (Kyber768).""" + import time + pk, sk = pykyber._keypair_768() + ct, _ = pykyber._encapsulate_768(pk) + iterations = 100 + + start = time.perf_counter() + for _ in range(iterations): + pykyber._decapsulate_768(ct, sk) + elapsed = time.perf_counter() - start + + print(f"\nKyber768 decapsulation: {elapsed/iterations*1000:.3f} ms/op ({iterations} iterations)") + assert elapsed < 5.0 + + +def test_performance_kyber1024_decapsulation(): + """Performance test: measure time for 100 decapsulations (Kyber1024).""" + import time + pk, sk = pykyber._keypair_1024() + ct, _ = pykyber._encapsulate_1024(pk) + iterations = 100 + + start = time.perf_counter() + for _ in range(iterations): + pykyber._decapsulate_1024(ct, sk) + elapsed = time.perf_counter() - start + + print(f"\nKyber1024 decapsulation: {elapsed/iterations*1000:.3f} ms/op ({iterations} iterations)") + assert elapsed < 5.0 + + +def test_performance_class_api_kyber768(): + """Performance test: class API full key exchange (Kyber768).""" + import time + iterations = 100 + + start = time.perf_counter() + for _ in range(iterations): + keypair = pykyber.Kyber768() + result = keypair.encapsulate() + keypair.decapsulate(result.ciphertext) + elapsed = time.perf_counter() - start + + print(f"\nKyber768 full key exchange (class API): {elapsed/iterations*1000:.3f} ms/op ({iterations} iterations)") + assert elapsed < 5.0 + + +def test_performance_static_methods_kyber768(): + """Performance test: static methods full key exchange (Kyber768).""" + import time + iterations = 100 + + start = time.perf_counter() + for _ in range(iterations): + pk, sk = pykyber._keypair_768() + result = pykyber.Kyber768.encapsulate(pk) + pykyber.Kyber768.decapsulate(result.ciphertext, sk) + elapsed = time.perf_counter() - start + + print(f"\nKyber768 full key exchange (static methods): {elapsed/iterations*1000:.3f} ms/op ({iterations} iterations)") + assert elapsed < 5.0 From 1cb2743c6e82cf997eb3e59592d1b56f28834427 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Wed, 25 Feb 2026 08:09:35 +0200 Subject: [PATCH 26/47] Added backwards compatibility In the new versions I added the dataclass to make the usage of the lib more verbose. This broke the usage of lower versions, so I made it such that even if you use it like the older versions it will still work. ```python public_key, secret_key = pykyber.Kyber1024() ciphertext, shared_secret = keypair.encapsulate() ``` --- README.md | 6 ++ performance-tests/operation_breakdown.png | Bin 54603 -> 56474 bytes performance-tests/performance_comparison.png | Bin 55960 -> 56485 bytes performance-tests/scalability.png | Bin 113130 -> 110134 bytes performance-tests/throughput.png | Bin 71679 -> 70066 bytes python/pykyber/_types.py | 8 +++ python/tests/test_kyber.py | 64 +++++++++++++++++++ 7 files changed, 78 insertions(+) diff --git a/README.md b/README.md index 1ed309d..b3e3863 100644 --- a/README.md +++ b/README.md @@ -40,11 +40,17 @@ keypair = pykyber.Kyber1024() # ~AES-256 security public_key = keypair.public_key # bytes secret_key = keypair.secret_key # bytes +# Or unpack directly as tuple +public_key, secret_key = keypair # same as above + # Encapsulate - create ciphertext and shared secret result = keypair.encapsulate() # result.ciphertext - bytes to send to receiver # result.shared_secret - 32 bytes shared secret +# Or unpack directly as tuple +ciphertext, shared_secret = keypair.encapsulate() # same as above + # Decapsulate - recover shared secret from ciphertext shared_secret = keypair.decapsulate(result.ciphertext) diff --git a/performance-tests/operation_breakdown.png b/performance-tests/operation_breakdown.png index 4e4fd0cde47dcb0d32854fb26cdb8b3117c134b4..29a22db998121a0a024a12b6beb78dd40e8cde0a 100644 GIT binary patch literal 56474 zcmeFacUYBY)-_IwI0iI6a@jP(vkkHjj?3PJM(?l@4w%Bu4~2;&NWt)wZx{Z>Bp^g2oRt79`zuKHIwXiWY()-EI zz{=Xl!dyf^Xp_KJzMqcU*qpH5CMan3`6mP{td0pj(6oJuPx;}*0S#*wmSv0Sf8QJn zF2{E@%x3J}t$gx&*GmWW%9g3=zGdSA=HBzZH9rvW+ONf{++Fzo6gLCa=T=}QrlYl zsY_$wh(Qo8`AxKYr{#(N$Yl z$IZ_ln^^HJ3(I|e^U4SXPV17MmzipI(#)e`BiadiQU>9)jLLrm_Kp0lA$Yd@^VPf( z->{^FJB{?XU%Dh}B(i+IVRM{T`t6_hoI5_yTFTk|-R$|#GHg5Fc6DjRIouu`?y9@9 zV3pXrf^}}n#>P=kgCwJQ)#9E!dbG#3qf)_(Q?ByXo;i~P!PAvHr}{1z9ZW4ceD}z2 zPlI<_IKRqv8VPJ&wgeX-l`!b=#xW~9TdsBcUAa|T%#{@tnSBnscAeUHX{CzMD1M}& zgRiu>yQ>Rd%(rFB7L|A%?VOyPxpU_#US2D?`RJ3sr>CVUE2gBauyk8_zw{#Z)|OBi zKLMj>H+R3tami$iKfARj*>T8NTwGj5(J(D2*lkMV(2miNrluyo;bVq|JR%}W+}zwR zvK*4a4h6^Ey}QX}yTyS|sh1`n|KjA^1iaOq$e`)O9oy!-?_UzfiO`Duc zfA*Q(YH?c6eR$PurY0OhLqm<)p58c|c=SS$L+c8;0AZ=J9pf=wU0pm9Dh=PK?OgEM zaNn)@rveYEs``$NypQ+yU+y)0ey!tybuNQfSFc{pvoS&Q{?i*0K7oNI&N|tSLvtlY zI;x^sfBf+lp04-1w4GBQ?pzoCg<Q_10qnT;fEnS4A zy=na9$&+Vq3%yvEEV*ObS)GtEU;6j)3KpJ~XN6hJdE6$4{Cd*c)^@*0E)H=SeD|C# zxvRUImpe&wkAd9kREx&As~h%TTiSj=u_8=P)Uaf^ExvKbjvX0RE$*(?&L%>8OkcMPKSV-o3@F z_U`V^ns_xGogmASFuB0Zj)TWzb+R)Si{!~ z?pe@#@7`v5s?#3|b}DDunTbnCM61Rg?x>9PGAz9oIz9Q`&9GoQ7AY|)No2>vhY#H^ zHr|$+=anFsJCT?WkKN7bGOO6hZLB@K<5hO1adiy$qD706P3sf~+RAFGqSg3=HvIha z?&-0b+|4%cM;BJ@BQB{Ua`Wc zeBF{I`sEhKj)mj;CP#9oRrc=vePUvQ4$JKy+Oaz};|V6M4-nGNfA{*qnQPk}61Um+ z#N5BXEBW~IUvM6(iv@FIv@`A6v0EMAUfu70@rIvYI5v+gHe>KgF;gyFXL@>i4_ph|yCfwO~Nw_fdh(jTLqkW@Gs&Q46LBDHD zYb$=ELYLc7+)nnyyP# z*QB6)W!X87Wr8}DneTI=T_?vP@jpC7pY!L><8C5w8|_JDJ48lLILET`s;ZZ~p&K83 zzQ3idZR4_K%c>%k_AlDrdkXs{b-k_{HkAZooxAgg(b0fQ{M$D^EiSGYf1ewF@W!^n z`g+Z^YuDmJeO@`Vt-%NAjx>ZH3a&PZ&kn(@uKvnTqCJ1W92_oOv1e2MR}va|EW6=LZsQ!RA)b+XhoG&I=C0(^Z9#g4gOxbS>* zpiR`EXz8q3vkFT~<&sTmRHvsVSy!#nJUX@UP*7!Mq*4{)Uh^>yK|w)L(^~l(686=< z|FC4RaAUB)iy@EkLZ?_}$?9k+R zDW(60-y|iO6_4M`mbI#40I})p&@KDbj=P6Lkto+QP9TA*z*Pav?%itcP zG*jaohdM%M&0~8PpF5R!(p2HSzM)|l4q2GQ`z$4FpKM(9_T9UPYoaE!q4Ds_u>{GM&HIwdR^+{$_H)k> z)LGmR+&Z=S$ddUi@(+I5vu6QQcI~mJ*M;tx)|JOhwucAjn8!>^I6vyDOIqOR>1kM? zGaiA5^ef^XX8|V%N5I7d1e4X8aEwoeuAAouB{c{31bNKZL4P zQ)8WiNdxm&Z|%*fk?+N8Q;bGZepBb0_wOx)hkev^gxW8AdWw0Byg9#aWkW-Q?2C!X z$@uXMU6c0mP(z_i+fGBQV$!yA9J!Ojfj@8EnpRt*-~0Ljn{Jt!jzeD8wO1#b7o5q? z&d%F9)KMjJeXHd|JpoDwbtWe5LWoCu=n(d8*zdV{#j=$vjZaSW6_k1kp3KF?9jhuk z&A!KjjekBi>1OfZ)(DE3Bbdrg1ua$2aZazRMc7)2 zW#-S1RE@p%GdFj;<4zuA7I)VsUzjQ02mXuDrey|`LD@rk-c_K@#`yu8rb z^s;p8Hd)Vs;o%fxfmS?#52J0trB9vc>k{5)kLX+-*d!q#@hH$D$B1pCfWTAv*u$dH zR-@Q#a-PYX&-0gD6Aux!{NnV_yE>e)vI1yeB-^HPP{DZMKuW$4DUm%Ni|g z^{c_lwo6JbNJvO9w4^|D<_3;H`t@zLMQ>}HdZt&+_kHiNOjT=j&!OqYGvgJzs`A{C zYUjSpv{wVDVbl+l?Tk-tbREwqkh`%>1-nZmI!2&tVsv2T_LFyS-??+i?B}0nQV}KXSJN%wawi9TEQ;E0o8HZnn&HVw63ppo9OFob&{;BtD}rD z*cqSeyDdLC$hn`PonaGMSzz(vUSW(`kvI32d*4qb=oeJtb~rX}Tqa@n=-h&p+iZ?s zWo@d-ckatu<}s1q`#yI%&QHg&FlG`ruUHl&SsK;I?|{YHY}Zw*SCE&N*ZyeHPCmQq zqOMb;#}Fv8Wc65&;paMVhY8W|54h!;|N85%+g!$M67=_9T>fic;GFWt`h-jCcIG@z z2Y_1oq0DXS4gw-u-SqSQ>)MeRL`;Ikt;2#`hBdU)twI~DWDXswx&PaDv18R;2%7HK z&##z2TXLkq+K`tC3=sCD>Y%yQG$P~Xlf6egc+dGJCmk#6=*fI9rrB4?ym)c`(EG;5 zqj}eEZy)bU8k-zxG*BV+D)46eZZ}i*reoJja1@R2&FHozX zy&_!Hq5tiAwb*o40->?)1VYb#H)o;$_FyryYg0fax+DIDm7 z7b#|e8Ft;qUB#uPRr;4D4Xu`p1sn?!5_ipWXEodsId54J!I_%UPQbt@rEpK2hS0Zf zj{+|p2CNfZk!06>I4RaKN-aJPIn@Yxo=`87$pk|DIj^9=WNKoRV!oy6!Gi}Ar1n-9 zm6oaiCEhct;0z53;Sv*5UBW4QckIK%SqBmQ*!&E3S~mS&US7_(gTT7*Fao4l!2N1u zsCCZ0zYV`{j1LK6FTEk5hJ2Gh1sE8}pRD8m;K-FTXU-Uw1;y&Rj!Nme4Ef-Cj|m%2 zjtz0X&&7Veb9qNpSC^^2W|Cp)J>x2#$^K%&7n%0)VX^^wiF@BB8Way=!F0FyoqiaH z4S4v6AAZ<&;`J$fZ}@O`{i=e^W-pWpOIOG1#;uAd|v-%V{ig_1Ot=kUb zepdyr1KI>MR>4=x<1TG=g0}Hz^%d~JKd(T7|%zMKWz}47pxF|%-)KEZBbIX#rcJ6 zVxG=`U7L4T81;ay^iYf%b6oJ#zN^=)x#U7;2k=j)%Wo^5FCmXL5_ZQC696at8EzhD%qX$rsq^+o}uMc$QR$=xJ3?#cvyE4jeOL@qq%(Jz!D(8*Qx{WB(iSGa=@L}94 zE%e$r)Z`&}?XeRg&^?!NJFgTxz;`$7UnwA%Dk>`8Gbm=0?0dWfm`P*>O5kvymuBC6 zmX?;dKLsnRMEd5LcrbyT7|WCY1P5%MVAf4Zr(v#b+YY0g-PFF*X*dRTgMo97NsWNl zc-c4KeDfmB@{a4|klN%}XS}2Dk_p{2mChn917G~Hxm9EPlOd);x|W% z-8ENcS~TXU<~abn%6X!!39j>xiQzjF9UWbmW|DdY$4ykzu$Qpz@WzcB1NoEuZrsrB z8tSS~EjwD0<1${7e-ROqT`=%X>6XUL;ybvwo|wuSrRd->iDZT`PuSaUxnPfF)L3nw z9qSQSI)JoiIGJhxUd&^Q*^A9yLS`@S3AGDmJq}@iBqNx8RM_xkhOMDKoelkI&ovUV zW7n@==QA%G?0vK-@Zu`rqkk~m-n6uGtO#=IN!Qb@?@aHE%am=(27WQrkI`^X+GQ!D zIfWlKoTMD(Q4xMM{U)Rk-BUxDrlA`O zd#g1q0#@suTzJ&N!eT4-cA-Cjf51hf`jl8kZm5}X?nJ+g$EZ%)i3cYDV-{;SXOFxx zS?ttRo4`5go6==eml*o<&Yg`%8;}4>^1EMV)_`)Fk5qS_F}}vW;a5B7-?Fl{@4?n$ zXiAx9D_`$xE(m=5t|I($oj)@u{KTso^K6^ZeuJbkao|u<520gES0`;H1UjtgxNdTC zasldfAy1qGA?0|TY}uW>$O_(PndTS9Xun+&Osjd7W~uKrjO1`_%{o?A1L6D!4;~!# zz{3c(JBaHT1%v4oif1#-etW{$}Icnf}TU)rBx-|1{d(umtS)bkBwEL=fzwb1`!c;sWOt1 zlD4=FFH4FaePs(5E;KCW(i!i5{7{qYrQ7tRmA!qgxemW(igIUltlW#ksphfxoNM>A zHGkDUQsBA9vA=L*RhZl=ly6iSZ;2T z=`ucS_`Vw$ST278Fs!JkD8sz#p$z-%S+fEzajP$^R20Bz_lb{>*AM^|v3Z4kcbPv2 za!Q_RqHd0}24eE9*$Y;N;3*ZM7{T@CTjO$%M0UBZb=PZmacH`*(cO%)+~u89Ctucb zxai`+ORwkSleKTKJkQX4GrI3hdVaEIinLq&LB$XCw`Kut$*Hnk4Z(WHY9#F&X>`l& z$r?E5;N(>N{Q2{(e&aZza`~Dfeyc={z3a5<%Z>eJ1&f$xc8iG~e|Eoi3VO&| zHQ?C2pBd%-QbW!SmSk zzh#7mg$fB*iZZo$|9>wSCo`fI;`_xz6B3o0`xHsLlTA0%6kp_bi6 z`~i-Bh(WQhQB9n7zC%P{U|?O_Mfb;(MoJ~me~Sw5pE^71lnHpj0NId@a@RtxUtgWn z!WwT-T7KSl>8tudq>Y;B_#ETwr}p6~;fsuG@BVrrRht=tdYP@xwOdT8#+=_fI5_@~ zKmO25U6i3}DfM$TD#WS-|Co z2M0H6b|myJzRr~Ol@>G;Sg~RSA|rqQ8Ch@@$|yV5U*75b;jZIIPb{*zy35nVF$b<9 zL>lw{hPpZpFn)&3ARLst63((ty;f)#N60ZP8}fY{r;*fZdpX(0E2-D{POsLT-ic7G zd0yyoo7R#QRGq#^wFs^%P#5t_8Wew|Sf3m$(pnZA5AHzM!NGw!B_J>jgd>}O{`cSC zp-8VpIx|n?P?kzR*>{`JpINGAAIdTfj+g*)c}wagQJOc`xCihVmTV-u%- zD>I_#;_NK#a#>|8*J;$ZRh=W?&PI0j2)F5}{9i0hyoXk214|f}hg{&4^}mU#V}E($ z$UTs3=82)+fC{KeXR;mZB9)~*hpgRJ-klZ0_1){R-d9fV16(BfL;ZAw>vEG~v@*|! z4vv(TnvBG4UOt~VJJ+%Hjb1!MnLQaYfMS9J&g=vMIe3`dG6=7kx0>fIdx0orjEG>^ z3{-b?({eu7q?<8IT`l4bA~)qdcyLRrA0f(+cZGIzTFnHo0{8RtS58~Mikh3drDZ4w z#Gc_W#IK6JS=)LTYrW-qGeV1uGW!OV*!1|v6U)Hsj!~dgt+qaKLjJ^w-UWHtuO@X& zw6h&mzrolq`=i+p-qXI;ZU0b6RuOsQju?pBQc7=%HQYQf!8TXwC z*<-KIEV@|cC#V~TW8o!q)=z;?TA|U7zd{UDblKEIu!o$K)m>lFZLoq0-A-7Mj zXCBUG1yGkQptDyBJ}Cls#nz^ZjIO)GVy4^bxecsQNQBPo7N6 zzqD$juC8u#ia*F{UdyY6&+qJKUA$PYT2=jx_}Ip)o4yqOL-p;Q2j~_S0WO$*ff84O|c!|Fdl8I33x^?R;sz!NV>{%pvRBXj1clUCvt!@-g z|FdWEUTxs+G*iv9ds6>MN=mZrsujZOy?mCuRQ1C#KBy5WeQHWu2HPt@5o<-d|IS`4 zbxX1THe^WFMBx5@y#zom6gg~CYg>yQ9DpSE!N%t z>)Ezks-1AhA#D7IxqkX-7bqn)P&f&eMOHoaaoQ3|E!FXpdU-=Hu!mJU1`xp;+`($1 zj@p_u%&io5fC-MTH04npAUGIU_pE}Bo}M_|^@@4n0M_vYz#e}9GA*5ZWUiKGiD|oQ zCuowTY;0j5(s3_b8#dfg=1o`{ba~bM+5EaW4I!~8C-P%m1az_@2)zb_J|m_R0m~RX zBn8mIgxsmI=)!@A)`Jfxp#zP9PLOt9Q`0oHnMLyfF*rOM_FcS!AiWQqMq*p@DvPXJ zh!ds3I~!|<-+CP~u1hq?56lCxrVQz4Xkwr&8ijcj;2&vXAOW~IIrkA&OVly;p+_5H zcDNkpRRlB9DTn)~z5!vHQdMI~A>>t-gYom*X9>K6@hNOdX6xIlfyxL1o5(lW-90a&=70i-#1)^K) z`0nTI4^19Lg@w;S1iQQF#=L26)>nKs0Je4JQ$WJm;t_&Msfl`c`{BSl1QwU6(KZB- zt9S0)!KJozcABUh1bTP>6pTq|-MFc4Y{poDwpZ60{L~ zrR~_DQ8%7LeTrEHi2x`duf>E3|N8KINo30WHpF-p5CfZSJCtp^U#LK|kOpU0qw5w6 z5XvJUaFE$D9xIsDdzxrSgf)^w4F|TF@N1>X<5_`qjDR#J>Ne$^G~Nj8db6+i!G6!x z3gg4wRVXyio;^#f3lUv(F-?zum;~J?CZ5t;EsH7)>+A~M!f~idO%%#6>55RAg-7Qr zt%QhuMC2=m|7@&o?yJ{8^kU`{ANtOL;BQV_rtAFNRMztHZ7lB!B=n&uU`fZ!FoGyy)T!l0+8(Lko?s?Qz%RzJ-ET$l> zI(dVyN0j&|ztFOId6I+xoBQ%gFD#hd+3GH0SaNr40uNneEnyNiiJabsoZg9N<=d;S zm8~GbmT?_1QNv{cN{!9*94<>D%OngOk&wvLYrB$HdbZ&5I^Cw4;_~riql&Q3d@g5M z%YjnD_U8~f4o{9@RRdgn@3sz{dvIh*#KOpY5lkP?r9}k&jxL9u^`<;jhBE=y0ljzF zUKg5{25o75`*t~{(`e5HNRDgm`wl^czjVZ_>CySnWmqD>AP74uMV- zDo8Vruyt$6bD+)A;a0w)p`6{vEiB?e5@>D@L&{fe+W}oy5@m_hu>HGd4@@ug(|^<2 zc6S$OD*{jIH})7TM?ndHfOHm98lWe`rd_X`?eBlTSzD_PHn==$ITo!YrR+GO`chWb zP?SiAMPGp+*Q;`2@M)%$q{STn6+hyLP;A?F!=7!`F>FDD!~CGmoJexQ1iA|Y z)5z~MKAkD2j0cuI@Ki#|ocl1)Dhk?o<+jXf#AL^p>D?PHZ?}3`rZ#JAu>B4eqw&O! zSy0-HCOEAvjcej!<8#J}OgmK(Ry85x-+?%xNrWcqH@PtgKUjZG@ca!OCl{>Tyvd>G z?c0z`tG0AdiJ+hZDG|C~B)BE_F5M)yp}R<8x6qu(=f|DAKW=2fxpWij`YW+@v?a&f$O04IDeE!9Kyk zf)I*GFhP`f4iTU-RAw14+7sx82tG(8RUjo}!G&r-n33wyIQ-N4^$$(OA1U0~7tpXt zz!Pa^$A{P7;XEG%#8yM@f~Xz#`t=c_u<;hi!eZk2d3jRxsTMVq+W}sl;Ey^wI>z9v zNa&#@GmL*!8UaEH&|O(p_996Z$rg<|@VZ=uHc4VAk`C+w$3OJGA)^araEhZ~8#jAY z#b}6t$x_pG?mN5Ixp%jyQTbl%eJfNxxE|Kkt7Fcub5)n|<$F#d3_Jqf^|oZUAY`&* z?A?a5=g${6HtHfuS=rbqmtGSkVn-6P0Fk9sVJl9bzP;-~=T;P9pp6fq0?I()Bnp+J zyEfrblWcv>D%_^WXH;%zESDiY@q$Q&$)K>T>=01& z^B2h`$$$j7+_&e-=HQeEfHM@Qs4H^psq*pT5yZ8?f>8{@2XN*2m7n(vQpM_g?s)Cp zTNIce{^%ei!ZDx-G>>Z&G<%h$fp_z%2)MesN=r+VUQ5p>JtHFuRBT6mYCO^559bN` zuUWEcRWy>2+9JupDVbjSsV0kAQ65ZoN$%lz&`CRI_PRQH2VOPd;scMDiu1HFJGpLfr0 zH|;`t@|#)UZQDTA$YB}Dt^f=ahE1(L@k=W*+EDQH#D3&ZZxBvEb5#g% zl<6hxy0}yx9Qt+Uba&04RV>WH!p^|GDZnZglDl#0{GxR^JzKVb#g0QzZ5}}KGlt;R za)T4W=oAkRKYyvI)FYH*s(j=n%b8mi0Mb_i>%F`x(jc)a60M(z_PLxtysiyN<3XlPb_F{#UE2V(nm|rIM6%Ic+1ko zd0~kC^19C{&-LAxKeDg{?!rQ`?BYnbX=jpBhGLGQ0k$XMUa+RIo(Z5WpmVd1e?YV= z^^}AnMH|`8&F#}q+;P8juJ>P@t zAaf3+-Y8ha=Zkkxj9q~$Zz=K(_C*Ae2WJ7)%v~g_YQ*5M*`l!F6Znziu~u*E1E+7WdMh>`zmfyR zCTY0bTjc1`qY+^Ch;t(ESBhDE2ML%^X}|sMyCD##6u>zPPLxfwDg_PfRwajI#P{IB zRGpo(!0$vL=^J68qz@c;mgO)&1g+HGz3QytxR=8TdS~VLd23_&WB$J zv<}_>ZV{KbxCZ#btU61u{N*4fafo@4H=b-gj|0JCDp%mSMifWH1$6~U|5{pF(rZkb z9$%na1y$n1WZs6=ixk)AAk|1&r|P_Gc~3w+o2qv@Lw?O791>uX=Vqxd!@x9v8;SxV z;GBe|L;B#sYFJ*8vjY`_!vTVjR{fABCE;PpuMP6?A+K0^W+s*DiK$y+Z@6~GrfxPW zXO|p(>xCU^8CkZd^Yh}aDzehq;WTV27raAzdZKM-GHIhZc*s0pTwum2hZ_Ok9J{_5 z1k!#yF@323=`RZkpJo+&J~0*ZA4Z--x+rbeq;r zeQ6iS-V@LmqplFA0$@`404h>tQhSntaL5 zwRNjHpa|&6flC|<=qECAMq5`Qwnalu z#0ymkJ_ALlgtHf}jzIl%9F-G*fsf~EaXs4@_~RlF4yt%f` z)>vEz0XxDNW(Prr@ym?lys6W}P=^$Q^fFSyfAVw&7P{w9P)OcOFauZ4* z7oPR4Temn}fG3p@Knyl52aohBF&lJ^ya8SeX2Z*u{KHNsPaa?j031YpK-#aqwdcHY zlA#5Vy8$=Y)qbBX0z&a5SsIv)~G`|YQrR`Et!482-hruMarRD8g|3L!PJEtd- zsuJkpy>*P*MjJ#@`Bf6-!}vy)*;!g9bX@P+k3?_IHY>WY0ay~+UCP#0&`N3t4*WsN z01!7~{E(mLTFEG!2xIJ%j)wFkJZq(^MwF&fW5}Nk0g4#v+4Gm*B!kN`0j+08QYGkXLv%x9||yhkv4@kYKg^P|H^c3BWUv|$|w-$7Rv1l@TYCD+O= z=GP(X47LVZ_BFl&DYj~>S7EcAqb>s7-S-)JlKekgu2EL+zShd22+_VzeQ{D zj#C_=0c|sfr|_46#0FjXG&B*BeZZCCyKcco_YQTc8e$6>$Pfo2qV316T3nSq|>)+qDSt zgYXPbOWUgNgrHuD0>i^i!(FlR{2RdXkCgBu+S;$Hm;U|lKQUe;9lM-2J#OFAz|DXh z$GFfon{IV*WFj;|UrAAsor+4fg12pLGE8A%VgEqoD^Q<-&6Q`Mkr?>Sy-aU^|Kqq_ z$*o&!JN!|UAsKoj92k_7i-e&#((_U#hzl3Z676Fcq$|I@xx3q}&;Rr=LcfnjP=uC> zl~h2Y7`WP@t~w<;HE^roG7LVFN~d~U1kB)mgALYYktkMByWQyOo{r-u zZkr5TI0D9?vS~ZRl@O%Yyk_f(`+80fq(!j31jKMC(uU;xH|>tk9=?XO8HRJTN-ZmJ zr(4d#)mv{uLwSi+&+nVJOrVlzAJn;}0U`x@C8$K+f$=4g4oxR+OC5UX;GA8iBM*`7 z6?i0~dbbuZ;DBmKx8`7gfc(kYYwkm1)F&*gWe}R13oh4?ZybbbKxr{TAnVGNQDSB< zmS0YPm9?Fln?Y5PWgrKGbSFCg2&h%$Wlm%8M%?Lx>8xI9OPiFvV?#t${>;;}`cL30*>o$0mJJP_Q55u*izw zt5RuB$=80ef&~UgNX)M@vqHjO^m{Q2b zqM8B}A|i|lbyzm-rJ59wroXT6IcPJ&e8AEN5kqqjDt@&iOhMkv<^hm)a!k7WNWjdQ zjA;ZC%D|xxpLSpF7#5#QWPJ|sEVD;q|K_Ivw?t!4GUIk`(FK75LTU&cJ}(#70YtE> z-@cnOh!%+mV2Nwk28Ab)q=I1WR0xqSo1-mXW~&V;B5Newmq>K+zF+7KlR9 z5MYhr^0?51ryvbjlMUzs<)c>*Oy^D=`U^6yAOd&b8J35?SOZ^(i7m6WcNzJPEco!hHsf{h!pi8DUta-ARxdIb$+tbh&lL&ijNRe zV$Xv^>a3{K@6?-T%HcqtF=qmv7CQsa$R}rN%)~1Ptu=}$9(@ri3Kvt^`T3PLs$7@+ zTamHbo84z-8^KXRfq>ecaQ>rkGPgMnMu45*WjJ;x*HnUTnVTv0`OWx^x0a8V!aknN z$+PJHx(A~xzjlT)(N=FBohK;??N*U6-%%LR0pVtqL*?t|R|D6d)%bnaX#8c$#q`&u zXGd^K@7n=QJM`+{FKbi!uP;)qV>S5vF8t<{iNe1sP`~_$>9;e-@AF^W{Q>mBSFih= zTUG54L+{(&=xIz&RAS+aN;2AS5RM;_zvUm;Y?#-u8sELRwIxkMCE4M>tB=2Y{(t`Z ze_3Gv?+1K&0*KWAaSi|f^$?XUi5`GuF0Qxt#OT-<#dUB%p`O4>;^d<49~toj)s3bV zQ6z#J2*O=VBx;tT-}DVOetxn=H8{qD03p7N7#Q+lZcqT%rwXu1whg5DT__<_Qp{gQ z!GofJhB7`cYg9BW2A95^!H6az3y=>wNm`~dwW&$5L!I0OIQXn<*Tx~E#cF4&!b|Ew zv6FZOfH?zyFitG;De4MzUGzG|(*r$%&uc4yXgN4o9-v=p>hkoQ9x*uwho>>p&|$P5 zkVU^UrQV#^%bKu{!G$kZb4ul_x|3*ixiRnqm7rQ%T3U>dWPQAU##>Ifd=&$tNlIo` zX4slgfrf&P)t9U%7 zu(t#4sOFi#osu{F8QdL-=1{ghO z?a5sr6&yPv!$C)zbUD2_yNoy{GWch7r_}RoqbPr$2PMR(?`7fA4cuaZGAij}nYEP_ zJA=f86rxs$R9Ni_h%VO@ zggU{1qAL$=9-JnDv~-5q z2iAPm81-L;bg-!Js6JaqHeGH^fC0S@(j=eQiL^^ivg?1)r154 znCN;8fsBW`#TdFOiWs7`m@w&B?y>y(-SSgWM{miZUkdDh6`b8D6N_TpAdxUbP)qrY zt%e`4Do#5Sy}B{uJ(=;9e|@(Q-dzHkiGu-FA_Y4*==yc74(p{coE7o9JFD=p|J55n zv$8Y58L*Addr?tQA>*yE+`nkxZo)~+Fg4Xq`AgX=l6?K{?{r1J+;9&N4FtqgGVAhve z?S!;6hC_!Zy@52DK?XfXu_lO5bLY*gz|r+aBNoboC}2$5sRZ81LcGQVt$=i%DA_<# zAgcfrE_Zi#ML1}}4&FHIsrG3}(yCOzeE>@{6aoK2o--iT{(@zn>R=7 z-43UnxW#S+`&Yi1A_pbCxeFJnnwrLdj8Zd=`Th6rsc=IF8_Z&&?TCtj#QDGu1oh9i zTk7MJW?_lC2!5{_8y-cR3=@vaaB9tJL@y%s@S?tk^q*gwbK=b};6(}aOXW{ON28rW zx-`xWe=ba(_@F;Py%-o8MxkCNdR1c@mQoG|j1fFyzCa5qZ82E!LMBCTdezQ{P<1m) zHc(6s$_4Sk)CY{y#{)Mf3@=nzq7_Uw|Jdiy%Oh;~AVmfqJg%As+$0sbY_)KtrWoDVkoPq0;&%(RR_=?c*1-u<%9VKpbGAF9-TEvHhUjO;F#E ze+j1;qz+jjeYjo$a8N5+F=$xo?hTKb`PP%yR=&MSyH0#VpE_ggB7G{ zJAo2E6C_*%ymmhKp@({ptiicDPq2u@Z?JS5m7*| zn?-kKCf@8yw}fdJG9$<5I@$u=n9ze%;a>ogrf;f?;|zP@W{ec@Qb#8QlO2v#=^2|= zBTjxK923Q_Ug^NYAP^q?=>i)%W`?!kn^fu{u8;)@SS=FNNXLuhXiO~expL(vc*?+r zl^k`3?u~Xin~q9uui<}RhFkgs)aW?LA#O+CHTeV?8xDVj(!0_zxj_YfHVjA+z?L*? zNK=67K)mPTB}*tWM>nCjgtR@9->~dqI5{TZd8K7!l#rd1Vfdw<%NA$RnJ0wJr@7*z zD$He%J%0^dz=lt+Yjo8x;JT`ShL{lmDN8pkMxXa?t-i zga6$J9}mQTJ_`}$XN5^1hKX(|3{bE`kXH;ae49i6(a0v6U4$-7G=AMeeM`f2sCY*R z?duOcmDr?S_k*`zUD7e$9XoVT23AsMMteIqgXmt)LqRcr{P8!mOslhY zqGVA5f*X@iWr498FENm75ZPbGC>2=Cofg@E1HvC+6l0zuvKw0pZ$(6Wrz*+{RZnA2V z+6%$yrEQJ&${o&WL|fYxehSC*aW}P;fmGqbU{JFJKZ9Rf$w1(h1x3JsL{} zeLC7o0=AUA;nO~bsJP8kK(|JnZcr-VMZt92J;*EJ+Gp;8^^SBLS2Ly#F}7jw0kFTF zo7*%xYcBQ;40ypks^NxCP4;%M5`1z|bS0l&5kEm^{%2T$1kPlKhvli>Gj6DGoh-`mes5f=7_JqFt?AkPt= zZPqnwV(|_*t)f870fx%M{L|mxKls8Vo|=qVZH?&jKfSolQq{)}zt{hy-CV6ofM!E2 z|Ji-{tEgWFCp3&ExxslrlH?5ipSAeYr_!(9XL&N|lhf0UfU|)x3={M>Y}kOY2O39n zar|^nzL}NX`*5Ct|Ic5)jYrx?`!jzy^B>aKzOenZrvUS5Cc@nL^Sx0@puP-8V7h^B zipL3PR@6k%d+6hcEJbVt(xaj3+*&P6n7(M?mk(05{F7>d^&u2+o2V8tZlJ7%+{?R0 z-0E?MI_hS5SfcI$J&|+m$(5gJ>>U~);Ykuj)UcYld!dcTg3y!T^IHh=j-&uzC8LVQ93 z`h4TD9G&FtKtarCg!lC(h2)R8xO0Ia-I4dAFT*Ay9)bbmWWYn7OuSA|kd7%IrWTOM z1T$dA^E>C^{J%}f3Ot+wWPQ*?68J>9r%#_6*i-u2wZbZ<>r-vZvTL-ksEEmqx>B=i zq__79yEdjAM4g0~KO=O5hCz?Oiu!1k=rDL2X&{+!YBw3^&|ucu`pa>W&PQ7(P{W@JIX@ z*WxeMOZl_tG?iw;t8_eJr-Xzi6U`qgrZF_u2JUaN-k>bo=ro?2d$}GX^Uyw{L&7WQ z4MOkKNu8Jfbx_s*81X*^)gpf{pBiJ~ufH(#AI%}P>f~o;H^Nk_{Ph9f(u{zrqnN>R zUa^hX1n-SsuMK?B>>JfkY!l=uirDjEHua%Qi zfq6t@8u^cd0kKw4OqHw()Yq0=n|rKmEdwLZcC|BS;S-8he7&u(vMYDGX0aQgMG6Xt z*f84sbiv*+i^;920G5&}3bGy$SBH#fEB~ z`LvO_?3T)Tby_C44fL^06@b(;#T380AIq5%UfApsZ55Hh8u-KpQFd*8*~w|<2aMXJq_uc&1er#)-PB{G1|By>=N)E zF=!yGOaN0M9Us@w`Uuf>1>E{`!t84{J0LkUkr^SPVT46F#EdHV_t6Wgg>YOBo4NE- z3p`CUTBcK52x6@a&L{1Da!~=01YVSctWPB@*ivA9?5c$UJu+Mz` zW(Y8r6MJeMKa#Gm*~GrYUK+v#Lp%qA=1S5SPE7E`QH$22p-*!cEyDanKgt(~;)S(- zn5*#k@m{Y!h(X$jz54XSsdv5HX+#Nd938owz}k_Qaszr|Mc zv28&LlV)Oc=*TM1k3xYw+m}Z-GZ9D;D?^YL?CG*qyl9(603kd?SP?oN7rqd}RtDzP zP~$3ihesU^*d>4@0t{*ytSb0eQ+x>|<_aLCz1X2=9tK$`$fceh1QaXHq+W$&6E!5t zz`;XkE~0Uy7$+N3)D7EI6@Udd_>&~F>oYga!ZQ!eW;4HSxDBHgI|HUKwsFbr+u0c~ z0&+;sDB4+cNnUwPPCt44AFB8OpAd8VvKM=Mb^hM0b-dn6Kn@J#$1{Re0&r) z8$MeO{yTK+{BkQ8du$}?Yasgy6bIG4V;`?q^~-sfDWNhj%OYiT7|w^~yf(@Gl@BP3oT``Ye64YSRqj>UCtWBdVT% zEr_~!YU!YphJijL8QXkoGh^>~4gLv>{jQB@m}ETh>|f^2Fu8K%WD zo#jOFmy9mI4KUspvn~~tlzhCsLukIv;AeVXPoL^Gl)L1(CWknXT)^Nm({$tq>sWve zqrRp*?9K|*tI_c7#Cod{QfRnF2M|6#0%^$J)SZCPL#49|aQWw!fC^Z4FQHrXOG`ip z`lJ&iQMMA7KR6ib#;o5@T z;?R>QO^yLLny44~(pt$3t+-Vz=2D-O>=W~li2wT>%GL=NnHsoDWL+vUp{!v{0QF;F zOi=|{{XjIVD%i-uVT74TGxKgbl52F5{G0VLjj#U_M$clK0Rnu6zQT2JHUPdf33@3S z)KJp|EKTsMM40AaK&IGav}oQuB_xfylLRI;Q)E#S)SyX=>}aFo<9=fku)ThQ>?h{Y zCRd~MR z3qK&w6d&1ifJx@PNi@l@HDj{xjTxw|tbwU$n1HB^&*nE*L0KSAo-xSQp#t9G@L-X+ zhh2h3N*C32@Wo4_x_gHMK_e7t&h@9*bfVbW+PVV&K@=r|UctV7`*?(f6Q8&uUQ?EK zgy8OesR|}x{h1_jB>JBX^mmSk2K;HCS6ychK@dmmAX6C3l+bRYFONfZ-;A8iC`aR`LX`D)yHxgmF(u%vhRjvSsuFykZ__$ z?z2#{3094KEM48BKATvyJlt46<}3QFo77_XHI$ZFoq41_6go*-Z34<;BAOsiq7QSU z3ub|;T2y_{lJZrNhB6}b-|-b3?txHW$pNU?cUBm4O=wmKCP0TGR+7WFzqgm``6$bM z)xRzeY3={d(qp#yLb3wkyb-+tTLBGs*kY%^B7atV#&$RJ0P%k(c>ixAh04*A(`J6; zA9!i)h9*%*^iQxes3u2Bv#@NS0b4h3-ehXAu_!aXR2_uCPW*=>oVvFUa6Xh;4RDn4 zyg%3$1c4#?&_-scCzfzW-3EgFwD%&ueUa^!Mz+BhB4Laf+u*6WP5*;t7^l*<=1&j0 zfiDZoU(e8AizIqB|E2+t<&+g{93137N0SICKIo}j3fzjZ8ooR_*sl4WYoe+B6&wLg zzNW4zxWj~>f?b<=$ya?`=9>*#mgolBtc!h)#whMeZ74m04R!gU>XuQ&=E|;Tx%&TC@ zIJwb#gf26h9H!DoJ`^q|HpfV$Lym#&(gB~zXrs`+bONk>y+7% z&Kc6Wv=yJ9^k>aXVoH2Gg~kp zTOQV_*rNEqdRFE~H-Y*5AaP91Ztf|m)S~H)ZdGRTb=)j$;;OxkxBl$0cqjhNO&+6> zsW)UWIbP<^>2u@TQ-OcD{OK>uLtnZdJ3R{IrJC;+ZNCWxk_%(MiB*7?fI83M?n`5e zP+?E6hLTSLX7AvjH#^N=)N`{NZj9b}(!oLFUo*!8Uy~eWwtOr;f|6~{#Kzb}Pq;BZ zdEuVBomZD5BS*y8=kEYv%zlIBa=Y!$%q5w4Za(JK7lKrX*@^Bv<{$u$FQ>}PrD5qW zef)<}cBNzH^i`TEMK#Kzg$rS5z$sy8z!;KL>o(k_!I)0%|6JSqD!2a<@NZejy_VqP z0ms$eHUoF^hV#;wnQQ+A$R4c*gYU>t1f$?_iFOxN!5EmY3fe)#?SZe%tXV`|%)HbU z4dxmAiCD?h1EPr#EBZ=qBKr_nhYS9|1%33@l{Y=Aug_c^NAF8ZhU3TtQ!khyaE5S8 zNYvMEf$xh<1!!7@0Z1rC5UpVF<6ILqaA)wL2@xHY3?vX>lnUtI23;N)ngzUwdkLqB z2m>mg&aSz^OcT&okQ1fr%e3#u{}Ktp_6n(?ZE^Sli3lpS|2H~$k~%eu!X?5AWgX5T zvb*w*`n#q}PdgM>gJe+1w(qIYXff!FTwuMk1%cU)^!4r9i)RGnf#i4 zK7KKY8lcbrmAMUUU^RYR*4KdwO!;99oZoESDqDJ8JgGJT|MCFF2Js~}!s0@+dO(Gr z6)ySvpC5XJmz0)&Bv>yr;rOe84yeNLzdIDParDy@_I~r4&HmqIjaTvwG!75tI|(VE zD~+myF`bAe&8&m&xW)Tp@k`%(Dk>B*j5TJVF_@S!N){~4j9i?@KM`9+Aa{DS%f^be*it$W|z9*Ihntu7bs z1KP++VBGktMnCN(7;WT8#rY>6-mK^*nt=ckMjjx7$T@h*NbzulU2~{b|1xIcAEuL_ zlJJkV8=i$M$|-J`m`581leP!Zx?D&`yFobdjG-N@6w>=0P1VJV3ux*&px5A&4VT}c zm!=v80RL3|2Q+mZ-abX+oKa(tSqSF2f%hG9Jzp$;Q>h!!_X-A;)$uc6HdXLxaEy$h zaWK?1gu0yG3j!C0VFwyUgVxMJh>WUs?&w1xUDT#skx`E4W=@F@?M8~w3BdMbUetV} z(TPJ)NuE@EIWHz1D5rxIJjkqsyN_BFc|MugXze1gc1peT>OXslLsm`A>Y$O|sDrs- zp@oYS1UJ{P|JR1XE#6C5lz*o|=+L8xM#8_>0#OwmHRy#p4s?+LKW40_1a*S{Ibjx^ zhCefK<%wgB``~JW5-ZK5vEEa1*|XjTZPTHQqB5AfE{5}yXu2ye0*4b}n8EDxi#f|m zCgsLw4y5ve^kR^`+?VgIQuGAH00VgQ#3P7eFohg7 zMFVlFL@odGz~GmtI2h`d{MF~|{HP5B{I0VXK6=!APXC+xu}%MAAydsOe)_ap>5yb7 zsDqc!?CfUxvu1|-+QcwD!oFVg6|l@=?)^4KIVKxQvwnJHAd{<9Ip!JQXGHPr8Rcn~&E7X| zm~~MD9=eb|wZzqf{EE1F^C$d+JbCQZK>TEz3%s!bdIYt2V(2?cXw?qgu5VAp*261B zvvef;pKRzrH+*EXDVmXy;gmj_sWt6>_@eek2uF40EJb~)1g#6jX(%FD6xIS(Jq#2) zjYE!qyF=Kk4?&q&HY}m+3$z@^qVQ0`WCj|bh9`lPbQ`QH@In+=Ek|rJ-u`lyo8@0* zkldTQo);H)W>^xzh?bwE zQD%hOS2eHwWo9Z_0bmLvwi5Ix_1%(;MAR*cBi}P;_K52)U}@08@nmOgJb3*sw5Oi; z@7-Q*#UJFMTM)H^=BR){^jPRHX@Fj{w1|+95L@$g`~_OwF|FeUjhEw%|MJLA#Znjf zzj79aXgJ|0(Re?rCkp`u(7wkE!E^aP?Y#$7Rp;6*OioVXiAKGNpixnd$wrC_N)ZtS zW6ehCEeMDTNE1+yCI}{mn5d}PfJg@cX#z@>ZtQfVBh5lls)CeFz4KX!F(x@l&VR>$ z|9^~+F*3vmd#}CL`#xnpbIzBP39wYtz9V;RBt;)F1(@eW`wfn8ntR*!G!fXBp zEG1H*4^~?$OfoPh_P1(&GjZeLsfh(m{ym<8(!Y`5VYlFsVRjA}s*WUUG%UCD5~`ZX0zsALkzMHWnLG#zP)~(=|AntN7E*@3;N7 zUyG=^2IafhiJw)wu2URb!gMvv0y_?yhF_61{+!P9r>E-OJ0-slvn4tT0xAevOh_-j zbSzKWK@o5qPAOCRy{cPOj6id|;9fShanWD%sS78&PrA`57cgH)#%kWvavccsGgwy8 z2^E*I(Y3c);Af93?X#YPKQ-msTJguGR*{;`ei(Al0bTf@7oc>+oSm9F1PQWV!c8Y~ z2MUQOlz3VY6(@t}afK|N=s+*xkpq;xV0wyq@x8x(@fGQt{a_ub1I@P&Fj+7IUx8Uf z^dF2XMEXeFN?Q(7hFQ3)8w zkZEl~v^QRjC*U@z4SAwn8PA{N1#0^|B&eKvmFPac6HP+awQi`8iMu?2{v;Mi1ty=> z*68aphbTI{>&$%Lj3p1&}^Kc8zhqdBt{=XH{hCA-W2`dZTSMITlSn zvrt>jufuks1V^~`EKP=D9-M7LrZ5Sq-2>QiJa4c^Ub!%-NMO>`$?ao}u37iJ{w=@t zn;#;#|Db+3;1i3lJFU5!p6@Py_~f$M<$tCeh>8C`K~E%;@9y{8PHWGf*)lKs-}|dA zE`59{{M*lG{_us<(+)zCZCDV^vW+-|?5{qXF-8vZ9gJ7Wd+M=D}W zB6{{A?s0*N0Ul?oTGDnuq&QQs^am#4iJfkWRmgpDQX%_}J>YE%qyzQX6aaHiqOtWt z$11UVRF?``dM|{*ImUcHX(-DIHjg$9^(9V@Bof&lUPn21>?zbhM6L0=zss$0AFp}U zT`vRQlLA2AAy|NG4M)m-CHCGpK4J;!%tiV?I|Pm$i77`2KNY@q2E3^>@IW^?r-)W< z#+@(5pjHyl?v>rCq9E@S!#*hedK+G>lwMH9eWc>|KP>Axz{8Ra{Y6$K7@{4GGZKV% zkb#O7-Ha$qxQ>^vsN3;+f`&LD>+@=>A4@ma)!7ZEDX@=T4oB(j4=iJ2WBcG^mUG(= zRx&1P*baAQx2 z1qMgd-1@viS`2!R>P);8m|O!qVkhur#ncTvJTE3SetFpqcv(rKyJwDcKa|Gsjt%m= zV(Lo#kW6J8o`_oq0)_Co`H{QLpgERBEzUQF|9!y14*y%hp5Asx{vwm6{@|gODjmaB zRrv86Yu|aK8IQi5C1C^W0Eo~ccOwf5Z)R?b&e_Z{RK2BwzWN*>8LNq5g?lFfvjsZ5 zNRH12MkKO;n3J(DqcBT-4uIqA`i^MVcDd%dJAUu;+(@X1)tnUsxtnf=tqE*tub){g zBL&k`hLIb_7>55T0E&{h4^42jNQa-CK{-CrKcxjRJ|OTE!L8+f!Sz=w>1YQ1zb4x3zWTHrO^oJv6~OBGLAEaz1@?@SN6SJ09k z#m7@jmBMn-nOZK9R|-*CH{le=wcwnT!VEFZUjWRy3t|TTU;^5ttKlGu;Cvin@)K@x zYq-F;nMNdF9i_`yw%A)Cw($6CKOEYtD-GhBCQF zo|kvuMb_GbaZo&NiNJkS$9*_xbpr-LHn0^59LjFr$gPZ$_i@ba56TjAM*6vfrCtHd z7E3)<6I+U>K9t%1D@+XF2!D#jhWY8~k{VBBK^vKB0c2wqn`Do0Nx(|kdzzbgtlQEL z9J;eOS?F%W^i^Z?d3lLavXj26k_Pu~30)myy6uyqX;*1Z}86l<^M9FuZ_gM7)bVmW3_;;eseIv}oZs z_X3|)k%Lp`!k&$d47kg_cL~dS_F15BQGwXPdc`63)w<58xoA;-*oxzu&haftlrz73 z@9xdu$jm_>+bEuG-69GqYpXVB^zep8+jfOrUaz!VWM6m@_Djbk@YZ5oeVEkJ-^TpC0`nAWMTJoTau>H;IL2=-K>!sOENY&H%&Bx+eePo4Lm5I`T1V z3Bl298)hsyQZ~QeULZrWMwNNhcm=3}=*w&^5k8R(1liECW?wPP%XRCCjY}w?x(uq)y*0#$c*Qg1Jt#&eB4K( z+%29&Au9$|;Q3zJld~SHxzXwgwqc|?vsiqx#PZxk>_ilpqM{q|+$4dR{ zt5GQ0AcEYDuXe_K7D~-ztt;a0+(JK8j~MKFQH0;I)Y%xTHwfNi#&}lTHkmv>oD@4Q zH-3hPr_9^GYpWmHX9XO_b|3r($BqfORj*mF$7$an97+rV7vg!&pL(7doqcGEO+b?3 z;+)!GOtg(bcZx|!C_#MjgB~jivQexpkeJ3gbn*&7iQc^-_x&X6%Yx{0!IyHoOZ7Y;y_&n*# z^np2Y5d_Y|JA5O;b}@`q{LUTgGLj1tKqs+l+ z#b01~sM1a)OvD-HA$@>FZ4Q5Dgvqc3Nb|dbH^`#HIvC4~B=Pw#Dfz048EP|@bFWKt zfZ;@+FJ(^a>yN*0z&UBUNycp0`qstIGp`cGaMVe8!^_)emdK@<&5%QzWcOB0khk2* zJEj5`qmQE`GT^I{jDS9d7*m9ObP-|pG8VgYO;(c+=<=75ULwCj87q3>tr}5-v)wPR z8cjKcm=yzWg{7&AXSX+w<9_`m{DG&$^!J+o{DbemJJ2ZH557h_XQx;`Nc9&9Hvy?) zp`61(`dHiVkdtH}$PQ7lv7!PKFHSnDrA@!8ROEqrrow_hxdg_2C3rv*aP)cAQMCfK zYaw!3AH00Jk966U$O@rayDL_NP|tiFzg&HAu?Yx~9IWh?=IWY_P764W zN=QT#9%Z@i6a#-rES#Mh)hOOJ-HN8dQA)8% zxF6OI3UD)KBL&ej8|%!QupDoI?R|fsZGnh0&dFMwdKZa1fF2zDuog-f-`DO(YGZSX zuy#*A33i|0Is-nUEFdk4qO*31_ay{Io~B?bI~C)Qzrn{XffzB6UY1)CGU2^tjx5V# z^S;xTP$vc=N}2%p_1xVF^K3SU-=TKjw)W1uh=>m#UCbM)N|eCcxemk`7QZ)xzbqPM zW@wnF9cDQ&l`6Wsu|D6tqUQ0&=E%&<^{^~{rd{)@w^?BZ|DjE80Gwqk=qzOx z8%R47=rc1jzkCV5tq^h7$FpRgg`Ti|ux){~s0{L0x;k^44o}s%+L61TT@J7=m>hMV z6o=&VE8MGe=fp`2}@^<-lT@)bb5B;!t>B)XNS zrWz4%L_rGwJNOUZuAe`aZ|MIuaCWUrSJHYxek_o#(f2}f+IWxOZdV4JcaLwc*RVu6 zZl?UYhmupfjHv()5P9m5sE1?j0l+pyr;?{9tM2N)Ef2T@os+izxII`+IiHqc7q~td zPfo2^76O&%wD?#<8NS z+V(iN`mpkG$U}#UKlVsdi4f{`LG=QP8N$l1`^s~BMv6@3y+98YfyUO_!qPI`zZnd2 zN`$B_mYD_~-X2~J@c$6U80<4zV>4zistk2PAa@1rEALJXEa5pV;!29%w$I4`^J+~n{% z&)t@=b%OcBPM|^;1b1FID6N17l9dldb<vslVfK>ueBiP^H-{1oFZCAqE`}dXNLtzb5`e|g@hY^-U|Hi&4 zHt{vMfPTdk>AMcSlN}m_17M+13ie7s-{JDDI;EW(^~~;g?j5OiS(8`^;3$}Yf>xj7 z0Fzq3b%*z#FcPpUS|h?c(-Ro))Yox!QRna?K)O^>!iKB`7b<*INlQzMGTx`A9|CXM z_Ew87il>iRMknKJg6P3`s2cK;(nx&_!d1X~wqV znNEhhmE;Hr!AFV0p&=P)WBEqWK5u7g!q@HdY4ueU2>9(Q)n>Y3olCyc%o7NKiqJ3? z2+47)sj~e|K(s>uY6oMx)W)qpKz$WR*t}Eas)lc}9Kro|`GUSJDCKuy2v-j59Z6^{ zyp9isKbZjhr403-28zGA?!&k0vwLtP-+f)vARlZ`@&$Pgi2+vLP%B~}?X$%`xD`Q& zljPq=7=$v81#^8BE>L{<-V$FlD&nhl^Y&H|O0d%hYAsFP*B>RYvG^~w+})aQa%=q_ zJ1mvf>rc-X0?D+!zwBg7gqLyw^&uGIQTNJ4-a|Lm2Jr!BJaH9IsGq30^fjRMG|f>M zd2p@|-Q_c@#74x1ACpkm7EGf($#Q;wrT=zV*E3tD;XIyAD;{w^)u~o{WUL#mQDNU7&vfn=R~ zA0rFJ9j}+2siV4{UI1F4?jTcXel(DuqBWq z(BYwZ{XuVC*wZY9bcDQ^Q6xW}Z--IseZ+kUx3S?3sQee1AUjYqlMav}1w(X7v$jQR z?s;420{*p`E(*JpdyxD8sA=z24KE_>i;7f`ZVb>uWfXS;(#|P9w`9~3NR7&gnh$wu zFLdiH$+{2m7CMlBeSi|d+wb*0DCxo3+<%($U!>K5RK%cjYY*0*w{ah>*DE4j4uz)* zRAa7fk|E|V!0)bC$DO711`875Uqen^$^;&=D0)z$L2vTm9lboaW4SLp#9Km7%qiHm zz@ReJB>~4uP+>=%24#3xpk+lL2?d^if6lspdu(0?NZ5q}{fDptb&>-tDGQHCNhH#2 z%&gzWu%g6F9h0!=Sak>bi44Xx_`6R$F~E`H)Qte&3IX+7>RIrKIqQY-VN?i68hftd zUQp^bnB0J!gG_Bikiy6O>#lxz7z)uS)KZ4y9XfV6!H;4vfkEoRyuSikI&A&p&_N2< z=-VmLHe51db`1w1tN;#Pf)nNa=zGFhaX$TX*KSM0Ld=FFuy6ru#yH*jm6|vv>>*S_vRvoxCQ9KyX&~Ls#@3g?u{tKOxp;|9tp8 zo>M^2im-Chhld_Md^l2?jp^1~JERH2JoK&%aiYe^TBJCxJgimiNXi@--bdjlwz_>R*eLdh*H+(cbD@_+8L1{@2AphLhe4OMz3g0K8#=leX_ zLGh)Bre<@Y`#)a1b|om^`EYYdGS273x1n?PV*%l=tiMY@&P7l53mARAh$ zp22mQz$Ay@oBk+;aS_a*3TPoh<;O&E>^pDd72cd7$}*JnX^BcpOPj+ zwonm=m3lx&UW`Zeo66R%9xo=uz-d3<^!H5+@-}gZ_I>Lu{hAXMKXlDYvOsxgb2Zf z<^0HzWybCWj=*54K}K|~ebS7Ard&NBIV<4za;CfNlksn7iQNaQLlOvo_gxZ7^}x;; zy~`(hQmG&~$WrZ?I}mTvih`! z09~S)?6`+1Z_xZzX_Fy$DaVFa&)`v=dTHSB7sL&NK|GY!a>5?{279z*DTWiQ{Cy{v zXanDLMLQywvmIa`0bdYbv{NmQYOk}MVgV4a^-wzAr@CNO4|+Oj^S&FyU`}UxNL1VlgXJT=O&h0^>=IW7+S%(^3E&ZhdnE%j{N=(mOIS~l z&W2>ud9A!by~HqTK}%a7MoJw^Ygku~Jz0=S9~F z?_?_`dm2c{A+3ZEqFSZod*IQHZ{&tGsh7CXqZp31tt)>rWS?jFH9wa5aLYG zi~%$GDi}C+(Ai@pvhCDr)OysF>uJ_*3e z*%-yp8T5S}afxkEWR%q84yMwO1)y>N8b(`LwoB^y4so22!oqQX4`W=!Gg>$Xf#~Tp z6Kt#70P^R5`@t;RO0^xWc&b)RyPwe!8)y6T2MdfL7NvfA&b^$+-!G<79Q7<*&=Q-Y z`9(r9o9EK$73;x>9bp)^j-qbZ#&&>l+ri2!a={$db)r9{6tmC@GXE?NlBRcgs>8Jq!ST+X(} zWl{mhEjuZ%+05#%A=rT_MrcWHkDtqPepnJvO6?LU^YC4u21}x1x~z|K-R!t+RU6Hg zC>CHgZwem*z2bA24bsAg($O(mt!=Eov=l_bU_3|bfZ6lA7XGG+I2sQOdU^hQfpE>C zQ9ANvTW`!_oE)bVUNeK|#VEJ(wJF1*KQnKY3zjKgP~u|4%p>L} zj3x-x#&A*s99#ZFH{Qd2IP@PU46zR^A>>xbH=LNEMTMRqn|cQd(1>>pPl9I%xUOcG zV-m7GaW2oJ(xRb{Pb}~h2i#Nn#g;@-$C*53D^r9WaW6LYr@k{TlM!x0CDQL9?z)UX zX$pA;a1JG|F3n@vwqU)PASVvk=@{5+(JT<~`@zFc$`F<9P%xO{99q5GL@*jmVB1ziH@rJtYm6S2YCvQNXdY{mA?;H+tO#lNOZXK^ zOmCVbV1d^@sWE~ig619lIFrm~jXYom8cwrelz@?VwotFrJ-I&6P2136Zvn#L<(U0+ z32nR(Dk6{u*&HMlQy>^LiSREJ%UVgO6NO4+5bB(tg`MoXyV#}$LxMx{gV)Y+H(m?q ztT-?}DE_TPtwz(5M2B82nuKW!Hf_11d=Vete*x8sH!*Z3f`|Aaos$5Z_P9j^;E#=xD%&&fAw}Gc@&;AId1La<42m z9BpWq_a&6K864;SvMqC4W%9U6l&t|9E zZgVPT^kNXWD|uFds2*Dh+yb%OXGOyG{k|=4rhk_)7|AkTvZx0)+^j6ImvWZtXnk{& zh3oAfK3TYC|83=Xq~T|0z`BU)F&R?*UBL2u8xFuQoAAf1JW-(rgE`?4M9p^tN7LF8 zbQ#I`%ttz_SD|0%m~WSu-KWSgCLW7WF#s}~cCQb4jxWasd5>rB(4(!GNrmQrymZ4l zc9PS}CzKpv0%f6^jaEUP5XT1@I(wW2v5=d8T**u`qIp*pkoj(zE40Rct36{Y{SS>H zrJ;Tm-X_Ud@NHOh4NpcumTO0^pn@rup9ES#eAWzG@-!%mp!I;(r45IoAEj~WOx0|w1M}0G zGnu{1e6RY66x9R2^ZjlgW;De4`Se{v);oR*)A5n}fPS#nB=C*h^QLWO|JT0Xvd!f` zz;7pv=%`!Hq?2rl491V!ekv;>Dl(V@vX2_q%h+riq$)!8w`+fqq#au^W?bIXU(Y%5IT=EL# zSu|O|p>P*51!Jg3V9Hh?W`6wH>VF#!-&~+>V9@xT$|eoyUf$4PR5rZa3g4EW04cYj zl`jIZl!!nd-g%CCPAvPy&6S3^8^EnEAqrLlM%d2iQYruppsUyjJg-1|2q9IBs##HMmrAlz3$29O)Ef3VR@(MF~%wnR?LK&?TSxa#f< zbgnkXI`!Bb43SMvXP^jdMVqe-DXuMMc-Cub2%Du`*@vFLXZRMg*Ku37N!M@pGqB(N z74TbI_=Qqd$Uq^|pBys2GHtliO%gp)@AdW%0YE3R}Wuuxop~Btv7s zT}!{?1a?Zrr8|S^%@_k!L=U`v*W;5FD;JwMw3;u2VMxK%eYeW-G*;b3kLZVnKME6r z*KJXjrNFn#2T;l*g|dp+$VB%W*W`HckXEbQL7J zIn#&`YyUFlc5+Kjm!tPG;6wm>-`0+UJTJ0n!0vF=6Xl&eMNP_6iLR|H^oj+hn+U8i zQ_P!~!6$}GUt^mbL}78g;*FK4p5+Bk2_^g8_X!IDV7rU}I;w`y^tGPfGAEy4_`8C; zk_qB&M>VNJg9@M($jL@=mOU{2aD6f_ z!;4LW*t`;Nyj-Q2+Zv-hi)dZRK=nr41#l!1v5ZXNL}GL3j8)L5g!U1066JkUSYR#H zgu6J|80&A#YX_@%7jf|2PP!{iyoyq2eJU{Ngn2-}4c-;d_ptUFDs7-pi@;`4z|Aj5 zVkMM?;Y5Nzu>l-W?&G=c7qNV3IA50^6~Q}_qH9RC%f{CB{J2IJ#BbqPtsjTV0DX0K z&SRca=yNJLT{w{CNZ>gUrbL4dLilMcQY_P~-&0xpCFrGwoEEGsB8N4_)tnul+W_R3 zNJW?^>d+2rLvve9-|B~MHgu4<=_+wO#i9&U@xdb;y9~fnQHek_I_C#N&!Adv8deldi zU*rin*i@w^dNZSAXUBuF&X*fRHmOB6ZBh2ZPE~wNw07!$2AZ2y!F7De(1YIF+-nmk)p8Zq%;(y7-Ve=CI zmRk3*9>+XO&6SFOJlkBvYlC1Ui?f$$Q3Zm##l`Q8rqwv2c4GHobdc_KuM6fwX z{%g&S(fvK1PCVAX$FlHOPCn?p@ZFj2v(%1>w3moYi?CxUfue8sWy$tt_jjl)ROG}Z zWQtOI24Rl`W+WpofnF0=tpw*+ru~4!bG{FBdh#RXk^X!YHwlH|pXXw-I*`^G@`s%U zEnYSUZP(=or8DWntOn>wh~JJS_L{+XH9{8%oAlAy;|F}k1f91W-_ZAqt?vVqPUEh5 zg>E;?{DMHvtMn)j{-e*r^on|)nJ=>;;ET;cXDPFOexyC7dU#T@)Orwg`C|e34QN<& zuOHe+Tf4#Osi&TP9wOcb+y1i1aAy= z!mP4%0S0IMl;WOUI_;pu!P|e1w_jc-9pypg4tg7tdB#&&RmtYRZ@1;bd+&+~8qQmE ziGOt8jsf%JT#9rqHz(K}ovb0C52~7R5?x`CW=0`dDt(%@&1)-D?(_Huy)_0qBCujE zdfyn`kk@s;PXc-%HV2&+Z;)Z$gt*YABRvgVtEZ@2MIZ%mz+^Fzwni2!{T=2@*AJ~# zmOFEoOKp`MymdA<;aKFGD^ij!rI;Mc?-CuO?8ScFqijm9{x8N<4)W&cOFyTc4qu@Q z7rz_hrg$qvzq-VDJ(xBeQ63J&g#3Ho)t;?h7_Nj3ps>7EsU zbimlYWJn|>4l@iBc%SEZ<4@bsy5h_1E^7F{!zJaAQK3@)YcaznNg_f0ooFSZaTg7w z)O4FxtdG)G0;5$|U^*%&h$V1bgr<%Tvz|e=rNZ5otoH>UZ(S(i^kA4+z#AoA#o|x; zD&7uQTM{T3dQ0=H8mME}ptn4DsEa5(9-G5Hse_Wje4X0VDo6S`75YElF6Kcmdh=+!Q4_5LDB5&x+g!7jES1TrB08&DMCtXyuZL* zP5bgNo&Jk~&uZd`VQ2P(<0<9XR_^7H0AcT_P+Rb#+@IV_|->&o@uKPYoH;6gl4y}5=8>brg;AlV*I zt+OB-#FFahb#LAw2k(&lF1~FM1QUSuY@!2izcbyMhdxggb^M3YzTe4u_0Oe=VM23j zm+n*@A__?j=Yj}5e~Dq*L0!0u1^`;?J)$fZ_vd-<)86U4CulI$7Ky4QZ&14&L&9QN z)GWl{!W?`JdSPKl#pzFSa0mU+@1#HHlSY&1#qLA)qyg%YWkSYs^jCdz8YeL$WCRxk zxyl7<7_Ca&qt_=LwyfZqfPUKLViW903=^(#svbBfeHlZTcz|FYB%?_ziq|s0bWFeymj#xB0|9LYtfNlCd$N zUsRO~<4tbEc#kUw3ifqj*hE~YCm!1@UT z`|5MB#gxWeG$Z%!KOI# zP449BVBmb_A3{I>%isGq(1>iOSO$v_87ljM+tYy3d9coOG5=FEPWe>cKQxar0Xm_A zr$j6x;uBi^j6fir$4F^C7A^MOTByDXVwJ>W2?KZ%#o_xHJ z|1ioveARj}PsV@O+v+@01CC^n77ymiehThx7&)aheob68n&#tWFlj`D%&cY3SDVqaQoQy>fjvNzW6T$d(C<}G2plVsl zj~LEu8ir3#8N;ic!L8!35aBE}!NJCtzs%G-5Zv$wfZUPrC(MtQWm9~l#{-XYuqRO3 zohor8cN=OFQlPWQwfSB8yyN<)pa+gdzMO;^v$Z;Mt|q?$jZEg| zypg;)O-tTZKKIA_nak25tu^`&@v-YJQ+`VMLFp~X2J1uh2qqSJfjkee)|Q+d2Zdo7 z@~ko*OF~AQf1qn$zTAFUg%P&0n^A*MjH(Wbr zW@7v<2fj>P9-2n__hzLrQW|}%j z`tEr+yp>5z(f^v757FqFnp9}?3ORy1)BHoAT;v$TWoh=Qbi5fqoE)K*(=A!wdBt@o ztGUtVIa3jo6}?`O|Hs2)@n*zEd@w1Szsn|HbvJJ?HL(>uXBB)L@_2OxQ)5+T6CzZl z<~ioNZ!A@wB4|t_2}y-wg$N{)=q9?rx{<~4t&+}tEw3=F|MD>5m8?22gHes;7I(gG z;jXTdCm(Aw+uv7lX{WFcU{VV*hn{qH1E3XrS3l0Y`*EuW|K+5K@6msdK+it=60;Cv z2;OD8Q!0{328~H6@v^D5(+A@33>YNf1ui=D#1hL zu-mrYD%}K!0)nvK?C_L9g-C>lct~KB?2{k9NP<+U0U(L%KToTmVErfb7%nq%3Ss_NmmK^J zC{wv!W#fP*Cj!F(ro2>Qzj=oh+E>2f(ApvjioLykcr|4!FBXD`HHA(y#dv1wi_0lH zLZfvS-O~qL#-a>`KY%&6Ohs3njm& zo-&uAjB8cK(n-tzks)C5l%0XTN`##RWb{&hXU$~mKYu`X(tD^2gs!<5wHyKHZ&xf` z(*kv4Q`o40OV_naPwj<@p{TY$X=iceuOcRITL0a^pS)N=wpJ2w5Bt3(r$#}fX#YZh z`xR|bz-Dcy4afFB{qzH#0%_~zeAX{{AYkvX%LF$j#-~P{?#PzgqEQNl-9!I@4Zi&b3h=bP!HB&4r_;} zWqo)Yax%670d%1b#B~wN z>PkX2xRJ~;FenHD`&AM;M`g&~7xS8;JZE!&ubCp))MqoXG;0OJ6~Hy}g}z2KgOLbn zutRk@qRFYX`INMv@r(Q3m!uB(E(=71t6Am$WjMr@|6d&1ziAnNbq!|Ko)TmMAqK`B zKl*6mxT3=R2^C)(eC-;;))62sll#(><_Yw`s3W6+hf?{}14az`QM*++G=>H-e;Sw# zPwWpOxg~gV{_BjUU%_8Jd866^P^^h}OfDFZ=FTI4m~2fzNtdAM7-r>*`8#R*kQfye z!WZW@4t_n4IrfEKXp@FH+O*2wjjqH5F^on(EDE z*@gvFj7(brVic&=#&KLs|5)q;rNIUrmD4{d?1f&M2!Fqt4zJQxp8f%E9ZYrJtt59c z$AmLK(uz#Xu706;tS^ z(uJ?H8s7Dh4gKw1wd7VX7DPeWd%%YE~y=&HJCdgk`F3xQxEA~5rH zyw3tS1p{DUfN>p(WEc>M;@h_aQ~5uRVq_UJ^`#0ft{V73e@7`G>^yy5D34SQvsU#X zVZq5~%9tSJ5_1E`S*jqj(Q*UuAOn8l)A==+MX!giyAy_*X{QFr(1LP>7mJvooCw(3 zkmP?{nsh_N5LoW|`Ri-sSrq;kds!o#yC#8|TEqS;X=x6puMs=Ow{=?LcO#)@rNYq| zQnC>UOl(_cgi9P(;Dw1GpB0Bd2T)C|GoN3!D#>ZAS#yuS;?>+Ki3W&rIGp%()qx9B z-SIl1~oCpOSQ73X6p{S6xZzWmQa@SAMq$kI`vHyCp0F%YPmf&_8j;K>9 z!k8C;q(u%^2s`fgX{bqgaUr^edGd&?U3I^BRt%p;J|f8TjoK0?0>`*nLrl65gqYWQ zODh>|bl28Eo>AZ|r@#d(Iq-~wdR>Lc$+iTbG-nXWZ2m9Olw=r_1E5u;CkEPdD?Q|u@(QRG_M9`vijha(` zq_kTWJj}*DrsJXC^gf9y988KcBCc^-uH9Q|S!Unm+%eI1!qBKzcJO~mo!xl5N6|`I z)=B7QNwRzB;jU#4IvutJKg)fx=-$$A?_N9UBnOi3CXHu}S&kgz)&d`*t&P5Vu2Bva zva0!8OOm)*2XHhJn*-091z`6RHH&S8k!9pBn)64KQkbHkD}&fjj6fT(4lworScwL6 zyXQmeEAy1sEdxk+AMB7ILRU^_AU%J9k%%>|Wd>M|@joFaP+?f}tgj4ZV{Sh&j$c z$dCT4w;1}rArT+^B#xMofFeksHKzjx-GFuf1EA`WX#a!}PK%W$(i{yYNTP=bBAx{7bPR4- zb~H94^hjx#)g?l2y8*oPR^|5xzka<6c3COMIRCN=Ogn59i{DxWS{Oj9_OPb1Cs30Z znzc>;?NQ<{u>4;|(D$WNZ-EZ}k{tlLf++cc7_cQhNP<==^#C*qPNGeB>&h4(`nh>&!+=AyuQ z(#nwo8QDS*CZ0Vx-dhTXM|Zv)2c7XNj1ymiV@}+}=v;3V!JHLUtx_I}54Rw?XbX1F zvzIOV%;#0EW!kHI;Y6z;d32FoAl+U(X)i(xz_v5Ug`~fYgeqe0+Z7XKdwigZk%l|PWRk|v zu?~%p0y6U;y&n-5gWxYES+ed6V#Ps!eeKRbR)=Zv2MhGi(>U@_?xyEb_Z&@@*vm$i z@ee_-XaJWJx{^ zVaiQB<*bUArR$!a+03~Kv~sbZ`BMY1{zEixh4MeQcN&R5}le$hIm!yB@j?!f&X=!G%XA+?+!%OAoo(RrhX&UBSm&;JM z;C(a$+@9)95q^Tnq0r491GgyDKKuN6MZwL! zr$Xo;C=r$jN$T+VK;i3s(f^Mu{j76}4;AYBP;lj)k2nO>z*>3;WH4UL^Oy{T#4&sJDIAL1g;xc4)$qs! zF?g4;_mLk{K|pzIOAb-pZDi6(kbgd6HPDUtHaCz*7jSqF6tHBi67x~C>@!k#t+jkBGh zuks^zSnQ0+tYTN{M@fr_RLcwtk@Q@9>_Q5`W=qRV>q*wMLFWf6hxfU)_vA0Yra%ZU zN&w(lcS-;I43Y?5y}q9$X#JJr{kSvh*nNJbt_R{Wi0cRzB$rf9Fb#uFX+7elRhd2M zaZe-|4Qa%WV6Fy4)4=rb+0PhighA;1ngzyV%3KV>QP52EHbIJB1jxl zJTBRukO>&76S7y+QfLOk?+P+^DWppfn2udGJ0mdmXa<{u1!)?WLBOCaN@6N};n_`o zXxuyEZa)!$8Kj8&+BJqGk|bpZ1v|11r3DDSw0s8CqP94iww=VW5BNzM(SAZ;Y%htA z&$+gIK~67_4_wgeO~~pg@XdV{Nl~9MS6Q{Y@=>pb5%iTBIArDhvu$Bm@rGna)dP%^ z2;3nfl~HN_c@Rr-SOUX0W>Cit>DT9E>O=}cNbmBX3##o1Cg&B#TLQ&6d7tUEI$}m^ z43fw;g?gVx!^j?=?wG=En1j|^BmnhrE_G@0B0UG32Fz5myT`B4P(J~R8zLzWe%kfD z=yQV@u_zJE@}(n|SfyJdd%U`_YTe_0S+(v;1|?@>D|3=ITJ#@?E)sfpL%VNMpxYi# zcs`;WD4;ii$DZB;CEA2Tz&-tO@W2xk=5!@iE$Q}&ctM-dZ4A*uRR73>Z3C7Qso?wM zl>w~1Nmdw67(S<697W6W^;hZ`<$RI$S)$zM670vYeiQefG&Jl_Hw+oREi{wy(#lh@ zUu1X27{kcN$c~6L`k=MTxhiCZV0+!ET%t7u-@WW-u8>M1K$0a$7$Ur0cNQpcm#<=@ z#rI^P>*!R_u?K0wLj`%k13`h0q8}}lS+qJ&*clJ0=DV1<-1`cMahiM^;Jwp(G#p#n zC>kGh%)x!6iP>Y2-VMXR5E;n(5af;&Bi23{Rd%nUy{rTk6M7va!-jahl!CHhp-JFKiDDA*p^CuwvSQ52qU$|zJQ>|YK_j2dJfdf zxGgT9xWnMJR&))lX>6$>PKI`#oWtp@P9v6KKBECR~WkFh8eF00JZYGASq0vYH0ns>cx8T$a`K zCEw#4zv>bl;TVaetIBqX{w!5?wp#w^R)aZ+8AlCci|eXH%_n)o#iGKdBCOZBJ^Ryf zu<2D$K3ysOGmDgJMnnT4Dj8Aocid}+x{M~6q^BkOm`g)cXpd_fAp$2%9?YOo5xWo0 zD6Jqb?84-p^1}icrnXeU$Mb4c!#$)0l$m@vy;SszU4Qf~-72C#F#dw%<+0TD#m^K) zsOpBMI};g*6WIi`a3OB2fYvv;$grt8OUT1VdAB&i{20v-s2R1j=WK*8*S zpBhyJdwkR%HkFczNegtjB~;p?>bxMt-kT-*n28EnH1zk zs;pAvr-P-<>b}X6qK6Z`IS*Zj!qmQRtcH1eF#7V9?ufv4&?z%E*hd>_h=k?R2IhbC zhV_-*#tZ!nBXUY45h3TF>wdEigk@psg@`oLrWcW0m>K+FV zYn;%UZz$i~OJYEdm0PZ%Q3H-}rKvXAmJkU<78rpecagV_U{46S7qdB(7Ll-49cAnz z6QQJgI^V7r;js_uTyeZyR#FLM35>B2$6yrw<8z6LQ`Vhfj2XRHWYcz5w(TOz{dr1nb$q?DJRdrm z3Ea+#uYJ;}Y&fG>FEl$$Y{sdWS5#HrjZPU47c({0dbr2@U#ZUh5m=wQvC+t|mn0-a z&s3J@w!qO-4sc1`lT55U8Ilmpb$fAwCR-Ue30MNmB7TI+`ZERw2IFZ@!77X{4a1!$ z6Mn#a+DS&441Ge+{>9q6w9v*Ho5u}k?b7EOSTZc7f)0_)Z9q?nKovKzqnnSU762_G z+}y|GNs5qvq48(?J4(1IrBy`LoTNO1l0Yv^XdI=2XqoUn(1uu*yq_HmB#g4|N>j?AqVRrpF!>H=!TqFVp zNoGk@#}FZ3MT&QGu6H$wnoL$MSw_}MBUYy)&moYo)l+VK4FMtvsawP+535EcEFOaP zRCG~4^VxOj{DEK8XEzHH*{V_#Xm-`y8{wLF^-hBh%;wNtp}xsYCX0Bi_DxBdOdH6nPT@xZdY(8*g(LJI?cdB>ls>3ZEOQoMBZSGg< z!$@t-hzEFT9&js&K$iqLr}Y{)G~wuQ$Zg@^%W*C$xIJH~n}Hv&57y9nw*!#4!r;K? zfhcs)(aJ&G=ekY@@uoaj+iIfw(W>$_y*%rPrq?=WpnBvbB%NV!;+Vmklgu-&^uvtU%+N?9Y?d%V8}R!3(P8&=p?w)ucr zk`-i?^TRAm)S>9`ARBvBJ7le^SCoTn=RsyS9A0#A$;HF=;!o&bJdhA?lA8Obc~p@0 zXPA%To-FBg+OZF4mtNx#)fpZjm{u?NfP&RyjgS$|$Dlw8!y7Q|d<0dBBc16(pC`D4 zfd~?F2o^Z=Cmst-gdIZo<-^Si!2?Bh*1C=&{Zx}nIa`R2h)6d-*}<>&3=jfZN^*h` zkb55Cm6j>b28ni#2LOlgXTFo4nJr}=OUPJ@5IzaA%dz^LG*w|&Pc3(!0gXGbv2jTWXwaEU z!SCUdqgIX)2#_)_*B+uX|H_ajH&f9Gn)51>@Lk0q8SeyF<-DqatUgoEO9BpaeflWC zYKof79hb%djVI{|RfRSA5Y|E$I-zP~2yyU! zBbI8@pyYyYR@Et#tsb0tW6)V=^V8ZbSC0*TwCR?UAp_Fy>*5>KBWMA^v(H>U*gKlNA`DP|t^DXeL-%Ei?`xlWH5XB#f~z}RPynM4brm8)J4vxA zZ_tSq<%m?aQ6FY)9G$V~?w$Rx1CV*=M~wYn=z@N}b8sY*z*Ze3KC| zHc=CPg>khVgs1JWbO`ocEp>kU{n%@e*gdg literal 54603 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

Z_XIgQ^1&n~0(~v&H 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 literal 55960 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 diff --git a/performance-tests/scalability.png b/performance-tests/scalability.png index 4a1f742cfe4584f68fcdbdeaf950d70ba6bce3bc..f192419002553825737143efec3c68579fdd4292 100644 GIT binary patch literal 110134 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 literal 113130 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 diff --git a/performance-tests/throughput.png b/performance-tests/throughput.png index 3eb36cd6c8794c8b2555a58335f06ba055b43dc2..0f1811a9b2167e231aac2f51ed26c3d176bf778e 100644 GIT binary patch literal 70066 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

j-$QNKERqYtb@Xhis1(_j;CUA?-usmPXAT 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%0D@c;|vRSu)e7tnHW3feA}p{$|URoWxjt&4y< zDXM#3@COB!3{s1_lx^*;R|mXk`YSlq5T?;{ky?RGFcc92B0C@6jlw=Mm?)BW{_N)Dk+ml7(a-AAXPm!fc!6jZDU zVdj?UdGD1gN?&4jb)dn33i9IE2_h_5jUZItc=_G6JwN?ai1XaXsS~Y@y6=(|jQ#l= z7~sb6_`HKC4E&>WD%kzK^a^$Up!aD*O!*Jl#01V-pLSn$GGbqo6{*GO$SdqY@g-pw zvddt7VU##k4-_br(sJ&eT6%$If1*!SEEzDOsnN(BE&@_ZJe(VO!~fQqpi5In0H-0} z+4x&ur}b^P0E|iQ1Xiiqu4>t{`~}d|^!M-?VHBw$1(!Xwov7urj{)ycZ;nuI&bWg7 zyBEUi)9Y*>`W19zvQv_C6~0@_CZ}>1*2p(3>rE-c5nR<_TIOz1R@4O@?xrBS6M>IX zBQjF1Ak+v0MaXA+m#og>R%&eh8q*5Llk)l z!=$NVI-){Qj3!;Xj*@=y><`rKIVfl~iD{K1eH#hH$_T79h=OFwv-7OA&CJX+<8^f# zm0ktM__5f^Wqy?Ps|3teZqO(>b>dID{1apS`C_;*4O;&C*sgV`B#DA%>2vhfe9_B# zcBsY}Ndh}V%{bwCiKZrj0FL1p2U7Fn7j;XGGGeMVBK1H{1UMmoUw_GOBfbcjD_jVf zIRRD#vc~gBx6+SR?+tegZe{rYyjeH<2&FsxV(gV@_iE>WJsFj@`;?v8s;^n7BLk1* zzp*rXS$4<1et67{uvv@D}!c+=b;}LKiWt?fhk& z<>jKf<(Q^def@RVDb44h%c%PpQ-VvZ-Dm)$c;Ui@g|*5m9fM)#idGeifbLFX?V^@d ztf{p1D3_>fze7jJchldL}Ed8w0TVnZj(+pYU;c|AKnyci0hGk0M^C~Gq@f>+Of zP=&9fLCnj{4iqojYPm2mb8^Ce8fnrJ67=MsQhMU*vV2Uf4psSlBr%1}J6L@=$V#NI zoK4_{#0v|QkU0vZxTa;G<;HZJfDr&9hd15>wVV}og34SE6+3cWkicjJ{Omg0w!hRO zAx@JQ3^_Cqm{Uq{d;8y?7BU1JxNpCE`qFQ|y-3?>p2j{Q z|FNM}KqdmM5C+TAjJGf9BJ*c!BcRK^w9AMafPXX|2;7SFWPj~TB$MdyHjn~NRBPt= z!I=M4*HT{!gQ5QOkl{Z)2M!XD!qj0X6I|&LCw>`gyp)_lz+W*dI&TpImW;>9X|W_7 zsh$!&7ip+q-~3{#KkJOJf&Lw7V`O6icy&p$dsIBWON>*Itu2NGcsY@0sP_?1u;?nu zJZQ!fKB%(&)Q4#W^Q}|*>}7@`XR-0$n*Gsa;(t2(GjmAU(;KkRil8Ey2Y7vBI7aa_ z&;0W;=FI9lv81FVW%-;&r)qtE*=gtg;Kgm)Rp0F1WY5~Sk{2|q(Q?lk_g#^N+mhGL z9~Sam9IZ#Bw)w7O0{{{jr;{eTOGQ0?Yzi8(|id6ie2W;J(8D~SLw#pudULt{#h13K9LwBH=l;R_dP*L zk&Gov(Af!cjtPuNZ!5OzjxPdMo?-{86-U5>1Gs;piu)L`k<*w!OS+0WU+b-?jdni$ zh$g~l-%J>ud=bh-=p1^ccRJ0Q6n5(wN0E6lN@=;Qw^&fzZRu*slwcAg&K#Tn{PEP0 z3@tbe&prx-Ha>ck_e@VFqnCT6we>l^y4m1n`gZHS{jQ_F-MH`8UbL?NUcFP@rkTH8 z%=6Gq-iI6<_m_+Id;?v^&0l|QFmd91792d>aC((L|s!b0}jKl^1e53 zdKKR`{qVyN9=BX0sq|74vvYHO&(E}k{GzHKmn$M%G^M`bPPQF8$J*Lj>$jg#ekI|? zA*s1dP@kfC>$!QxX9Z911lcSNNhJma+V0%BQ}Ze7)~{!pYVnA(Pbd0jJ2;nC(*{FP zOiG6^D;D$U_M8^(?k$2Ql|TG2DR~1PhSE-Q5u{U+&rC9k zSp%4uwD=;E4~(WrMaQ#DLtN?ZONbI`a)`Zd+{M7h2M)9&MB8&!v`dR;;K96-vg;i1 z`8b=kXS07ARk*xYz2&p)0*+I;2A6Eeo!_|83L|Qx(u zqmuSioug8128AitCQ5W+hteidZSMjvA-N2Wj6S!TN2*?zxp5vHnnUpV$nIQxLham=<`2(!83V6>7T%UD z1NPdRPm@GSG;_A#?u5-1>({T>v^Rz-ZsdK&=6Xb?+{R%-eFfv|GWzIkG)jD|P3D;N zbxgD6T~ZK5wfD{&A{~<0Q|Jisu<*h+?L5kwN<;NJAA3jnBQKb<#%KGccMiwC;Zyz7 zyy>m4UMYis@*7u8f5Yc<%X1L(#i?bhw^?wwdz%_qq>+Z0zg2lX{p^GYh6ElV@ev=3 zy_ig4^x?VOlZXg5S>MdDJW=^U4JM+v1whl3j+AMp-Jd@~&I4O0BR-9#NvKO{QhRVS z%WwI(+GlMrnYN$~=!qEAlf=d)W3a9ActSeNg(D1Z{%*hJl z0ibW)gD^oPfHE|fFk(^AhcmVS1a3v3nL|Gg%gXoNEpBIYwC*<*K^^289}JI+39KDr3o4?o<&+xgT@iRwi`APxqM+@pQ>`J{gpet4$CTOu}D2--g;-_72(KLt+U`AhskWIXU>dyYI3X z>F`fHb&y(Zx4f)zIujcdA;90wlxuAkh9T-JsTHrxp;a?Ao7%GnrlL7dB z>K2oynl)_rvE0@E^5u|V#`9yCL(s=$)s00z+MQ}|W&C(YMieUT?_v35`HLGY@Ws(u z_z)jZvM3Vz4psjUp1FWx!;pq(`ZXZHpo~w;e;J*J$0s{2FLC3$V{d-n>BA2-e3PgV zWJDw!gQ3h$IS0;|5HXa<<%0G)@9yhO|8i=e)dtgRCDY%wMkm0v4c$v-(u}0IUn+{wTRtR?d5@?Vlpu?vC6Ku%3d-cx^13)kR~M%#$k@Vj4)*t z)TdEs8zy)z5UCFM6pVWM^l1+B8SVdgw(?IetDDd18;q`q(ta-j>ZV8@`JFg#4{#XQ z4r`Gt-RTkb@_o|VT203X{0Ijjd26q#dw62G?yI(L9Tz!nBfIpBf?+F1d}8^k`QJ8J zP)yt2Vnuu~U2dkA2N>zi8#jXCN^16Swfxu(-Dv1CY>}OSSVt@-rKa$8Do4Ex#1GCb zi#di&@pN2VT=ErCIx4=nOP3=4>8w{w2Q|Z_eQMKAot}k_Bc}1NCyglh+LC`_{?1{h zTQLRGh}`(FRr~gXfnkqxo6v}kt`%ar8Os{;a|EIlTeoiA)_-FdE$sxm2^>Yu%hKyn zu4UZo1p!Rf~dKmNG6d%i%Mn3J)Y-+Zd?rO6a3K-pzU zZl%)Dl*B}eq$&`36f)t54yDKw7!_K>-lUO$#q*d}5tc3vik(g_T5tnclSEmkVjAE! z%F2!I;2DZi!82VR#5EjR?r9(1F9}Qb;9DDf`|+NGhYee!1{RX%HnYhCskB}51pFY; z8gdq)(h&((>4YM)rs|x>eEiG!4r|Z$Y$=x-^U_in^T_Ai{7aN2m@wq_2+RAC=en`6 z6ZU;SuBv`~uJ6Z-TfH*pM%2RoQPo|eM~6B6>Y(f1^C}S{rdG2Ai>RPRI_Hytqy#~fW@LS%yX!4lb{~i#d9T1r)6u+ z&-7j2seSBz?t(KhA7j(C^Y)tgm7q%2=H~jv!;K|z<89ms^`4%dr)@MhI2Yq&FBboV zK1M36qsP{%31e3B6#{x-Qv4bt*$K>vHKB~tkzrt zdfbG}7ss#qE8T7SruoW-t~^8nP>^3tcsG(rHH^W_Bq9l+Y|n8i`4!{Zw?FuS9*^#? ze7|(53!=apHEV8%e7IR_$*s$p{{%zQv@%*juO;KaWm*{PG}ax9$>xh)gBR-4=u+MD z*;;-BK-R#hA!wq)c19q9!UlPJdqWhjWC+u#RtTSMlfk-i<4~j#G7Et12?3+NRlG(P zvH%|2{Y#3k>8ccTn$K;Y%M(kY>wnYNe1D&8?@=+GrPPg$sT-CDZP*Y75Kd&5H?~AS z;A~9W6>6T807MADvDCHnYL+wc(+s7_0#wsu*h@U{J1b{cHNx61Gwb$+=q1-Mf|pK$ zGSu>xqrZA9YBVx|H{N(de;s%n+)qHenQNMm^B$A`Rw`Lv8*XLD+Pn{US-E_H+o=Ml z?w?zDdov$yVr^gQQF3xW(iavW&fJe#C}Km~=#$5fKXP4EcEp~BL}7j^5LAHHvC@rE z3yRM|>dTQ<9WP>mWWw8?<2D33H%NYM-382PXbdbkQJim=5Ct-&YC_(-^?dX8w@8V` zMkDYYn{MsnXP6=2NM zp}AbiPmKL#cgN(3`NQU7uM$z{dhQW&UW}b|JZ8sGS-5lD0%Jy)WNpBK)sm#Zk&(#N zF7m`2RLSt{S#J|lj6B-!(!XDOuyZ%jVHaW5dGb1tPryBmuqSs4YK22-#cGWv(QxxH zczl%6Z2C3EcLs%>f;&9z(czj`I^`OV=93Y7N6WI~=bvxPHDiD2p*?IJPa&VEUAs29 zz&`LeA?x&b8`tRQE^>NAk6AhV6Eeycn$Mv0NM?#yxo8FK64tGWu5W@p`**x(4srog~Q`?h;6ea1qvfYc9`+pW7I+Tt&URAs%Hc3xLvw9 zUTcThP#fQr-j0#y8v$=6{E+voCNt*7)OwBELcgdzlHpZoDbAnXt&%H!7p&R_6&3Goko3AaO^!M{k6IEiB2=V%A>J4Th%n49&6Az*pprAs;r+Qv&Ycl3IK zLo_}>G6v#A9jx=pLpr6~Jd}_NLjv!Ejwwmd7d09^`dW+U+EA%=x5?g|d0AqM??qa* z8|osv=7|`xJe#oY!q?g=}LsI(6%DwA9_M6 zNc+It7a%uqK<<&P9aaT1b+wBa>pUf>SHhF0PhBfsH@`{uiy!lKX7BhNy^$%nl%yG- zbG}MCTk3-GuOAG|t3^RKZ{L=g5{?L6(jKPia00_9hQBtfl+KOve-k#hUNi39=|@8# z{xuqQ_?=>6#kH9&IX=tjwr|bpJ~cV*UH4fPvJ~t+nyO_FS8wKD`|rn%_>ee89MBAD8nnQhB`A$?_!wei{#IwtV@RpTjLb zRlQbOnX12t`Qqys3r1pi_k+ADMSTeVYN~m_W+CvDBS+8Gs?GH$rc2vd3yab0x1tRf z2p~Z*d2IJHZSsH+9wGe?ar)u0Ohh0e3Xc8$AVJ$qfxxwoRD>tqw(x>SuBW3QPPleW zk`L7+L;}o&BI~52@q9~HLM(<-)lVR^h?~)mOwW61J%O#Aojk>r$hjL2XPqzoc!q$V z#tg}Naq8V^w>9xeF(M9NMf^(FK0?Fkv_$oSMxQNOqf!}VqC^vM=g#%hibNS)(+y*W zFhfiyiFBoFrc4`H)1gr}x>cCg6czp;ZFJo4ryUeY!~au#stSd2ayyK^qV!y_)rj@l z{;tVk*ajC8VlwDHeT?>rsDCBDK6u`??86(XR{{Q^_|;NIJQBp>sT>CDo@f`zBp!E` zIrTF|N2mtPW~f~7+w_eWpih~f@1)K_3@DY&&O@1V6WsfOZp*lVf4{@jo^04OhXlf( zz*ol9kC}>yHPr|dAjZwRbdjOD_Gd$cn)h?_RA|J9jI}a^_VHN`=~%$Msw-l+92f_2 z4OODaDDLTtm)K^duR$9~Z{uyurrusOL$UiAk}?IO8@uV7A=Z|lmo#o^mkG)FB+}N$ zpY$-v27l$s>JHZkVa<%9AK?V24o(rzi%X7X9`DR0&>WPkoGZy{p5(+)ksd?kT4xFd z#2bD#m2G_5n91nykW==gmSc=twNn(KGZqG!n|+#toB<`v8PU*rny3efA}4hVXouHSD(~Z{Zw#T z>^au(IhY`>w}GH2s<1v{Y@jVQ=1MCDx-RT`&h2!5UP3RvLr)zUnTBR|SoVzrZnjQ;V6NYi?y{H!=n;>)Mg`Xxx~Lni{zg zUpqdn=I%Vb)>kmD8sD10SkLyuQKJ7o{=C1n;^dWXU!MQILdEmPx8#obJz9vzfFa~t z*NGEd>Zf!VzmQTZgO*eEZk?sy*`mM0+qWf^4i;wnySqRA50s}RiA2@>I&ZrF%~dXi z8%uugMLFn1x{{8O=hwl6#n5IU$T*Hr8EP$b4cc-dV`jG3I!I9J&r5VtB9l9!;tcg>w zH*>2GP_UQMRzobJ4g03_LlZ(HY_>L_=9XF_{PjZQHccBhZmj7E2*!lO6VtABH98Vj z_grneG$cN+WIJSmqVTzM=Y+Za<*X0MYLzknquZGA$-7q*ln4{#884&(*_=CAap3B& zuAV03{*_|2oBw6ZFTZ@szXV!QBeiqzN782nr{2%`E>5RBXBxf*IB4Fai9K&WG@C9F z9&WhvOo>-$eI)G!mvWmr&4OGH_y!Kb?B62={)TxE;>+1}uqMP3=(cF}6L3RwL>Wt# zEU`UT5&e=C0un8z*>`~4F;Y@+`Gq5fO?5vP@Je}EV(=hn(Rbo}>OiyLR67hpZ5f{z zCZ@g*E_vA1ONoiXIeF;aSzij&8JBiekcs|OQZ4eXE3mt!bc54cYuWXH$m;+`6XpyY zjNSUzZ`9p|tW2b%`=xE_m$knN$eknJpUi$}O#zcv3~={k@NobSm$W@3m}WLMj&Kp0 zJpJsm&jP(}0jC567zDy-NfFP(LC^`&&F+c8-%>1fS^MH;0TnrJQr6TCYvnnuUiz=} zP9d(}J4oBjoX>Q4_dcb@gr{B;?rm7lu^LXrBbOX%VzXBMBvu~ANJww3f z6NqjT8oteKbA}<&Iv?YqlRlw8y(n4zLsyVxDtEU9b=yANcOL}WimveItlpJIA3L_0 zXSlOx`ike<2M%cW$?i&R6v7UF(^8LiR;tUay0d>9wADdxQ*X#?LCfEP@ZzcCXldw- zevJ>mg%hXwWs`bQH>Ugrj8ZCW1;>(BlbsYcTSk<9QUi=aj31+{^3BBHUP9(BNVrm$ zq!As2K?}m69n(sqN{1aSzvda+Vd2(mTPdB07Lr=~RAK50_(Y^ApMzS*`I{Q0y&ZV% zG&1No79Ns^fY(Vflmj;)75IcT{)trRbz0uvr7QY;&KKX!%e#@6*P>?4)jf7tXt{u+ zP=vnF>{QWP+6FqW0io2@+q0)#Jr1D>=E07;~ zhR7D30GA?*Z)j8=k!B!X%#2;+Z<3HoF=5}IB1quto5Bmtf0i}>dfl&6>9wDFfr4OE zuSno8P#D{lJ#6R80 zSM$N{oxv?=QYX1N^zEArh2c7Fni#jCSJ$?4d*9dBSN_r8I9l#kTn)-{x9itk zs)0t_cd=Uk&YO{Zgn|_-dM96@oiGYF{3j;fYC5rU8(RFvVph3KaQ$eAB@B*Ov|cMa z^u&KPvXSK@9-c5Q=_maJ9kkg=VfO5})KuGqAIQn7t4+a-S=99Y*7EZ=){I%;yN$-> z+WzxD{wSaI7C*aN{t-pPl9iT=oAuGSCvOxjT2w`y855DT+-GNa0O3{I`SNb(FCMd? zm|jsv(_%%5B1dy)o1eV{e+nPI>cSDL=3>vA1cuf!B6VG;?cutXk~QE>i8z=913Os< zmMK80DUwO!5W%DS8fZ|o0f6ifZ-a^12C1lT)mQNqh7jWP?t(gD?!7@KTu>8}N zb=*ig`WwIf#wj|PnF^C){=@IQ6@_P`OzKJTAB>%2`4tbiR6mMk?c+oIQ;JT+bfG;? zWMOC$@;MaLio|drsY}kr#mS0j@QL|;hohook44{kkdd*^+RL>-!x#AI4dqe5oAbqz z++J*(5UB86WLxH$W0}8T~65~eCeuq=ubEQIG{hFGxB?jC^ zw?ZQ}YRNbb|K0{4e|`Jg#v3kB>xN+$eH!+hpdbEDN9;M9Cj z%bcd1v#$YgNkpngDKzpRE3!3^E3Y(L}^MH5I~%=2E108^!V}PXLyAQ zqNQTH!;-#b*z5s8_?%CvivgWVUmjRZW16g7TwHhz`=F1Cd}OAx=1j0R=Z&l%M8Z{%C-TRbri4(lLpCCb03 z#a387x_$9ux_@f0{*n%OG&5BZCeo<8cLXJKkihO zjHnqWQy`!)&>cdA3XY8v#Vd84U#HE@tl^G6=AL;Oe9p=jE@IWH7K8d+?DIy3Zq^1s~ zx96?o%nIL|lan*_88Lhn0P_?f0iV5!0IxB7V!*sQK@r1zC81T2npFI%Y#;X?f7Tn; zbR{}K^_%j=@vLXX?;_-dFY&?;T9Y`5-WUjILYEFE@@mM2ccqFV#T}%Q4PBoHB_?JI zu8YxMsnng#OhGUpdhSzNEnFxeL>MhGHfhK)D4$SJ9Ozp*~{jWgq4Tzfd8 z(vM1VvM^PQfufjMCmNtZx_yCP;4_tX{#0SLEKG9+PwxmtWuTk?QSl zhSUIBja%sX=I}+WUU?crGu`Rl&)a*hUbcr&*#sGV+VQfGVhScSI%r3n_Wr0|WX6%k za4_Zfp6plu_P0C0A7>xW6+D1&qsj4iiABFdd&>2fRKlldaKtZRe@Wh8lMH7QXJcPxn zo$L9*jVeW4UxbC(?z`j1o8WdhUw;+q2*&QyCrOk`%6_T^XX26!EC0UAl7g3Yq#h;a zsm;*lPU?5NB@X@iF*@)Chyiq-(_bq7Ymhu>)HGH`^Yln|h~i#&LP+1qnnr8m$Y4bmWK5LKOc%hE_hj}rK+OBO#QW$ zvCM2oKBD$V>V}m(BsYqg799-NJ?76cFp_v%t$zVy7|iBIse$PsjV79&tuP#*ZwYZP zb9Y?(kINUyVveY{>Y}U8oBk}D_;p>TCQJXseDURr0*CY8K*Z(U!R2N zlC_|iR>Ue}ew#Zbk(N7jZ&QJ~5a<;A!j|RU=PD$VR4a$ox4giEo%VH_j_a_N&sz3Z0d;D88}pok(9_GS{Sixx zX2_4ryj{-oEqXFZph$NED1H~WdRb!GHCq|;{EMnxFJQ>N`zq*26Fa-;5obHXn9;p{ zw9?Wj1@x_c70t_rlT&SiJpEclb9S}c6pHxJrrwtCSpOO%dI4k?&au`RZ)6f$TEYpC z#`2cTL`v5PcuIK*(a~1}U)HK~oSQ80B_j+*evwe5jmQk1GQl&n)=PotfUGKW-0qMw z7Y(t%r2*vzow;4EQX1i-z1JNlkmbRemgBLKIs$GkcKE6BMXN5QKHyVm^)CK1Ez!my zT+sS&+siepRoe6YvYltC^EC^=zbQ+lqrVD#;558A<}PVHh#df*9#0WI z>Kry=&iRMZ%X0=@-TZ(1wsCmf6CSBH$cP5P%E+345+p>MSR_6}bAtiuffh6SZRor+ z0NEw#TdBxIV~{npLhu;_)PPGWlmlDf~-b^zPq31w>KW3Zq%cy?ba|S)fY; zaMZqoRzSnrfMZ9AJ+&Hd{-Ep(f?)7j!l|dOnEw zmGK!sTJC%kY9{G7C$5w!+$^fcw& zz1tqkb2z@+eA|e4|4x=O?{R)v%yTv(iaim!2FuO5?~x|$c<0k<%@Lr{APB7%z4l*e zHobKfGI^jC=678jMneNaXt8z6&8wAf_Bx6(SKAKTkh(EYdsriK(jFL^Tdw$xRnQ?k za#VPdrRsEXXiHk|7}7=uMt2iNMDu$xeo!^=X2>uPYT{|f9tBFzCvcE9qoJZWE`wiRRMOUNYl48!p!+9#j^oNlO`>f*_iyIv&)%IL1@u>+6O|o1Qg1xQW zv%hj4?R^~Kj!-&5j>62~)pqh$TCMQTYLFO|R7OW?vWR2Or91$Wq|Y|o(i?Q2YQ=1~ z=ra7$n7Gl`W3x?*>&KtnX|DZ(R9>s#LNo`!vq6q%lyC*&O)I6SQI^vY@J)80I zPC$Kn322qk^S`UyrRvg=bN#(r`PrJD+M6SufrNO*reIX|ji1k-Z=Lp-e7>`^edrw) z_OSj=Q=Tj3LBk5MyZt+Cx@~`N=Xm~Sh2n+x=G?FUD_GtAyyjQ)V^2(mI1!Pj)!x#r zQ++k#xpvr-c4(T^U<|vv2|cHhQuV`PG(Kme1mAs-E01JcO%o{^Pwok--jv%U$>eoB za);o1jI_Ryn5S&Nrx8?ORgW_bh7hAh+`-o?rqdzpLkpP>d{qG5N)A>lFBC;VA!GB!$^p;93*65OE) za5q!;TY-d|ncXtIfY!fSxG}n*7?z7;KH2GmJ&l4X40&IM zIU-)o4=QSCB-_y6Obk36WcRcStkIO9hY%{u@6Js<8y`=Y2%mC3{pl#^tq~({edPJC z*ppP30~ve$y`6Uq_{h}a-F47Vo`WY-1zQ^_V*>9(Pz*wcw&%s&Mn+1UM7x5cTT!!) zulT5OpC9U*WrnQDXa;~;{CFbBT|JN24n~i(xm~5`OwEA&%wuVZZ`Y~Qf<}!}W;kwz z&dfKcgXJ+tQMHq~rJgI-Y^9oW&=l%4w}*v=D_5u7T{qgw0scC7ss4qHhNvb17OQQdIm-9}0M|CkC z^6~q9?_Zgh-y@EZB%ZcbpJec4Ea^23OmpYuB_*hC=-nYgm^719qlRnyX`owX)OzT_ zs;rn%nO?c|(E;~<;j7h(L!SXDEYiw#`A7-l zFa1?`(wVx&LDc=$Mv&T}+4MEN;Xk3%%_WsBjR{qEVDdTwjk`od1GoI_cleT8u9z=e z;UVN-jgq_-fM&v*tAoIE>!T%B!>LhK@}Y!9!(J>dJn!QznIErliEgRVL)8jZ#@J^~ zrSIqP%39p{F7>#yld>DuHsJ&<00f~pDH z+Hpi7;_rBNF7Z2q*`|aK=g@Oa&&aIrUs6U_rNE_*`L8LXW96O(={v`)@67SmLR=~H z$a%w2tQ3SXR_=`J$pDnfN-JDGqv__8GmN6&#(C-4gM`*zRNkSvjo1r?e+XZ+PoV!G zo{{Q<>42b`2ksyHi?-?!m}}m-s{04A9dV!};x2z<3Z_tSM^&j_L%R~`+vAZ@5MBY~ zo{Je~0a$}HFHYY!$TGn$`cW7(DSmXF$n$5t`vC_ZBq=Y(&XC}CiI>(XM{7DsKp-QX zKlay`G~}P0r}oKx3t{_12suLTH2+LMhLD2RS8!B;CArz&V?t>k1q1!V%}Id#xA`-a7Agh zsy)z5qjYvs*@1{dD?H8OF*sU#^PXkM0j|AKKnG1b_Th-38;EVB8`D8cex&RQ+&GG2 zUJsW99rOWbgWAU0Y=is~#u@ntY1^vxcMXQD1ynsRn8eZo6FuvQ6vmgTvF;5BLMBh?YFJabnz@lp zs7$J7PvKjq3yjBRaHn)J^hQTC%*{!7XP~*|>D=x`QAkK?5I%WfdyBXPw+_DzJbmjh z_qnJo36e@l_5_#cG-URo%vz=o^Xxn}o1IzBqz)_n6W4`bfS-*YZ(}@iEMg3w4WnDH zB{Taps`io=$~w-xWPWb$TW-{VISl# zKotvUnYRO~eN3uve?;(;`A>cj7(Y>o6}mf1e!ta?N!0xZO4?38fqX=LG3&DjNw})% ztnML}-%4LUrq}7tXaPmq@@Qzat#9$}RDTJyLS0&i1P4nv{5L0ye6D*w!++*Fo$_Dk zw!GKKAhPe}@U3*sL&32ZL~b&WjKb$D$vSY|^GDuJN|#{b=KGPgMwY8r9~kTz7E=di z-jX=OL4~47Kb_(q;2*Hi?~duuRW$gRh{)JdtMw$}x|x^fQQHn_EpmzU8OP96-Wgr; zZ1v4z+&B7e=qv@RBi8|*f3vpq`8_Lax~%v$L#^sj=Q+dx0vqQ&_*PEx*QHekoYx4& zS5Bp}yY4U4wpDA?XPHbxlS8+2*IjGRM0v-%sa8vr_(^*Zh^oZcb;6-Erp@b`SYBIM zi2l&9`vv|b!{zv-s=%!nLk!I#HYJOe3j7m^T`2iln-yFj;0rQ38akih$g-uWwUORD zZDi~b=1>z7nx|zHl-{f&Z4i^{mS*}A(+f#35-rA|#KS))K0e)i?+z;Gzzba{ z6-|YLbeP`Wzs4WToO@(XMsz0KwYd8~0puYy5n|bz`EH(g&lxk~lb>)y5=yeok;72^ zHO66_8_f3Rt@r%&xDWmFayeJEi+xJ2r6EF0+@k;ksY^Y9}%*_s( zxTtKfchiO6VIZW`8-t2LQT5q49kD_LV+!o&T-@AijkxCBfxQ z-+!Ml@)kQchmiX;EgN{8Sg=Em2IPG0yG)IjF9Tw1&QEif$&?KlekdV-`hTr4A!~`?YYCS_Nrb2eVObEJmXxgY@W7CIaewNjZoSehC zwIWjI^-uZz-pQ(uDETwJMzEIJv&v0W*b|WvLvw_3qgjc5?!jk9fNiirp5(4NNn{F@ zpC7F%{Zc4ld?+CmTTmYHpi2Ueus}X~>bR_O7&TOfgR+*6CJ&_=>q@eWFf3$GHSFPdy&x^@RJ-!qthKc z&TCVF*_dSQ*`b+L+RAIt^P6_PB(%|xK+ya z?`t#{m0$C-Ps?7#aAPTO7MW%bT@8|&qOfsAbfx?cDUAMNO3>B3i05$5Dwk0gX$lBU z914i7U0AQkxU}ZjuPiT{{;qGsx4mY~N`h0_lQPP;@6s-he-ILXY*y_3)<^I4h`dYQr1|Nvr}UCk@B8TS z*YAuh_uzI+wT=9@;R+)EXr>SLhFM;!`+Oo4PwdsdD0rZ*I{Zn&)2Gc=%l$B9ee@X& zPaiN_)K`goYipytMg&Ulu2o`z=L}7T5#mWSp%OpKvW3~S!5axSLU21~&i)uSwBwe} zmdlerbn{ee86}BVM;q);8KaTbRFBAKqIe*F<&OY}(-T6z*%>nhs$Y&<(If5GdZ@h7 zpxnU|5D6R8cjkpAC+7R9oK3vjeLnobFlP7xrw$SlIZb`YFw(474t;3>!AE#4p9pr5 zGbqg$EcRraNl-5&c;|r+Kcet(r|c%ltrVWmt5kP>NmHapFkd!-UR3-hoU6tIVEvvg zDb*g!vRhFNBD9d2PW9YZe@K4jI5t^OO!R7P)POPHb#?9>u1^Y&5dphpisdS0&3EDl z$?i~B+E|tGFdfsHVPR#(bM>z|royPWcq`DwF=v&1e&fcwS9riAa7A~&n!nbEM@KWU zwhw5uQYV!EGAL$-a=c>))s;Jm5ER%xv#K9{UU4(<(BC&1s`oalP#EPhLJ&vYI?VlF zjh6#3&uD{%bQ@Y$^Zk6YMeAo#eo2^t9hkM`M483=D4|&)}?6d ze2tGs@C+YQ_E5*H*G`%LAhm!igQqwG>D^qOoTf6z6~s8XJbZ{&*LNBWB`l94S$Y`N z2Wr0<5KbRJ{RwT>((n_PyJg()3d^c8B6bXsyQER`=KbE~ z{9%nP{uJo2P5YRqYZ1A{p|Nw-J0e8Mt4| z0kjq{@G&BI5d!>*iM)jP=jLy}nXU~lKOg{#X)l8tR&GcIiaK|EIL^k_Z&n#@-^2qx z{}K=kjrrCVerQ6}9^5P@0lB^#7=7eOZ&UIcMYvE?=l0VL(99Wr3Y>g%`d&xKU-#&E#0%RrDeK0AFUmq4}$&Cpf=vwp|6kdGo>xW!u)F!)4Dt zo@5*^tmEm-hb^X5xn`B|MnPMFIV>eeVx2ZVZiBl#zA{d`G1VV1Cs;k{u3_JT(qYH# zps%+{K+?v+uEa;5vt@i=@H9R64q9Cxg3&+LEK@7pNTm0+Zkpy(vy+|O@Wr*6XQFV> ze4RwHu}j}e(MSy4`jEvdrWVW<&d0L1P_EJ){0NrQmZ_8o9r1d=46dz@r)MHvQ9~*K zZK5F`CZlFnHL1>mf{eEDBF9M!d9(vTeKvrO6nWHe*|{O1rI#gOk88a*R~-KS`9|oD zJ*N;!kJ1H~1C6HD02gS14`Q_4!pI|h=!_preuT;K(xDtgtrjBst)w(0hMd?mtum7X zH81y&rVY|@yG(~QO;1PI4t1H`5+*pwkr$PTz%<`>HsemTm0{!SS^s$)(Rr=Cs$39R zeLaAhU87GN$270G5s~`WR@!Wo2n=sgtA z0}0y1EX*1ro~yo34Ef%>Aajq#6kdu8Jwr%?%|;$MaC68H{)&MDcS16-vxF3x3t`AG znU>&69Y&dDwq@vTVjLpkOy9nJWgRhPTDgF}HQ-+RXi^LOUkXjGf)VUO`MESx5gb)c zlH$Vl$$UV6@)a*+d#NRPH1#H{9Io0$m{CafeRXb4#m9-VNb_$;j~=x$@&bdv(_~V6 z2V{dGT$7b_`IPD^WPi;3N5H(Mg)vC*NFJ25MTtn3wvcf!miyUr4_JkuT+MR<7;Fc#pTtwC*(@eB$JTa1 zpRIGIDIz@qqT+DteRkge#a4iyJ1h`rp8j6B0N=4gEUMb{^PHS*ylz4f-w&I!)mFIT z4d=7yD$IZW$b|v!J1nTcd}XV;62E7&LLa8l0cb*4--U{Yl@=FxQVXeg64(##o&jPZ zg@g)c>(3Af@0Y0uaAx(N)|ZcKZkb=K|1O1UeDa57Gm^GTjny6{}Ui!xy z-u*X5HUA7i{WpHR-jNtTxDe4GgrZ$21)y92%QCz&NpLp{3R*+lYZ;hm2NLL#nHm^_ z@WOF)xP}oK^258ub6vIniqrQ!QVP)$5PqF|yIc|FkWP-UTt?jvk2pJr-C)&O1Wx;; zp%F5NYAbvSHq!%+x0@)JGnN`d9Bd~#sPO1SNLC!Bxw1>M1#WO+qkwiy$wQN#(-~Bo zes9yJP4$snG~auutfudrBt;rZLyfM1D`*LqxV+Fdif7^<!Bn=7Z6FITSJgfq1$=KFW@e{qz8!L!bLn5$_ngl<(P z=3)~CMnI8=M?}c)ktDG@`ww-13o|qnFTv32GA`kHT_gJ*!CON^*%%>gQGQX}gB)Oz zB&4KCG#OJejto|9^Sb|ArN=ksoLkjiUUrRyIX4r)2=U`j58({=3Ls7od=#MSqR$S7UQhq zGc!jqaTNH)7hiNO&T9)AkWt*X>}jmJADlmqVIykm6gg|0vn!Yc?SugNf@+NGidkF| zAun@pt@lv{+Z3FdSxxOYL+Rn>m4P-bmxC-9vN6}*${$p9WY+xF$m(`db=jMa_!Mji z=@!xQ{r7*`i!240BHWcn1^%tCZnH?J=#z2E^0 z&r?0i!~x83*j22Vb*06!fuNdEvUphYgx>*Q?M{KEWRK+ z_tvhnNy+n37KXm?2Z2c$=hScfYQF6^OO^x%dq8W@a|{CNB7V20F6u4(PY&N`?>oP2r{K7Hc;u`Hpm>?FAmzI)XVEw1PYim`dWM(RvFo*v z_~S(&-8PR;psnp$v-_%p{l>Ki!`H4@k=OOv`|_rAq*6uhvP#UeqjhS6=JwuLk|OEX zvaCVzf}tN*{nawK2lXro!R*I1rgSd;uGI#=PlpeT3zF{f*u!&n_yWBMQL>|b)Y4cl zT>p*q->dUyzo)&>Tsx_R`B<)Y*&xQIV8n;jzug#nvK7i()YPwePVu%x|Jj@9%KA%1 zA_pQgI$AWUc^BFy>*qcZxg~Tofs%k6E6$H*WT5Yuz(wzWS2y2wI*rh*V*hRVH=aF8 zD=DA*>#t+lH=em+`}SKSZ{3)%ColU3R9M5*$cg#${A-qG5 z6?&Zb*3{N^DB*7L)VrNUHxYFXF8Ut4g2qXc55QOQ4|Go1N$r&U^%WT*4jeczaNHK=FJwPzG|?rW zbgNOdLAj#nzrX%^G6ktTMNkiGVTdW1_Bu-x%+r58BsM;4mDh9o9uMgOh?873yn z?BbI(#me#VjfXAd9G=f*x5Sfk!2ivCzRu?MBCLvgn>EF(RV zJ0gSEE)05&M7Up}k<<<1F%Xi)d#@+X4(-|_9Kk(&o8DWP3f0HjyX%N3lYxTdqowLZ zgMdtUz*Sr%KkZ%;WGOMzM^k1UBay3l+JW6Pi7p#b zDE|qx<`IuuvK6P%DML^(aM^@H=4RAo!bma>j2dKP@<*-EzRy1TDBYsGj`=!oajQ*D za`3eVmy0;yf{4Z;O$n2B<20o*uQC`_jJ#$`ib`H=lsgIJwrfztztl#59@Vle@Mw_s z+84452UYZ`Tl0@@MkWDFx3x0r|KJ<31ak|J9JCPv zMNdLRhoa&gVrmDj-eZS69rR~e%~$g~ctfL$>o+Aqk+pdKpSzAYB7Tc(RlD@p44;*+ z({yH4ZEZldBi9hYP-uf}DU^mSwq=f#dlf=CseQ;p!!F{9V@w2a+jF%lV}!{i{eiG# z>2;7@l$7TqROlqPv;=*RFJqq9>q82;Q!EltSpmm|7E@qgOe?2Az2ocAjI~KpKqGsb zGkbOu#^uDoff$a1;x;VTh_qdDR2dyB+d!r9F(>JNZ7|%^jAfrxa2fHf+!g zm=%S4nRiGo!+4-W=iZ8%crM;;11_&t)aPwn+85(gl{O!fV{xY_V&jv&>RAmo9RrD& zb0ceZhN|$2T~}%3=d+T3bZuSFs;v4}LAscN^pspR%8K)PrzVc(uERyJD`DNQ8!C&K z15|i~#zFlX(7qZrQ5eQVL_1#Gs&U_!VYr4`RM1Z^04?xiX0vM8ZhR7&fIAoy>0$Ff zEKpTFnX0;h5j&ZOkYNR#ZcTmZ03t2IolaFvZ3o^r8wd26(Ux-hi(5}4G{7{w*2bDu z-=dVR`Nt=pbiGWOtV+A;^@zRNg^)M>{2>y$S!3GT7`S@JDXB|eP!h;}1<6f|Uk`(a zgV%YkTb(+JiHWot7J6!5?Q%u)1m$AFzkd`hlqP-vIGCOtVb;g42yW53>z@Ct2KFfP z`9i7J;qU1Wf91DSj#|mM(QNlfz!+v?mw94~ncQnDqh{>ftD-ybNXzUnQ$FBli5Avg(N3&Y;r z5uPT6O4P&a*ngq9v~pv|P=^!U%ATTtDfbeSqCaGaONLVn1Za*(WDh<#f?Mca<>3t1 z8os6)o$|jd3bQfv$(3C%f)5^MAFLRKq+sX7j+k}0wEvIx&O55gb4%k#4I!fmBsZuS z3nm^TMuRQ3fF&j>$BK#_Y@i@WQBXld@ET*Tv7S%_6w!dFC`5V{5-*~Fh(`K8Z_yszq%OJhtUqDkOg02>)WB;sVsbFD)Ng*e*Kw+h8XlO_?4WkWJtSviuCdg)f zuPY<Psp-8x=$?hND4o92l$c}jx<{!oD`h=gWIrqV%avmLJT-)w>Ds9a~i$< z;@^Q>+U3iL((i{w}{>5Yi!TM)qO{{V{VUOoSb5YKMp+CsXW(HWC6;x;Pmob3qWuF-E);WJt7hp zaRsz0tB2ZMy8Nhw33=+kpf`Q0;`ev~f9Io$Pi?y~t0V8D)#lv2MH*xO3dw-;=iglhN{wY{N`z`1XSW((7rwa>FV;~S4Yvm!$ z)TXViuh`r?rI|0ze9?Aszn()vY4!Qrkb4I^Nq!^X8v=?G7>TLK!)Ru$Me?`VtP-S8 zS`;XQj!U15$0unDJ=O*~wYWWZFN4%nTd{IWV|jgXR*OwZVngprnfyXP7l9Mx<}*}8 zry#nCSR279vQ$CvNX}4Vn}A&9k;gKGEIG&?PwqCiLxB!5HNoTMGd;nUg`>r9_Nlt{ zpEl7Vd)tP26q%=NnUCP_TuVy_%c~&lilDx9pIgekv4z+EzU z>5q%Ahj2IKL)j#seQ7sZEPmMCfmIrPM!|jVvk1M}mODGUi}@uvoDFtJ!VA2%x-c82 z#LLviTBFY%ZE3sr+;-7hItSj`oNRp}!M4xm-F0R}+&zDPu8-{rpG_VeC!tF zpUZwP+2`}QwF6IBKbk*%L{vaw#qPV44Bq+crN=K?@AxI`8`0_Hj*pD=DznGd7oI;_ zm-}Qy>FA@b9$zs3rDM!{kZmt$PdG!ycbdhBgMA2||2vJEzoo;CmN>uPexu`%25x0Z zW({sQkn&Fa55d19Dn}uMGc_$Zk7CrfT$&8+HlAA^9NTsH5hwX%Hs@?GUlHTOE3$|% zM9VQRw+u#_jFiVOP;3JRK@D9N$LS=RCOTDlazFH^N;++RTcQ8`@x=2bxM>Q#sdcPf z{ex>LJZ1*EBft$I3D2~Nd4vPE35+VG`K|OmRQXc!zhZI5Ha+=!6ur|b>8diH%#4?x zc)q9R?lE&S75eRUJ=p#uL9E#vkl?=iG@Ks;BaA|R5OaE;&eDQ z8x7lUUI@*cn)4yw!!#2*Akfc&c}tgWYh)paJVA;yN*t~gO$`&~F`~0fmg=uU51w*) zL2s)C4xY{cpY3P)2~Cs_TRfdP}$%L1H2egA2dGsn$b7+~HsxC$uPM{hAq&57GoJ;_G=WLcQGYB@km^209Kp}+Sr%yMu3@{{- z5cq_?*GM!(GObi&+tKg>=`LM_!SVFrq^@t7+^=v>Nr@f*@dQMNdJqkGnVJA2OBO{WJz zB;jNXJ#%KT_^fGsG$hq335TEd*K3wF?n0DTcMhw=A4Z>XvsRZgmh~jYmTPs zpe4($*0hNy&{K7SgFvgC9!=zO3z$8PPm7DqWU5{B$RTk^Mefzqi1X(ERkMXgN#e=vchDikdF3VY5t8|84KyD{(d6EQXov$i2!D z5S7AewH1%|+>LHbc#8T&S0xU)233PhPp(k~JqlLQ6g49neoRSbTX74JV6$AE ztMacH4@WQ>?OQnBi*8Qo{fdgj>bMoZbbQ8;5g~jQ28V_QKrsmbK)eY|QD{7zyLEJ{ z8&&Y3V_eEqw(SVI$O~~EF6)uLw#F%hbCT;bb0=#H52fE_{Iw3jr1B$)_ec8|MgMUg zLeYMg>)BeXOX13X*sWW|<33m|2EZk`W)|;wEY0aHg;~nofs^A`y!8p9tnU{5n0zDjdeLK+s(zh8%Tq$ zOZk@y&%X}RvMu$N^pQ|5lS+wK8w)=jJ$m8wkPCAbGB75oHgP)Gl+bK|gg<45Gu+b9 zh~nAMP9&$2E-tR1;$Vb1YGTuEw+6^mR=V-f{6V=%1=K zL+elRvP6p^lpS>RjK98HzlG7`)pil}`#oCjovvM)=yk!7tEumg+I6SF80s7}0I?5~ zQ2^vW&z_G|C>BPH33rdZFt@q>;l0M7-+;p10yz1`$|UaDq%q#k1LMN4knel}dzG`r zSWZdkDk!c7O3x9VjA&zUGZE*3t}fvUPuqFD3gTLB=8sazy=9GJO{#-wNXFgMxnF1x zxi&K=Cm%E~!YO~^lY3540~CrtnY{q9LuML_Yzfry42W`QYW}XBJ0C(=_>Jf!awVrGSVpxxbPhTK zS)68f2-U~~j5wpVmf#E(k1b073QLLP4e^CjfV(!tr8#CxP#7EWbVS4$G|Rx6e^6X2~D0?d?(kQ zE;&4)W5VhpF5y2R$Gr(o)y4bVSy@I|%x17Wx&z)eAg@mM?wc>1pX7p#gKERA%bUju zAP)uLGl(NXICt+pPEnRW=Wzac!qmY2{U@WZYm9iDw4uO!^IC)ojWJKA!FEyKk6)VG zEm$8OYS#GJ4Vx_(p%FIbtb;}#-2_q0b7(ntj+fos)>`KQ;Vy!E`?4YBmQ@lFS;m&F zU+nAcy*eUF<4y;&Nz-~LCX2&}upcCaU?nE9^H;|#>3s|5^$=^O!0w-$TET-|h0*EfRR(R8(V*blKVf2-FA zj+!QxB4iRrDl!kbH)P>A1An`^2C-*FBU}8qNgWhRQGUMZ+c8CDhZ$m$utuJZXZ4v|Z2$ z%tP=k8270n$gyiWX$H!rxVH7KX`UTiWBCYSqPWICyivzU$zaOFOdkT z<&6Ha{!XD*{5j)+oq~*$;625_2^Z~(o_qa4h8p+klZc-6q}Wfw0>XAbiKEfC(gnZ7 zlN>%Lu(C4YL@I!$(f}MT-m-)aEjv{5Vge{`a%2m0@a_;P6j{4WKoH8b43UC(i#9fB zV$+Yv@I=Idjf;rlF-AKnV<}1cSZt}n;FOn}{N44Ct2a>o>nXTCi)deNtEUP?lON$C^tcO6m5O&6JaTnQqF<19gTHBb9fV_<=9eN z0GbH>a0i-WS{{EVd5dUwR*`2OJl*gXZ`|4elY<^ocu@<_C;1glJUQxF#+6Ei25)BV z)wA{&qIx^-=%LW>sPs#Ise+Ff@GtMa`-M6ig4$KUKLj-%nV$IwRGm?D%NWaO>(H}jPuup? zz}JG^>Ia8BfW9D1@YVM!E3Kya3|@;Q+4kbT-nQ_WN^<(aWqdh4Vaw!iz8Mp}fA{Xp zsFbkr3eTRQ@n_t9t7yU=w1it4=&&?^PwB@t_eb%di(uu$K7H(2ENjTV%Oc(F?Zf@R zN;n*12vWmH%03-DINSNrjmu}2#GFnm&`_8K+>Jgj)1*qR!T}N!s*`{gU;$gu2AV;R zFcag#8I-SCv4LA-qpl=y@@v>=>rCxt5&m3DOQF+G4EA_QGK{?}*Jy=8@xfnI-+X0C zEmC(v&$E+a;z|qDpgNP!I4JD9-se0xBffW$OU{yA>*!rlDAGIH>M4TsSGjj`3|q0w z&~sHKMAW>V4#~$jO9Xu+Srk_<9bH|QsL;0+6OXO<gA{F0DFuk_bRwxcWW+J7+6pJb3!5Io8%E*~unl+lY4u_-~Hw z&g(aMXv-)+>HiUsOR7bB)>rSfGtw95C%fN zi=OCy{zXMk5$S8SI!KLF1xYu#eB1K&OV19RAs?^I;ngQD`xu1k2HR+$#hyM}AAco| zD`+uByDb?#U%({>6RUhTz3l$&S#t_>#=lff3MlgC#e~w*KTRkfUG2|J>MwcqybCVt z{v_uS_=q}K{(`#)zRn4kMA<_5!A?1t9d9N2ORc1>c}2(4Otpb)TA44b1t z>wooJ$n@>i3zxgk7g$w{jVmid#S#t?gLvMUHwvCU&Z?CiC-Y)#=%EVFyQQV2^VS1Z zpjT41V(76|TiJ@EEShHqG)g!BAxFBHF?``zHc?VY@d?BGL)=JU%~_Ld*=Hm@%`N1l zkvY1;&`eHAks;@9Mafz-OHw^jm$}u96!{W3pk(^cFtDNOEfhCO<_(6sNCcYe@^pVf zXHf!~5JL)eiFTLMf_fuahF`Ov72vERRv!5u7MVCXJ ze{OKMAB4G%ldfU3>*HTEW#9o6?4r%~Ns+`X(f!=MecS$-Pbx{vqugUVM7MYNa4&}I zTI13x)_zj3^CL;sakd2pg2!AndbUS;+0v(8l#6m!@-mHljitQGn5&d`pr3^P!oAA;2XU;9p*URu{UX0*$F?j#SJ?n`(2yrEh z(|8c`u*DmW)L@&#k4Nn6JzAdZf(rT|@(Nu4)1*FQq8Y?vpEQ%y@izjUm>!e6>hp6f z$UG7)G3^0dT#J;$KEi|FC(ScJ5b?~B;R37Itg*qWLBroeUL+}rz$}^B*`^R#B?pnz zj1o`yE`Z9R+1WGVENI$)O_JO*V#K2*qJTVTiMpoB6pzdT%2lI`zkUDxQ1uM#%C<+? z?HNYVe}Whb9D%T5o;zI|cP(PqtcJyl7oVWuoTBE$*_|Q7B0YQV?=4{`ZRAasAF0hb zJ43IMwRmr!lr~UF3N_Ci9)(b|a0{cabh%~>1w!(;luP9zGU1!5>!8s#L#}3KUZ-;G zFM5~FhPC8`{Z-PC#L%fW@(LIYyZgbWJuNP-u7%G+1}K$6H92-fJr^Wj| z(9yXco0Cy_{ii}2Z4s{f_^|OWZnh^;W;?(%(19-jSyTrP2y~ewSYJ^il*dM|&wN9@ z6Iy;YUAjbfc7jpLG|s6#!(N9mpo60c(A*Uf~I zagWnFi4hA~Vz8Kk<6yuVJS;9`gzdE??2U~Vb@yLwqiBiMEYfqU9wy=~X+elJ>4fBZ z9Q!Xl`<uR~gl#DvWc^j5siG`@7~4vl!xEq#3joQ0#Lt-)W6efa3@|nt zPj(7HIc2<|_;1Tta?Mw3=cX513v5e%tZa2y*erv}@!dmjmJvAn_8PAJrOV?WUMdAs zXAy0$4Smju)p=u1Z1QtPl}eT(K7*l(Z7Z)zlIfw{o~?OSnE)rb-Zu0RnQA@Q{sY$ELThX5 zW9F&U>+LWLXk22hICFSbO?~xg4?rrRIc+8mWc^i~Nr#d7-pyr-amL4K%W^NsSty#y zrJ@$+CXQpDBU%nLCngIP_=ry+sq~i(LQfUTeV)K0qJXHFS<^DU4KxwG$}H0Le4eaX zZQzi>vF5e0wp!G<>y?Z1MxuCw_hx*GG;bwNgB2 zFf*Dzj4AAo$rvjWvx0V%4o^JB@4#VPF$dOZkov}HS5`4ba`sh4zm{J zXzBSBrPx4;MP2V(NDwn#I&Iq(vP_^-4f9G-^+GrgZoEz40$VY0g!CIVBAbL z5rZ?Bvm6j*pF6#8zz2Pqv1*K~l&0|_Tapw;*xGn5cpQ7%R!)cFF|SHj`@UqP^cyC& zdyc)oPJU+h`|VFD?LBosKp56aqB@nz0Dn5ys8Av=4tHDa8|5#a#|`LPOJ+y5?c6>` zh=dMvxxxUWcC+rlS9?j{Qs8tBFj^2`*`EujL^79H_?yJIvX#`^e3d_*ng{-rI=?P@ lUw!|-t)~9pdim!be{l%Q44QXwj(h^u-rkH?eMFU|`rP zFLy?bfnj|o1H-yMe%yfnQ+#6jFZ@f)9Bk}eY%H(*>SpTX zY-w*NbmZ94BPaNNwQzB9a268~u>J2(9IKM(y_}Pn)7|U5GztP2>GwWyw>$@vL4> zQI1xwW_p`dYOZY4pPE-14Y}ve*R`G=T$&Fsde`FEeeh)8nWt6DZZ#8?vt=1$KBZNj zai3f>ri=8qR2=;Q&+z@%q(XQt`@jFeu)6+-PCUo=Uk+>6PX7CY6KmGE|NHxg*RF~G z`+Mb6FZTZX`-8vsGXC@XYukTz*!a)yU;OlA!McBb-}}S=zd!zk@r&25Uk?toJ~xh% zOp|3D5_V2EENvhBwsHM>)469W&URfziBHbn(Ty3pwf&&k+_QUYg7%7=E$XlP-1BMJ zT58|E(=T7X)N(CbU0G6OKE@y+M&6y>OFcb-OBS_lA0Epr zZyuo~30Zw*5PbPAMtrt>by=k;Ra?8e#B-ppZ=bun`@+|+Pd&bTOwr5F@R}V>eEZ;_ z^;mQI?cm`0@qL^-?dX%o%$rtuakA= z#)hqG4i3*YFtMlo_19mu?9pKf30!za`3DD8^4gk9Je}*Jgk;&-*`tmMG6b*9X8QW7 zq9Ud&&Tn;D+sJnz@%!fw3=W1{72|KD7!HHo!!nkc*|Zf;p~8$s|9ve8KUU@!P3ojl;ixX^V8GnL+@hLZL_Z~IOW>+NErxm^nd&) zeEHQ6WDT7MYcJf~v~$w4w!rXb^o zX4T@PeE3ZJtAe%5eU~*Jow}~b#=;=+@ar9RhR<(CTc5`}eR{J`zQ}DN+HJBkIY!*Q zy^(Uv*gsmtnmRYpAw9fL_ZHTnBhOaEzFUG~yI0KRePgov!06~=@5VU}t!I}`7q3Ye z9=4!afBASvAm!4_->J5-SEuC78JRpR@Nw@3^-fH*=RPPdF76V=Hs+I0##Xf1)FA$> zno_upjErJVI-j#{PWym}OCM#E_SN6YD*V33Z#BKQ_tFsCk8FcuW2u?tD`MFJ*JT^= z^-4D;&feZ}A&gh^)6h^7K5b;YExWzcJ6}0QEbOQFzm_d}%1Re!$C40T^7+zydxgyI zp1aF@|1IabYXM9oDmkrNpIsKc!{xiWJU`l=o2t}hU%o7=zHZXd(b4L|lbgE)3~jO} za$5{(*sDxFoi{UsHv9JNb6Y2us+}piwP1d)H2eeXdp0dA&TF%P*CCw@uMh zq}xLAvr}=ti^(I_3rH)vITrU#W7s9WO%2s&;;>ncG$e*+krVgzb6>JA^Ja!%&Xuf< z4BwJUzEtj^zHHdKNA#joq5D{K-GTgxDh@xJ{Q81|6F9LKo7`PpT|L}LU^V4fs?#nl zQS8f-Iefpq{Kcl+vETpOw{JFct{?yUsd%|Q@>s>7$7o9?{e3IfNPds6dWHYiFlj$u zPY(~0k7C4J8}e*B*sS70Llbne&3Ggv^b^mAW$7}1i87DDmgXjM&FWa?lY2G?-M({&rfuYt zh}e6JOc)y*%d3?Z=`}O_7%8RQHbU2K#<(hIB*wk_!rKt;fr$xz4h{~I`eXIo!Kky*7*DS%_hv} zQhZvA{cqj6wK&&dzmt_U1_rE-h#HSg5E|8CYAxJ_cv4gHuzPeIu=rzI} z#-n~tN=nMf*;)PF!;?GN*wPRv$=FWTV^{tVwQ0Q+mFq3=>eZ|9BUz<(U1F}o?@wR9 zetl|YMgtXT7Fjdtu>Ar~IQBt6Gecj;b9yjWqD2A0mSIq=8yh#5;AU%VY&^R#6gP(G zeEw~Pq$lbU+jx6!4b|qwwKZ<^$B!QUIy?M921oJ2on8D5ivNusL`=ciw4VpwIst&1y zR?TUao@ORkSUk7a%EHj>>)l4f2<+s!`|ZxQ^zPEp=5)$H;b4D%JR)(V!@k^g_+q|& zPsZoZ4mG6_ICmm8t*YhAbCimq5j)%Voac*vii&r4@$0(OFRyvw7rut!g^XQwD33oE zB`#hzIJ%jR<7T-`OH$e6f0-E(FQl)ppO&|iN9`}U^XCO8?6J_IJ|b3)Z&Kdf+b5$q z?>W&f!pX;1>!OFJQJSBhET*?N`p`?~$7AEn>Z02kS10m&(ncdE{P6S2>3V7VBBhYN z(NU|bcpbNSYi9rFI8&S_PPE!_xX(4^+Z%DB+~sg&TeGpUTGd7gReheD%WD(G(bA|I z_){}gD=NsfDMgbp_qcVj_q<)aV}GSvy-YZt&RqZ{F^SmyXKyp#zkmN6&bLk8>}XR> z%JRz_8w1T_JrC4b?|b{>k3Sw=`P$D!b7YhBYRpmcs7jT zr-{z`Z(+GYmg8J=n$ARQ0IP@fRQe})Z zzh0g&AgO774^Y4!ypx;7H>9DXfO+Qa!KK!FcJ4G?WM6r;Ss-DFt)Q^5ZD#wnZTBaA zC*4rA`s#0u&h>5jZG$h=T84}jc(5L$7mwGh~qbjGghz?ZM z)YN<(&#u4w>5~bqY+SNMYT?rZjX3Li$@z!dcJDTyKOw#PZCazgjfB&9SMhO!OwWpf zW$~G=StHMZFpUm|7yW;NI`lq{=)UF+6r?m}gf&-7Lbej^*v+qN(r!c%wY3?27cEkg z5>$H48*!pkvoue)pZ8FS5i^~Z)jDJ*w6ruu`c-XZuf@@iC{jXu zhwicn-R0BCI?*Uwt&(k4rzqWew77C%dg!=>goNUf=f!oCcvs8Vbxcf5{lK$~fd|ds zJv=wrS*WyBDAZf#JfzHt7au9wb>zqq>dTb7n+nROst+>;re1u0MbtECL#OjVwdp66 z+&Z5>{`e!ZEVkCL3V6kFSV{nu#u3MkBE|9g+LC*Zk2$RcNoS&2+T-)1k(G^1?BnlO z41E_&X)SL9_Z&|fjapA-TX>;Tw9KchsF>3>A0=dd7uZ=zPs&27iInz2LX+z_mrej6NG>et!iV$TTZx+ zY7{M%_%0V+K=F5pS*N0+Vhn&sUEX`b;l<-@3=FeF(r{ua!OhgxZ6L4{fHsW*Ez4j`legx?H~wQkb02yVVp)ad1g{l604}qAwNGqR15iHcX~5Oo!4s$h-?mnB!7d^-ac|Hps+`6ES&X|Gtqe7CoN3~g^B zAHz4`7whT4I;{>u7>iuTbi;s5x@f+&hQ>R2HJ<7D0l`rRkndbA{OYBa(tKAI%u};~ zK_|LP^#Bayb0F@r*tebHlu@Y?#q}~ zhu+6q0*-|7>xmka`x;brfx!MlBo@ z(En`V-TUdl9V;tK_LM0Cxv&XEp3~Ik36ZHcdMi{hKhu^m^ zvIL$m16L%)z4=_fAulC^qfQsoM3_Zs&SQbM<R`v0}PSdLyTQZIEQ}V5vcquxgC!IbW{k~Cc#g*ju z%jXyIm)OLDli&WyGKs=aiGAgB{pFWm6xCNk1&q4;zM!_Up!#JiEr&XP9*8iC4l3!i^Mh*5em^frQoM-wGB)lUGQRET`VAX&eJadWzAaGa z2S8HN=DcxYX)a3A-#*`{dmb4mFyMP9I50-HWsnVv+$U`)Z zopTKu36&pOe1q8~ZALvjJy~$xwPyEoa&85^p%fu79EMA}#-@b@1skYArS@mL3LGm? zM{j;8^>*)vXq6lr*BDvn5Mk3Z&BP&PvxD#Ad#WKKJ$*EAuXr<6`T3RCHkBSYe*L!& z#y(3fCP~r@Orr0OK-sgxfXM+#QC{BaH?fk%UCWWn8tJ-CU!is>E_FON4yap>MV2rI zz1Etw>nylj^7Z2#QJ9+dLfJDEb+g}$+7S0 zrUsUd{m2k}7{ckbfY{PYY4OtFpwyG@;6~n*BKM*5_U$>zN-=&b3sqDB*>#gpxpFC0 z({_N)**{6KNqD@^T87>s`tl2}W=iCosc1Md1lXv;TW9mp8#n`P3BNeFyB|NIUvQ~C zPN#d4!|&S%U?poCftWxclQS=tCwp@*cPf`UxJzbdCU@+q2P~qDo~T`W9a%ysUEFKN zf>H!UuM+Hv-}T{Mhu~Ycj@3CYA!gfWc5`sp|FB_0d!v%di>@@IY=%E{s(;9Cd5(7- zneHF{5KpZVai7#r^$Na%FJj{4Zo4Yymef}fKnYrY|5%1`!hT_DfI2~6dGwa=D2~h# zT5m5jA;qN-)L*2P=`5Qe6R21!2<_a_lVjY_5IqnvHu2> z)KQWyW`;jh40o3nlW3t`oj1Gw5oqk-!GjcP@h}*HWgH~1tmHjE|J?iDv$$nwBv#T} zF)lvYC(^OJcJ1Wr+dGAn9zy^XrWBDQ`})pqe%BPObSw3t$!nIIvUjLvmM!ATy<0@n zb6Fa!@#jaBZ#>{u*hOQ?+`!0Yq26Ni>c-{Hl~W6oMJf_s{?Lpm_Dc#ekyxIgS!M`1 zCaqbwp>^iIfRPmC*P_eJl{iF-!SjJ&kV1{Iq>$aV)bV;mR>*_tA9~NBN9u!V~bJ?N>_+6e5l=1}C1q zvx_=lW-01M@3uWD0A!K7u*vu8)sk<^%L5-jUYQm$uG~Ud!AXc1{EE!l2ysA`ap3V~ z(Qa||F9`)gnu@xHe#@@K9U&nhiZs6*yRP;eUjosqk^6FNJ46Gj9vBjKBd=~^&xfcI zwS3S})7J6`@(i^;7#tjxx|u4$SwC>Y$$a$j4rrP=dOh8u*`YjUC^Sknbj5XMD%eNG zd81Sb&&{g#8 zOB0E7A4Vyaf@W{&#R$A*sXmW17_K4o_U+sD9LonvG0?$k9_Og?)GiVlCLt+lTMhBh zk`}52C0o&18re~(w1rl*x*a>2zu&%kfc|9NUEi-#g?8Di)&+a!Erl3zDR6?%7CHB~t# z1prSz>n9U)s2rdG&K@?-12x7@H#k7-17LLs|Uwibp*Bzg=AHq-XOTIr5G-zgW^T{r)`&nCAjnEr;Jf4j;1dIDEd&b+<~lWezfVh+8|yARSelHb^;w+}#UBFdKM^hm!0ADQ2A0IeX1g7KPBLVhjJ z+?8=4V=`81D?{6b-i)u5w|EvYCoCvD1#+i`Xk+N$GZzS>{KCXdPM2j-{?cECO??R*4({E zl3`Y(*;?(iiyv}2ZTwSMvRUFFKJuzl@5)Tjn<}RGNVp+`xz-yy%&aT9YeJ7Q&g|Sa zKP}+{rGb!?t40->M$1A4=X{z07gZ!@L%Xj|D=Ec@ zX+q8s^O|`IE!|Yt51Os$1YO&!Ovx=%t+EfslmYdxwaiz(AV-q0rh_)lyl8Jq;y{Ix$%+Fa`YY+0W_PyPbnG< z1n8mNBjU5@Qfy@DiTGg<95bp=tRq^{QKsWh?v zm3?=KrSmF>xEo*77x}^LQ2ci?4i$}|kTdxJdqSg`C8bnrk})(gMkPD5TiodgM=0on zC31z9Db8r_Qqk6*e!768ZIjU@Q2y-+X*fn_^#P}c+wbg3hU7%$(CX&T9dicOqGX9@ zsvx!6zVpU{DbYk*``-jSv@8w6C)uiNGYN4i0iUB&66Oz4b&rROdD zykgi^d|bew$YhaCx$yXeWQ(}#sEL@+im$}*d>hJ0AdApB?6WSQLsMRH+#PIX6L!H^ zQwxwd?9hc*eand@;S({mQt$Z`ybj}h1Y&WbBfma{FL$0V+m^+Xo+NR2az%9>b%0vF zy>-d$f^MzZB2=fD*u}NiR(T0zt1^Tdn!a`tG#tQ8)Gspe_@kI72v^-Amt?SY6QPb# z(mc6xmR%P3PpdUI%?Ar#5hetR#{$wN(t8`+w5v}adys*erzLf z%>!-LREa_e???mZo$nH<5hAdS)UV$o^Rdjv)GRbdX}!i~?SQ{Q?2=Z~J692etv`%& zCI5DFlh*2S@i?>7LFgl%lsJ&B6Esix{i8ByZzGl@y*kgXD+RCEYD-JkJHD0e#QT(S z0KP>i>o(Q&#&Q7u-hT9#M&4iK+`r!i0Gaae6^Mb5(!A5qtmj;txovDBd8Tf^RiA*l zi8S*lolA4s^-|eyXMJXdF9h6}U~vuJ!J~F&&6+jgovl2(j_5yyyxGxs+x=3)GbW1}78+_ot3p=HF|TK*NeSLYrGOY8kC@O2TSZR_j~1rn zlif4l;56j5jtAWuws&nz48fb#su>vAy|JbmNU`bFld&v1MJ^*ti=2eY6Xk1U|FvxM zdM$#Xrd}rvH>F0@ag4hM(+#DzL`wM-)$y$WyFDt*c3lRA)hu?i zO%=>$`-Vu$*(8{0P^^VR?c||ocKT}e&8f+zuBu-XOWzxT1BRlnL74*R8GE22^_;Kh z;Ya8TUP}}CvlUFztvNhs!H-;_n31OY%JP!ldS>G*S7tz}IvTfkRd48Z3Gxq!T7`!=kJJ3TIPVmYD5NTLb>I1oqGohkb*kcr0>^%v z*n>RpVkJqFKG}D9adC#GlAZ_YwVS$vD$ks$|-=&IswI&N=oPaG=R@#nTe>yW`F2yLa#jnJw_ zD{AmwsYo1JXbXP)NK`>$3?MCU)Y_d;j3F>vp!{fYxRs&v&lr461PnT_a9(=h({?=K zc?if2(0+2gX02%UYg>)of}z=K6CDvLlfUPwSAXDfMfE$0X73-Jjuy3zZkjEIl5f@c z^fB4vLxzx; zS0GA0LagYdCmA#Qqw|$a;t~&Wq3r5HXk_G5$p6+oWj-Vr2izmE!aB3_m3!=mQ!~pN zux07h=CzTJ0mWq=KYq-6@!2DYL5~3wtk6ZRjuJ|$4BBfgLInr59;}Vh^11ru^=@65 z3{tc+GeCj(jmkP*92@t^_;G#h>OsvX<5^?m-> z=Pu|i;L&$;_oQ_#!{;~?1^`Wppy};>ZwH4^P?bAm)zm_^p%qia0hyp5id=FY2O86s zdP0c)qga2XvEyju64g(Mf)I#qjxfmqhN$ZovNorC&{tTbeM>CkfK`v9{S;jNrNw;Z3yL!-dO=JX&VN6!@k&U*XucloF!47GP3mJMzhAA+oSbYdEr?HrORJ-Hs+-a6yn z`(h0ziX!9ueJENKDJNU zkFIMPz+OV@(Oc8&D0`lTfx$(*JV|HM+L5{1nBv{Pm2kj!Mnk$#bdCi1iG!^ms_x@u zl5Z&5bB5+U^|6xTO%H2zvP?dh$N5m9zDL>lEeu5DIt`qsg|f^Q6cweQ*o?3rR@2V2 z(Xs6=(W#f1zAH1kZtYqUF~#%Bhy-Dq)@K?^7WnW3DzW3AnGY&OC*VA_bxnT!_=K26 zun?jhf?nq?S;cw|vXJsCdh!*0=FHpyQi@8EG5Ms3brFnb?E z&KS;4)S%@N)koJv?YnKFdH0L(WK(1MpqDj(R;wGNWdpjRn{YX$$}UYa%m+5bIaZw6A5*h6!JkWD*zO%}z~ z<>da%gN*~Bon-ycoum&WjwDz>#a!Y%y}U+Y_-aD8obDMn(gYYyfM;^IH#ANf(r7~y z9qJsi#AVIqLgyhxpWqGG0<_FzzpY`AtGN-`XUCjx&Oh+xeubIzoY|)?9!a52^>I)b z;*GG?1`gvC6>Ux_Yx6vWHqA&{U2&VZpS-+$WhjsOU8HzczxI=i|8v0yBjB~!Pb zgO3O=iEOEmQ&bcltdFxVnQONu^8Z%QO-|%pe@KqxToIE>C4_T3#W<<16Yi4_Ejel( z%F9_M-ARY$170LvztAb%8mC-29x&h>B!)nEQd!Yzc6yqL>dcBJohXDEW6}p9-FB>< zS#6y3YHXE+-^$f~M0b9tJ;WnX2=4Z2din2;ZkcXTgUV^M=&6eLG%Jlg;rMD8E|&|a z!JIHcoP(t$5RhaKJVs8#S0}L$!<~iM+nAXx3W|&Ol$Dhs)Zg8Gd?89Z|8(+<^URK>79v{;^O9J0l*W2c{UIfyWvfYc>ch{ zFg~3I_%t3IgI*z=c|AKW2};8;--UtQ@#s~bLoN-3-?9QK)|(LSJAHk9mvOqPJO-o8 z?;4hRv497uxY`8C*$#d|qvtN;Ua^aYODiiY=OD8NLQ6c^xeE9aDCM)rj9?Z5Co_jG z$Bb<25AcIZ>`BN`B>BQtZt#`hHM%3}__r;H(jB+otfTlF>WeR2JJ$UvNC zfhgsVbanv-xp)w!%0IVpHhl9pIalkT@*KK0@iv@;F3dM?h^6DNe?8N^8*!MGGBi19 z_wa<{{-*wQ*Q&zqTyE9b_9JuyRe(nq)QOtab?ep@A&1HE4i(nnTDk{ zyEHa3bcQc{fCZoZm-3axRLy4wAt0qwsy}o9ri)-jQ?rO;#`KtW@99XyT-moN1$1I5 zb|{y(5oWf(Ph@0dpgOhPVBSBe23zp#L`O@?IAM9Zd@Kx~dyd06l6t8aq0sG3FI8mQ z#vsv|Wi|)X{~JEi!benx0jU9YTA<`<1>uPGmt`f(ap0W zs?*LLJ3>$1Sl7TKCZ>z+R)^D86K1KfBL=#@zP{%b7164w%JE(HqU3Jo8kub|QfU!e z-V=w0pYoC~s>& z{tS$<=5t3G7^41yD;t2TZu~Ml$lTNAoJ?@>J%v=odcxt78B>J@d}Jb6DVSSL=2Wk3 z=|gdZO-LIimHQD9+Gb4OCnne`w_ws@r5qgVsZCqfC~}^d`{Xy(Pj)IeG{o`AD=e%* zb(o!n2cZyCnm6$WjQpk)( z@BL3#nEmg!-S}rNgQ54r{Ab0k|Hd@7o%>(LIy}bLO&&XTteSE>6R;6<__@Xy1W`?3 z@ca4s`S4>9)221{DLL=f-Mfuo>jHrC#8Utl!gmj^EfE%pffU*C9*#fp$^cvqBUz6~ zN&WK>FK&Ek-Pj5AkP7uHK_}Cl-c8;f2PGb-C>funTXwY&wJH&78kH9%>7DnRj7+Y{ z+h5RS(t-!35pW-P{NOU(Z&k?FdHDT4Ni^%C#avUs*JfaXJH*2y4}bJyLVODf3YJdl z|MS(SHh8A(Rx&`fBR_)rAp?hcDU7-)C>L#wcmDkIJzN9_k)>^0pPfdT2uZ;A9fExq z<&*~d%Rqm>v8D5uk7qHBFow^F#>2sFu}@wMu3W;w@Hv)9otrjq&TiL6;o8B%l8lC> z)p+akkc7YfI+JTjI|t3C3GPi{m*MwYPICP7XxF^wTQ_tPQ3ev?d5llMf*y6__t?|BPvnq4X7xIG!K2uXm7+GeA|Q!M0gM4s@@ zE>Rr#aKr*mTiR4sQjR6^JIPHbE=hn7#N-DrTMTD_1uwq%r=NbB@BE)%{QUWIF=Q_P z86SIE0*7O<+e8Byf+=)1hZ9DfIJfnXP0j-ukWm}EU?Im!x@#&%-o4&giPB|B%@T*>Yo z*T5!q^&)JnMerg-`~36CFZ`51GNC35CD5y^{FhK#XONkBkT^(@kYxMs&%H4gsQ?+C z#6V07a?y~(9;hDj4cMCT=39Y*VO#`{rYM~+h83OKR(aniD))JnVbEM?6dje^a_-+* zu~iWkkzxZc^xc89LxO{Y3F^}H9c$*7R|B^*J=VY?WOfKOI{fT8V&!Z%ho9w$QCS*D zoZi|#GV20fRR4x@6c-@GfwDjVfoUJb`Iy}Bmsa1tt@0^n=*PX!0LxGcc1 zi0_TrtxlMi%kr>CaW@SHQyrLCYEjCK|0 zH_ZVi$%jCAvC>3EGlmXjgeVTj+|s37TZmOykZ_#4{SY-$MM)AO0yq=~OkiBhi;?u! zf{Lbz^Qnn5?85Q)fZdA<;N;>jdl(8Ra84ol3VJhZ>2Ha>lDwgln`i(2--z`Vxh>~% z#RgOrxezqY9|45IsH=cV6o!3BtV1J-Xm-#zt&mE|@#h-Bs*^DT;JgGha&**M69`^{ zbBB2DNwXz{C@bK}RzTszHt)~4*Q>rNI;5h@FzD|=z-t?MkWG;Q$b8Yq{(d3v6AbLf z$n4pD&Hy|U+q=5h`^VJQPM#O%SK;~_m*YgmC(l4#dq77=qB{rV#rEoOdIr9h)|7@=^`>p60GG za!93p{pta8>?zpTtH=8oJkAiWCMrcH$fYK91>rGsle?k8TdpfQp<79^92TYlyGzzj zAp}uRg%;bbW)Hg$y3y&7w1}NzWO=@)1$tH^C=GPgDm6MLCSU^!#fpC~SO8Mm@OJ}o zigT4p>-f|VgSE7V*L8J8+hQoCio zYKu@OhaFfkG|MN%u86f!2tm0#0wo64*|&lU%P7x82PBgqpsGpj=2#90{Jcb=52+YM zPo9jf1hJi*fhh`-x^L~@v#b)TfbO?%-wxqI$MJU!L54{kuegKwA^Uc0GB4yUBs3eI zVz1ehslhtyuwM>Mr2or18RhhQ$TFDpd0^M8Hii= z(20KvS8w+=hmC?dz^@`0Gn7}uP)6gEvzx#7EGNhU!%X%FScC{cAzZNbkq$UMA$P@{03l}HIfNjLU0`6rlm6t3L$p&UVo1YGfD5>y*o80%N_Whyf`dMPte95!GUA) zaA6rkgpmf}#fumHXGmiQrWI|{@gT!eNcsdYYb2{}Vq$8+fKMoX?OR$AU=ee9io_`l z$)}dRTILqZG zGD*SuiTNz%z|TV(yySENngGE(!&g&D(+E$_l67w|o(q_gG{}J|2?=Ve@ce|7!Y&9Q zPYw2HSCGuY!a_@EvWqxv>7$S>Qow3&-@WVdv>avS^mo?;hLkQ;kePLcUu8l&+7D(2 z^xlivDQkMM2RI52+!$1?cx)1(W4x-5PWev=WW#-_3h=Ft`L&1bbmV>wv{aEHNZ#=R zgAIlHlPU(=2yE@~1mK-??O8nwlcy@s*N&fmzSkz>c?gllF32-tgc!cE!1|!AB?@d5 zwIniQ<@-9lh{xFMX&l54ATr-2Mm#}voV1@A(_tBiM><&yClp|eMcI6W;^;H;L6&^C z;@Hk3`WGq)js|l%>20UZ8bI7sMH^Z#PcotlaTcm*H6}5^mU6ty zvDAmqh(exN1a;BG;1kf#Q*aH|qnECI{P2WAOBmLBnM9#DSx6v!$CuSAxcSg?qfel+kS;y??%TJn@A{G?K&+%_Xs&LSMh zG*5UD27O5Hmg{Xu_#ouZaKI%Ll17BtM(@9m^|dh6Lel&NBh>(g+_`PrV+`U%Hv7zX zxsw6JnyxMb)HE`eL}sjUYOOKzg43vh?i5#7knA_u1s3}PI5f(AeJEvQJ`+IYDcoQL zCN<^V*)1@N+Ni0o{}2~FRrLGpJ&pBhD1y;FH zjQwodx>XaC>!ITAcJd84C`~XEtY5!A`OK|fQgm}uKrSESd{|-)qfaVE<{3c~<@R`^*_h6>mMq4>~>$Y8QS+1DrU;-oV%BY_4o`l^8qm>4o{pG%A|Y(S+Z ztzDAGpwbav$dmYZ;>rrB`h3*k*tpNb-&YgB*%TU#%fD7sT!L*M2s{LC*mU$a!E9uR z`vuuO9Vk?16h7Ng0*=u02LseJ&VqP+3?ih4i_I zI7O^@o;`EsO?`cR&I)EL2@EE<4hS+=u|Q~x48((`01n^pfE+J@nUM6YjEv3bCb&RX zfo-)Vr94!mA7VV)j>B&S|uYv5Z6_KHTdU8fniD5$DDBd4XsU8(CxG!nGmAcTza`y;oVm>BR3 zDpHFgTo@$7CYB(C$%H*ox(J~Lun$Q>dm5Xq!?01VW3^0pq4$B9EJnhCh{H};F7qnUjV+z!)T2a8|2 zjm#bI<{p9Co4e@deST9oaxTDt4#@rQTyHV21WQN}3aT&wS85p;K<1k_a>Qbdfq!+t zIsyw7o*5KL@;n2lKM$KO+-laEL?G9KHbDwkUIA7 zUhk7tM&1)5Hv%|Pmx!%JXT1|~lOQz_-aa5)O{ET^8wR z(}I~Kz^H72E{bwnFc*PnqIfMg-N@n_6CpFO#iZiNiU5(J2SEk!0%|)$Bm?9EWDWD5 z@)Yu=XP^sGAYT#_ckABOn2`_+@bNFqV4b~t`n~VT@%$rHN|=xqBG!PIH;EFkl{rq_ zT^R!~8tBxSHc!V8!LroLb)xmT4D9ckFp+S{BQ<^?rwOVELHFT{JTE(m;mJjjxG^9h z*i@rmnThk!DSVW5@7{C(LMtfHO?|E_7I%2 zkI5Y+u=s|T4D$?0m$tlAtPa?LAPhrvAk);-@;&bcBe#1lB1O*MNq4L*%RxdMmUdp29D5{hw!i=N`0so&?z=(j&QvB>h3wiOFTT!Z|Y@i%GuV zprE|AaI_+6_WY4CNwWXlHq^WC0rC?`{cvv(R|qi#1C{C4eO8X*kHz1p8F%%bWDF;d z0EgBGCh2dF-oIBR;BEI2eO1t2CG`ghEu>gqp)#tc-DTyPZc>OQ;;hEgnaJeu#e9sjwZnsYL3Il;{k%@gtpDX3@g;gz2c zJw&+2A;|ayk~hI;FZn08l={-CLz4g7-uwu_dKjVx1l2}hmPQPo@ngC(ghSkPLoWK0 zaNS2|l;PTgBx2r$R)crdj~+4M8bN(c4&P1YRYfs=BcJbFODq&AD|kz|;i6mu=M4$} z>hWDl2f~P&{6=qBjp@g*#8W&Y%dx+DyLnJ@fu=2 za)Aox^R+L4G>yqMF`Ai%U3L`M?IH)4VsY;bm(EnI0?Kg&pK(bC${fd=G%I;8I3H$V zH5i2nmAK|;T`Pq{u@7eaIDRz=z1vz3a21M+k-#7+m%QOw>+(sw`pDV5C?+RCe~BOm zq)5?@B$c=$BdbmyRwF<_zQcG1_AAJ>xBvW874|AJv_z8H+GZ5EGMr(Is45^QR8Vb! zR88j=yU=3cLo^WS3l3Y-P;zAh+b8ZtS0H+YHgqax@xN5~p|!Nke@H`kKM0Qw@XQzw`~aRrp#+6XdY3aKiA+%IDMix&p~)T;%W-(v(Lk))x(X#<`R zVvKuZEbv~uAm~kwCK!{&|0l|;)Ysm17+EAANUISjPs1w^F`1-U*ha1z8Q1=~O#V1g z!r(0f#LxurKuuOAv{9wRpQ;^K@_mT(ai4M_=SM3NwWsIyvV;R%~o?;xC4)D`S3 zEyB=C{>zsy#Eu5UGy6f7gFu7QdZGKiIPUM!EEjPbzu5Hjf()=f={Vu6x*#(C?Ipov zuSr#8NzH>GK_qlsVU>YhwnP9C=Or0Yf|p#k=jwDIfRsZIS;Z}^!gA2V$Xziz(V_zG z#tBqLNzYll)TfNce-FV>lOzQF0#y*-2B77JPHm8$Tr@Gz7}kak-h^&Jj_a5f;VW2b zO-Q&6B6G4~cfLIO3s-@Yn&UkeZ8I+AiQ zm8^zjZ5ab$Iu$q^^i{oRxA}VZKW3y<1O?AUH;qWHWlDC^;|NyyuyV&ui!H28=I_sx z9>QTK@{}gN4%mueMCRY7rpMh9uxl~LkAD#NBNS(#uoKwF_E=^3EH*c>wwKnLo2)Q@#`>+2`uE_I{Lr*hd z0WN{qwu-A*$V z@G74sCWs3@6?v<@+^^iS7}R2nWF^Ea?!J4B`OK$K&ma;+cCDz39}Fsh;(}wDgaq>x zHXI;k9M^xP4!tHxWJ5s89CF_jQ9Lw#mv4LT0>hkcmk*q2u%*sqUw) zuO*z4Sec1?7)k-rw+Ju5u15!10voWxEK1fBIwN#H1L7&t%Fs^+26;+6T}9;Z;}V~J zXcZtA831JwvVl7dlJF5$u$r(qb&J|{K7~F^JjC4RLsij(A-9T=;|Z8gL*XVDMx76V z3_-f@5RMO}#9Mv5EYIAN~2ydb*8L{h`txGYpn;)g)HQ-6HM;q~%&zky}~NsUnJZG%T)YrEtrmzoQOD(wJ!^4MUh7*hjuq1c?_JVix@# zFZ-O$qeF`QAX}NY55m!$^@DL@$A~i0^{?_|uM@wKB!{{h3f!Rd@Wcl*e>Yrcfe{Al zg>pnLR>FLzjmn7M=iZlu52EFwRE0r#5rt=x0|oFTabij3i0vMTl&=F)ivSuWsh7OZ zQ_zK@t;Fnuq;UYmm5la~gGkzl2!Q$0IO67k07Yy95YhO+FG)GZ$53%IpAU@E)QP>N zWpDKV>7KxTB#082Rm^|%=zD4{yfP@yc|0oeo4?QF>cE-KMJ@>=x>$uV>HK51D;>6d za_aprUtE*~<+7xp21EtrBA!?=*Fuz21dv<^Zh3nOmOX+?{nSxxG?4KFs@%%KA-|hq zjLHphuJS&eRXKUYyDEa6hvNubv8wP8igw^?qMgVT)xsXJu~_=E|J8^$k^Fg4(U5v- znwpxZ65Nk`hh9ZP{to2|P``(>bCwiCNU9Ufg-{+XJ<+UItWj@x_HBt?9-ak|c#eoy zr2T;^au_!q5s3^`w=qTYFs^|g^cj3gNE*e1yWTSz;>kF9(P$0FGMa7DaMf+5Pg_?BIkfKiQb(o%jt~C8d7HQ z^y&LwwvZF~I-F~-)YaC+663%9w*)C6AvR74B z^oMMi*$L5r^DJp%I}ane!4+F+vb*-v@I9su=> zI-$091&ho`KRj@eGy(8uJ8TeRMO?{H4H@TeeZO?_@6&n=*nTHD%8<%vq)CLUj8Z4S zL1}@Y zNgZMmoADEx<|c?aL>MD$umAe%Vzv8t>tiOVufI0I`wWi|QTT~p3X+I|Cp5VYTbM7g zzK>Y3&-2pI2(4K1`grRgnOY!CTi{$Z5GvCS$OPo`Fo3Enb?HU?tPf zAr+XU`apKc_DNqdzDq1L&<#|PMvx4SkPsm^1n4r0N=d<%I@>_Z*qUha^!R5D&3dQ6o5T9jff4vvE<6a z3iu+(1&8oUB^)!ZJR~Tn28>10I=Ola$~P`2Mg|jxYjqhHE)c4Rt_@e>UI&$vbaKZj zHYf=@cnIz#a+xr0@kj-q6qm4*c&LAOI!{bPZw_~D@H z@qOP<&_lkHC)+}T;=x<1LvGeqt#ZS!M24B57A8J>_NoX1lQj--0zF){Z2SNs!hg0Zsn$ROnVQQlx;P!dl1(w(xoq%Fr7*1iXoRc{l#S@*j$SgqpvIn>ol`$;8h_7jfKyaF1M1(XT$kYT1beoN|=Tri@j}=!yRnutdIEv(2tmgm0-kZneoVWkq4PzE# znZ+25eVq0%lbynBIAtvw*_V>aHg-Z8Gt70_Ph=8dB$BlVB{F7^s8NzAGL>X0TSDl5 zzRo($HS@jh@9%rxzwiCW@BaNfzRPuScJ^7`@8f+OujBQ49eajPJea`gZ$80EU;t2* z(I_R=HXacFLDO#lJLs zK6hbH=73eX*+OeU(QuE1_@okoQ}6B`PJD{z)kwB`ohih zL~bE`>Pr+c9}V<4YR`SNQjiacoI^VQhrrs0L^TmkQ7CC)>j`NCh2c=b70@^BklAY8 zGg>qX3r0tBsYf(-<36n*a72l7`R}1|4WnFGZ6L`=FwHnd>O)ZJx~^y)=P1PT5a=%3 z+4CZ&@#b|J0Wo|o3&io9aG%L$O!zr5DpZICP<}F(EOfK|b(@TND^8S}(9ispzW6Y- z--$=(7TLHVeNY)P4Gw0njh%+ViVbtSq8PE**Q|Fz(lNn#& zgT}<+J}OcLZv_i7H89gm1CN) zaWT76@j~^m$JM#sy#wte(*DwsxNIlf63? zaQ-}s@0dRpW*d!NtU;?)Rt;*Ae^IU*8|MHV9TlBZ}x!8s7%nu4&cBSY{C{uXf^7 zLu`|_GkbJciDc}jh!7a^hFr?2h}G1lG*QE^^urY{g_7w2x*hfYXn>f4P{OgeNr4B- zw9bQ~x??~XIh4wEF?vMv0IpucLe$m6n(7aKQ2Zx|ewCKz&m(ag%e^QG6=BRcW7Uck zn*fOQ8;FO62bQxpdzj9>S8 zjFXeasrPe zD&N<;NAsE9i=%^Ack9;e%DARvJ01b6AL5NUWBBM3FJ|3wJhSBE);%bq`qHaoThs@C z7r{y)owRKHEqp33c>Zub%16G;QANDne% zx_N62EaEecz>GFVlI}IhWddguU)VLcF!1rL7tf{%F{NGfyOx@8ZbBy2vfs#RqIL!q z2h8>9tXzhDiCO(oMCD8PRA+(=}J{NgtoAKiHfjBoZ`^2nx7SK-J1PMMk_?#Wnc(b9bH8EnK352K4 z1JZ~Zk8w*7>}CJ>$(^ZQ3?aZ$ZAN>`_yMX-)6YKZ2b9{E0wDRAkI%F_m-@lg@-x6< zOWm+CP=y~P7`4hZ>LG-Xo!jB)BS>k!vW$UXisC8-0fCg#KJPCk{+HaI4@4N^aYfgjjA|UDv-~^7QP!(6XS)U1u$@jLt1ZEe+_85ZnTKhGkPwe(>4UT&INL8|hP{tuVA z)4za)(3i8BGJOxveNY6O8j4w0Sk`UsI!?aO@sk6YMVuZ}@lyzRuzJX?G53GH5R{cv zOlN9*#BZlgnKkSM_ioO-QzmarXmy7~xsJ(gQ%Dr3Yo1qaRErmg$^{e;1DiR@ziufS z5tHsd)I7w2{^uG}FNd1Bk59OwXNC+bPyID{AGIjC>6g_7M{*-%Zf3nhgI?=g4@9#9 z{4OPuNKRbUyFM?SHI)o%XyXQyDV>MB{Y1rcE~t3ocaF1W?T_=~n;Xq05S0q4t8W9} zgxdsqChQ$~!lvcHtyd0b6&2iWXuO39;MO^yPPFs(S{HNr$kZ4z*}!tYA;zk2WM3ZK z(V26O*W6sCaQ2hnJ{x!QUL0n@Cn8jhxvb-jY)TQ@?b`v}q=kL(;6Wlzo{uQ(2A+`? z4p$VUV4tybdSR~@J6(p5 zaiPKZo^Za@IwCD_6t*{T;H9}sOG&tu4}v-x50>34>tHh0{U{P?Jiw590Yd0EHMTL- zGxK3S{&IiH^JMm%nm2g04u(d2p2sbkif|qI;7;v$+Kyh4c9W`X(HY>~-r}g$v7+pN z$FB(qI=h7@6Q@FParLVvK2LUj{+^G9&HNmlL|gkn>U#;O2>H%nZA@SZrsX3O*BzAC zvKkMGk}uc8_>MZfi9?OhL8$^3bpYbfRfe#HK58kM5xc4t^dPp;ARzZ-!no@7=z@!b zHL;*(haC2s6R7V2WH;0oJyo&u&R~2s(Rs-$PNH7ibs2?ks33F-Ol88;eO zbJ=0Hpfs{9g6W}Y)XnrF)y!s_q&8PXbLYtmcci~PY5Tbi*$^%#Ki^cc{O@&FK`P!Z zIo$wOy+AP9q}wTcB@zUUH+e*nmN;Y6>crO;xPDcuW*I-)>8zuN{~?+g^Fy!*6#koLRi ze#C3zsW;|i|JZKkUbC^sxo18Pzr%CwXLRs=bduAhm5GO-7WEK`3*)Qyf?u&;T>)}? ziJ^p=3z9)qqPTW_3hBmfa*|tw*VXJ~(xo8PY6M30*P5-Gmfz;vKfa2_C|%aaau@^H z^x$24o{V)KJ&Pktl0c zLHkPXNSB-!_h6{cg{kkoWrQiXm3rQ@;P=B&a+EscJ}y&L$dN}1qzZ9AXu0;Kjafgv z(suF2c#7Zfo5x*VQnRBo@kpYQaf#=Hx}Eu?0(_+CoKCd{WJf%Xy;C=%*4>@$nuISh zzw1e1=)CCL8%+ZJZCrl(=-F_U>Cj^aZe8`-`o_@-tClQT*(sv28+GIkR&>c^rWa2# zm$zx!?ju&Xs#lSs_>r4HX3G69a108Q6j|tq2TWY5T@v)26|P&4|hJ%opZXWAQZLN`QdXtUzdCXh+^iJafNNS}2!I zaG`PoBCdNb$5^TcbG2E1ca;rs3p~BdO^SOU>13kcxB+{pd~aPjxCfEtR@Ovl-_2jl z&fU6Jg#=O@4>%Mg(W4vGELXAztTIO4zZ5^I&vhnTP*=(;QH8m@zmn-@oO|9ImoL=- z(h{p7B;#;{%ht7rnM>o*!+-UFWmB?Fk8JGVF+&bbFZ>S}mqzdTGU)7_!otECy4BIA z_P9QNchd4&r;0w*?|gY%EXof)sAuFn8ojV+bj+|yQ#0l<7)g{2QsFgp9M|zW)}=SM zKiM)Z{|0f4pn2xg3L@ETZqs;iXdvF`j(+S$hf0N%p#BjKjaxVd{kYZU(@#H5FIDCF zF4{1%TGqr`V zjS+Ql@#1jLDV*_gwjfz@h7ytV?N_Cb-uKPyedP~zL!pESfGjnlNgssG6q>MSI>$nN z2d7&z)jPOI&@17|C0U9>!L726r*8iS2ybV^4C-ID%mo@8t=;2mI6UPSX=NH6iDA1g zqeu8!(V4#$xy4}?`IOMg`Ub;xx_eoXWlAo`chQB>2gcr#@|GN2Vq;EE2FD}`h-GfY z1`PVi%B8kK)Nhmf_=~Mb27VXuoQT(y`a;(2yr?R?TUt*_$jFPrFE5AgrsfHqz3sGn z)Ci@YC58jXU_ow@NXcz7<*XyhD12K{-GEG2LkQVPZ)!WqG1`@k1?_s3T&ZleD%1uhhTR&oMPIcFujmz=d%gP;>KlN|#o|$FI9~6>S~(H9}#Pix_yTh>bu4 zMw}T@CuCkkKBx!E6FY!|RaE0)B1%eP$k+W2P$v_9opY?VWb~=Mt}ruVEJS_v82Lf* zl0+FINj!>OJ@VV-7220(S(Vp83ssviJ@C<6R)tNnt^df&3(S3O#z!YUUDC7WYqho$ zP8>``$bi^-v+kW4e|J^tmofI2UB2xDWyYD+%RO9dvz&GjajzL!?USOcA5kh3o&69~7XGaqv8kmHM-ioGvkiUkK^@(~h{&Ee7{hS}k zoJal1>Nz4bpHCJcB8E%qh^Io~wC9vR5j7rW2B%%@9=}_%(C^ho5RiDP zc}6YzBOoYrE|PXUM>sM7e1O8G6U2rd%0Ubuhd0Gv<)~7loAS<>2sX%I8I}7I+rn7d z_h{OG%_-vJFG17)2Tl=19T*QZvx+5j`i8r@E_p=Z>crgzjEFL*_-Zm}|8{jdfwoRL zcJjP%x63trT12*Yq~wC7*H%(`s8wONy#Dz0A0oP|je(TF?8fk3y{_HW=k!Rv!AT`m zmGrG4_2e?14CJMf5iwQ|+T?}bJ}P-+R=!IfTq>95lzHPu10!Y&YYphKoX|e4Ht?p- z1kdY{3OcpxOfdw!sPQnJZD3CE^af_T_3^;B#VKI_XHZ9-c-J8H^(hkb0+&@R{q7Ys zPl|m+w58rtP3Iq53xo#2Afq+9q38(naN7JuIb$NH`OY)ovK|Ls^rnar7^YVsoymjD!pN1Tk%08S zqOOz{7?qwRTZp3o6il1;HPQ0V|^bDwvd4i;&2q#U^O zcopRUZzc8pNqsz44T>TucaSXZ#=WCwF9$WKf4?|gy*s>-N%4y9vm(sbB1u z6*evTRkmHp``r=`gxgb~kU6kqrh6{x9$Hvm$$OA zuD4~(L5Jn{D-=e71BQ^X0+NC@t~SuH=0VFLq5*6`>Hoo{o6Wx`KA<4$S2_ExfAxc~ zBh{|!R`o79Red9A+zLsGkd28-^9-eVZ!RM3pQ%=`2 zYReduP17SUpAzAyQ4$Ny^bo}YWE^yOPw-~Jya?+3=+#s|&d zL7PT0ldW@rTGzo-=Dn!v>Qaz`=q&rJzmu>5o{LR3polDz>Kj?L2Rxl1p{Q}n-zGt= zw8>^)&c40tAg9TJK`2;%oMb7c_#o^ z$P>n|4W)<^woW_LFKbZ3PYO=dpdo4d12UY(3(-9E6Sz3m*jp6p&b)Ix`~vU06r>5^Mn{ckc|yX0N| z_b@8{-{oC(HmEw(yQa}8UP76&Ws^}`YQA0Y1e&-fm)G6{q$L9tR;+|n$a+0OrqG0@ zNcrg{4b~Go_GmY7_Q~==z8FY9l0Xkkkv+kwmM{OQ^sB8(zyUPyRfn7SNTt4>vfy&8dZUoz8r#|*ufn<8h z)zcuyPeGdU1Q3BIbs`rh%j&2r>FMdBgz%eP&S(-0%qy4g@`wRZ%j=b#8Zj?U-}5a( z4u5_1Jebi_8MC+TQ8}x^%y{1!|0Mm9Wg7)=_-Znl9%PICU@E9}1s_WM?vTedt58WS)L-7pakLg?i`42N|vIeTp(xL}T#e z`bNR(l&P=^XFG_h03I@x!&G)$JSry`j^mzHgXYai)(}#!NM(#p+6UEZ)Y2e z!djn^_jyT5P-m#ET}CGW_M`_K)VXS$5xF#MMvZ+QkI6uzz>B9nh=Ev=*FeJSf*X{z zeSfP%?ivsw#Rj_X9wv@y8(5Vv)ZOUtNF56+O!1R)xi<(*f5LlxBdy|oFgKFHFF%AX zhJC6^oXifq`z57AHfg%S|g=vO=CzK6AR7 zN7ZeGH+|s`_D8A$Cwe_g+Q~8JJVriG=&8t+JM)fvbZ=ZHf#2*S5KmSc3460iLYEJfe->T~y zR?7~{35vD_S!g4$SRP{7DWwKaEM}>(x|v=5r@~#?%1=UKSUp^va+A zZk_L!RoObD;*V8w>GOZRdPm~deft`Iu^K%x=CcY-=Dfb(pP#&2ru($*i4Inuuh?z) zzEB-S9QX36sm%)%J4R72Bz3?&G3Q9hx7xl*$a!T~-~+`o8Jl;2`p~ zyxgS?00DN1S0r>}tXUXK`5DEi2CfJljgOCaiPt=4EDwFrVRTz?mb}yhI ziK4v$__4V9uO*3sHX&yxHOVzw@jxEo@7siXrH*}16I|N_oGTa2=rV69*UyY=Bj0xk zF@z2(fryL>pF;CP_Bg63I(9UhUElg`!RZap=aii|@|&EDfm;T5X#)1pBvRo~HM#kcD!-kxlB0QN#2%fryro(p5DL4e;v`+MA ze8wyy-~GVbY}w)D+h?zwDA^%)e>`YeueD*)+90vcXa)@M^xV<2fs@~qvtz>V+`U@> zKlK*rREvyCwR^puH?!J@5f%in@}B2syH{+_2tx@A$^Cbbh1&Y}v<*1tJiNgwqp~L+ z#oMKO(aP$Fz`E{-+_zKGLv6u_v7NN{Fbh`6SLq9=Yim(ath{R}&Q^?H_(q}?Y`ZNn=f4tguVsbxiu&#ZN@ODe&x5&Cj8wNA7$thT504AO^Bfu+GZrhe)@71%xD)8iQ`ZlxN$clOkU(W-*PiUoS(v*dn zfvp>?YFxXcZArhM@; zgpRO>rNmh%E}x<@*vSnTOTbu%8%Cc^JAO&g&0fa%BuPb{?T2Hw0ppmTB+Ok^qJLslx%Jh3< z>Z_kzU_E(Z5ix<_^$4AWt969?O->c{LH*B-!M?Olxl45|_t&1MHxJ@b`wks;^x4>{ z@_K~NwcEFEp9?9j-0#+wj~&*>iXM-rw2nP~{dmL6?b@|Fjo^j}^v!+aEuT7Fll#Ui zUu%fxQ+d5N(E-)#4hHJ{?aN+bB@#QX&21XKeyQV*=GcX&?xf>##?>|i6#s7*82H}L zu;(42O30pXjmb3XaG=Tbv&fH-#Ux*0C5baoZ_ukXFqnlxKn%svgg5HNvsUT?6;w(d zrI4J}vaNzf3}J+@DHdAJw25FjECNr&O*Dblk$+~OsPSYlGJH z(Ul{3{u*v123BI%V!g^>l-zyOkkSWIV4{yixq&x z9RR2}-Tw+$7hU%DNi#`X!-jY%t>Dm1OiC)yQ>O_TBhm=M+Po6$KK6B5jUD&x=)k6-BoN4ONDcPr&CchGckdnS+pUUzA zcIVu@xm}df(I=Ojr#^7AK86-jgmaqEntLK6-6QEx7-*(lq$)28A5u>TQ zA9tL-GyBr&B7dHY@D9%2EU!K~%7da##XouS#5M9LoEZ5JaQG%;|1ph4?S1vOIs2n% zagV%_l@-K;mGcT>ws_}r*G?h9U3adbs+jp+^bV#Ss%TOi1cnYIhiP}@~@Zj{wc z$(pEVQ^1Uc7;W9U)dRVT-&3E;8R=&_j)(^sJ2N8< zdk;E{?r|l&B|+2x~C>nPqL- z)gVf7X9$N^-hE0Xs>vtkiVi{HgR8QK%tQI)#OMO&2rma9C0Jf^hgErAe^PPL6cLIj z3H&{&*`o%h&_l5G>xXa2E}N9N9XIANggh{N=E?XO!-roRm!8vaawog^n^jjh^p4Hz zdeGNyW(}WXB}di|-^{x^VQqyDC!$d(gB6^+c)t;trv8)dq4>pMp0dM{CLzOan|e4# z`N+AQ1=F~Cb;k1Mcyyl)Yd-o2_6vUdctP2REcs90nbqDulmgj*Ot=etYVV9RYN1B< z_Kdwx4oiIoj(F?$%?m^<(sn0=9Uw(qmj3~*``qFUdjjib4qV6bb=v{8MHX1vDa6t- zp*Qj~*+cQ)ZY*6&zR%seXS_rksAvy5&bfKhK1T{+Xk9Bv%Yfd;hdl=9(AZL)w_>@W zH<(gT@AWa^sSm;~@ZJUwy^SWu(AZ!wIHj{SbckX*uyVL)S^M3b$W? zu27E5VU~mcX~K$_XrJPj(l@DEr^LMpejxWUvERj903ejPwxTVsSD-3cQ~bk74-b#o z8pOhurGo5!BBhqJ1*Nn?4x`R3J~<1Fb= z)u;X|J6w9cEVVyc774#a9ERdf*TQvLG?1NmZK{1x9bR%hx1?oCeV1hmV!@G}G#gC3 zO;TU=5=Fx2mgBBo9R@6R0T^79=0f=jm#dlNSr@?9VhK zmD^4)5ghpblC?7J`paWfW@RHG4y&9}aUJvI;j2Lwg2z* zF`#$v-Y)Uu$;=G7Oiw8HXDZ%)6dN3?mea1b9#l+~*AM2Ew(r;x?DJ)lza^oVjL=`( zL6}Zmmrq(o!gFKFHSk5(Vb&nVj90Pn@dxmp+*RL5eH@*CWcBJQl7~^J64Ji>e81&&blFV^1Vg&Q zhBlML8Q^S_qb4#f$cr4Hu(U#8jeay~t>xFdZXDU|4DR8>6&3J7l6xl_kM1T(s7UQK z#Zii~8Z~N|eeqLLQvQ4sr>lNhW`@x$+5ru*XUL3B6}WEHo(E>+4^v~7XiS!Sk#Hi( zXSL)8mfxKE$B3*y*pcS}r1#G)0+%=dTshQn(4cj&cK}12r0(WW>>5#GZfa%KC4vR! zU?RklC<<-dGT8En{zFAwJ`I6wFxjRTMmXB>B7SmyS5L2MmGRzWq|>6QQU$Nz_|(Ft z%r`riwa?AX6?a#8uc*bU*-+PrlMN>^v?%@P+`$A=XHq6CBAOxm5UeV55TkM5x+|Cy zle60#qr`qE>#6zjy1Z<>qMjQ7l02EIJ3K^8C$O|~=bjacr3nhXPeSg+F{?BD^Zn(m zX8tPY78dea6_EUYX_3S?m%>*_1tAR7-j6DLyT*YE_YlAdf~CAhnq4viS6hEWdc`z= zq1^)Lkw}DvhbO^pmb^jzC1u9VynI+rvPvJ&Slmm2g|YPgx9OG!(cO%?;r2gE-^)OCQ418VbU zM{i4dBfB(E?d+VK840rp?}?#yDVFs$^xctL;kfYy8!1Z zkrqt`>B1#pKm}Z-N)-bmOF6Q8cYc149i_)FZF3WZSn%@Xvm$Z3fpFW{2~`>4d95Mt zNKptzxQ51U+B`n`P<`;jP`^niQ*V|47gffTd;d^vwx8(&8D-BD$_?49tcndHR(lco zMfrnpA}mI$k-dUvP!nyi<#j1jIsGB>6&`)45N$MLh0bung-NPk!to`CrzYPVEv!^5 zeH+pq)s_Io4@=n}F_XB0;fQ1?`5AW6BiIXER=jtEMChld&SiwEDF~yS8xvPC3h1I7 z=)g3uK5V$pma^$fQa**4U@y%dM4Y6Jq7D?`!l3Bc2Wr&Fdl89Ev0o!X+nys2dIWAP z*^t%tbQ!jebvpnkc+9N3gjbUR>Kx+Bc1Z<%iOx2Po4Ax(-0HSf4g1KhilewMRa1WZ z{4L8nCGy0~9_HkU{<~#8rgH)(xKfIw>+JWQ6l?K9V7+hSQ>KD>soKpcZb7L5>jE1`(HW8pfs< zNiKHoF1(%6hq^9s@OV;WfrUPw45p;{yI0bKa6wE{V!FhL3J zY5yD(0aLr)=CjwgTd(=iTQw;|>|x}DyRh->Zj#Tz@i%LaWo^4$)G^G1UrROsFwwuS zR^UiAd7RaB(DwxWcdt)Ljr?nov*$~a<7pY@P%<+P&E`k%Mv3zheq7Qz4 z|KQ7y9!(Y8CaRfgmJdjK{(*}gS+1{FY*5q_yb_s2oQu;cf zJ9}`ro_U4ve;({+%UevuVzw-^K82CZ%KG}#(Q%x8fkw72_NDGe8WRVdh}V`5r6;>W^(fjMBj+W+YlJIn{+2OJ>5R; zHti^(ENgi68h_p(!Tdyv7n^UZ+$d69@t}pnP#8h^Gs-2Ho!5zpw{b@R%^L$vLh~kG z^oq!P;Zt1bBXcTx-KOjU>6a)(o-tLT;7rp!m$J+dc!p2=YU#RzT9x_2*jCQu@-oQN zAdn>lA=_?+OIg2|)-e%4I;&=J?P=S#_cFhv$@6Opeg1R_=`Vz??Ax~kZhOD}#v1^} zedvn>SL~=e@Lk{1b&)dCJ9q9VYDgpVBR^j*tH;_gI-Ktfjy`d->b)O}=>JZI>BoGG z*54G!%oyB7-BZHkl|yC+;M3Nme?)Z<-S<^j*qxMi3&LF^nDICZCM4T;U0!P!0-^2n z?c3z>R;;WhgYidme4vPJHOhm(s8Z%HVR*%myS;~px&A}Ub?hLrzci~^R!mvA{`yrK zYb3_<5o~R48dPh1=jsC(@dw_9U{jhWOM=g=ML`94(g7IfY=_!IQ4Gja#>F zeQYp~ze^`;EbiyMeCjTH01!@@NhcSeZa12+=qO;ZIhZhNHyF*#2{E966L%OwV9EPm zd;&ghF!C^0P-45;@nChj7>v~CCWC0LbX@yUTuWDOOwEPmcikgNy;j0qSERm(YrY3`y8+CR-& zrTF^!P|MG-PRixMU6A**UgS_YOQ?ld}c6vX&ila zt0|?vJZ)Hi1Bl$=>j^)@>5NeIg!o3iUV7zqih$-oxSMiliJU_MS-7G4yYJR9Dn7jP zbL-O2Sxx?pGM4n)6ol)E{iNM=8tKBuk7SnNt*^z$_vZ0F zO*1Qz^i_v*M*R9Si5;qkem#2plR_oGW7`fL1~JqF8cB;yiXyctPOG%6HCSch$~QJz zr|W6>4*Aq|kvE+Yl7MF2;?fd8w5ap2Q$11UW=ZzNhtjzFe3Ez?Q5?vVuWcD6N*sB7 zEHRq$r+G}JlCzv8P53BejYt}q0`w&=lca`JqNX6~fw82s0^U`L0`6+m8+&o>dmNl4 ze^xXjDCB|s1J9{%D}5nl%b3HD@#G!!@*uzumn(qZzh{H89W1M+jyDa+=0>WA6eu4B z%YB}I$s+_-jd;fWr?B9p{Xscq{V&DpsMD1SDmU%AV2 zU$hqA$n(j`&sPinUwXdZ{H5pn4|9J|5=3slg(y7~nmP(uFZvr9Eooc)Ywi!mjef|nhwd4}h(ItpvN*~V;>p%@i^_jW18g13R4#x)2L@DkfMJ7m$`WbB{J3q|Sn{50tsAt=*?5zSd3J%PeCZFi~lp@WO1IXmxgj*v@YyQV9$Ta&<3TPClE z#sznm5LrldkL+676=x${x356xuSZh#?n={Y0&m(oVs|4^|lap(B0 z)@4CjXJs6my-3OElRMrsOBf|uWXpGowvl>$LYsi`kJo%amMH8>TKJnB(!YaSN&icp z-GfD%1hCQ?VRz^{8eff3q_V>_=TWam6ET&PQx*zGffydTjvj;rb%Y_!P?Eau{r7*S zM3q=q%|ZUgFXR~3*0gncP&&((d$&$(l2WPtL9(`T73~%sODx?GzTYW)&~iu~Q|Nj1 z$l+djP&jI7H$nko!LCKWZwO%lh>%AC?BiZO^BQ_Z32h04I2&c!WXjT)Sq17T$hv38 z7;Zz>XzEoGFb1D2#5z?5Lu!l?6OwyB20z$=azmpN*ydRo87pq*xGw5gtLvRfK8N<5 zcyaw?rNTwkH_olxq6FxD+OTuW#I%M7XN?G5k>*Dmx}Gs|N{)H%2G~I^u=C|Gx5b7K z%2Iz%joc8t#uIj)Uj#mt?~+7+=S5h7~h(31>=KIC@ib1%06mgv;TP8YS;1usv^+&cKcuzJqf2LAL@BdK_!+;@Q+ zLR_RksDt{$;oOT`5p`8P{aw@tY-hJ{<44Qi?^IN4*z(Mc$=rtTcP2l-2HxI9a}F1dK6c^-@R!J*?CqBY zdwg8tCzmi}nUK}6*6o^@TMX+D?Lfl?slw$>85Ws${d!%aSiSc7-#)yNzTqH3R_E5% z(>VAm?~IKf7%-i*8GhMRdCImj_)dF2)|u4RX)lp|x%XQ4q`6FV^);t37nnfl4ouY$H4R zt!E0pItBp@5y>-8?rUY8Qrx_L{jW*G6<|f9*tM=`m*t>uRHIf@%nOzqLw`bLEX>aI z;9ClxzgLE`MN~f1e)dPtlrO*d!aQ1I-^a|^T9sUIY;gFPr7SH*9e7FKxx}7P@+|Z4qV1MFUgpuja(P10|6^}$;yGM)>MQL|;VIcW@1&=fkBP zWAM(DpNA@ek3aUbK8B|eWbPJ5j)(OFdJ$QZsUj%&dTCI_l5N4k8t|yohaHi9^X5-c zi!2KwEA)$}i5D(h=r67WP_GlHMz~#G{k9@V0~&UZEc#>zEdY=%{>Ja40YIvQX#4t6 z(`aUz%!B|rK}YC`sp?6QsaQv zK_rk>g=ttY2%XX$vo$1VfLw^cAjB(xet0G|wf)*YmdfJv#0KH12GX)sB5nL|YUuLyW@lfp@ClO|mfI75d>^Itkjdrao^9)Q zZ_>c%F`Kl*o;&AjhrLDs-czq)CpI5zDP!fDjn*OLPZLwazD`UZn&ER0#Eq8Bc3R$g zEpRkK*cFXCbsEMg(&py@r3=t1jPl?GNx3NqC%0cb2^^hPLqF?8H=aABqxnZl`082bUVUNijhaKUpm%OMfi>*(FbT1w{+J@ zskwmc)d(SrbxzU4prZM1+ z)#ulL3gM5Vl0`^MdmA-TE~7t^$RNd(-8Z^h=wV<|N9q@7Pk+0t+U%P38#d@RHB`|& zC5##Epl;iV;m%Xq0u>lNQ9=Eslz2Ul2bLrygPP0Z+QdN+m)t_3x!{0_P260}5L;zfwZB|KNvcx5S z`Kn(X7vWYLIMU?xN?1-rp*K3uzysOM*2b0leZ11h8&e;EY3Oc@rA~g zcUYNw2?VAjFO_MUUV_FOP)%zNn@JK}*0Bdjs0Q+~@3x^e844-!?;KDnJ3*9eD2-y3 zvNmbGL=n)q$OTs+!lX|Ygji%#Mu6pvty8^1`x7!HBGgc54)Yu7y^xJ|v-o9xF`)*( zph1%=zAD(ir1)a#tO*Yf=R=QT4hwJMiki50{(J#TfK{M!%%bq6qtKH^Na1=7rQ!6`-saJlkUxEoIbcUi zilq^#RATD-!yR^s@71S|d1@Y6)ESH-$hVzn&!O8}>3y{r*DAO^CK@`y-Wn&;;>f-4 z&`32!2P9%6XZ^AKYxVVx>ZvJ@XR-1ak`dK_lEpwi{)X@+?mi%hfap@iR%32ghE-kZ zLXvOE{Ym^tWP{t$mKJX4h|`zc`()GM^YUSB^)Zo`u7`W$m;D^iaCw&!hW&Sov;|Ud zf#}qlVRIS~ps=U15m5H@xHea^p6Ut*Px^G!c}~P!$zRk+rRcb+{@~=m)Ny{W#x$A| zeM2c|wPG_-RkSR*Y#x5l}%sS#pS?j(5L(RVX9U5$OhC01O&B1yTanc!5+P z?h*;!ZkTanVXC5=Y}vUY0G96;Csx$VGpP}vwi=nss;O;<6c??f;m_#Q{V)pT>bbp* z_E>iwr{Bhn*UILYHyF32jut@^srJL84^c&J@hL94CU4iQj1{vwub{>nK+aL`EIxl< zwK0>qPWu4vnPjNC3zvN&tt6ZxxDpM;MUBMpM>hQw_ts{1i0?ST3-l*|iTk1F*m%h~kz-;9wOso_YS^0$oNIQ45`SO%ClK-T7MK!1Y)HImhK;k1gFom< zmi^7~E|vZBb*v#8Ue(Vva&boj&Ei zHshcf*Vn2%(PfJPsAAA0)`g}e$*s2jq&}!kG&2$p;2qpm`$0K>YqhqStA6w`CUx0^7rz3L<8B(N~V}QWt#h z{5jXI4`awu$w;ZtBm;U%&mA-u4b1v8z?*`|dtx%suSqEI@Rpj6u~&Hg^tHLPDZ z{=w?O0)7u`mbM0!1Q4Ed3eqZ3AA-n;eLLptPb)np2!bmuvu$B*cbb-ebtoa^0taYz zMojKcd{?764_@>MQCg69v|54BDSf})AhOLZsM?i{g7L02@N7hwLqW5Kev6pA!uXx; z(l(Okj#TO_ovoRgx{(Nuxf8nk5PBu*nfc!zaElUAoBFQ!C#>Pex z&DEq^n)T_$7Sx0i<>R%i!{*1F32zy}q z-9e%2&8@0QEmG%xr1q=L=W}}75MtpS@BbKgukX%|nX)WjCs4KH@jre|Yi2vfmW{7G zT-$80UvA}B{N*YQ_$BRsTV^@+yNoRC`+6R=I1i&`q{WZHDleq(u~w~Vc(7<>=%)#^ zTV4r%G6G=~6f5JWRvEN(X!Ps>Bp0bW+WPm@vwpZmugd&q+|M!74;8bp}? zH>_X(ht-x49A1Y)dlWrzYVk1ga0;r~bkz75(c<5>>p;Bfa@-&QGo!kg}a zS$C$iGlVc7(>b#^YH>PDQTRgr7#M-bA*symQd>)!p?r2Z%|VW-e^zNc%6bZhn>Cs} zoWT}gjZohQl;8WM<<(6-N#~NPmrTcbG%(V6)(R$50dD6w-pX&XV6aw`Pw_cU1C9#K zb91}HU_ah0SYy4Efc?W%=sU$B6M7wB<>e1TkYEiZB! zbOqwgZSM2TqwfY-ZmWECQhXW@Mn`CAnhB6Qo0JV78~^YAwOy6f-Je82Q$!(WwE0UN zP&1DM2k!7{;`V#5R{Dr33-3-kMt2W7RcUoltEu9*OdAeP)C?f{J>+Efjy6rJDW8K$>%X=e8Ed1}al`jHxf4Pfp|JdCy+c!iS9zS z6YL%?LFY9!!F%Dtg`Nq4_J?P4O!zLEPnOa1r%yj;=*oHa$N)wLGu0(3=3*cOavEZ5 zG9y{n0<-;3R!0Mq{hUr%C@dW+z7*V68x9{nT=GnCk`&x(Ti$(lWe`Av+_VXu!dwBt zgQ-Z=$PmjAp;Y#rJL@yA>h!g{D((}aqBv*=qCZ^NetvF_$l{{$QO`YsS1=~>B_wYV z;N-i$L}@95phRk=8SS zX*A~>sC_J?dJ)-b)Tr?En9jPG(Idzul%gLXSt_b^%%8Be`!wKh(oEU~TG)d45Un$z ziqHSBtZwXhFtN$c-#oa;c(QY?M|VQ36cHWc+ ziz0p*1qELg))GfxRI#0ux6tm`i~p!Ag5swkS?h=U99y^KzWl;LMoZL~4}PO4E|BCL zsYN%rfNQXT22M~XUA=W#Jy4ojD5!Mi3H%26gvmkF9}7 z)w%_*gl4%(m*hHY&yxFeN8<*5_0?C)ym)R_G0vJt%#Ys|6GeWILuWwnr5E5rzYRQT zP4eRY(nm0ILXO^*=k#lOuaQQg{D&IU|HfQ&cxo9jw6?LkySw_tRCH%2pBP1FSB4)@ zNKccZtDBA0ZnML`6b~W|$2dW1LTRXZ#(E`7H&(G)G5Lmxiw?1enJM`Y2A#m5StG4|yqC4i)o)S?EX7Lg$r_!7C*3X*i_JFX!{ z%9W;jj{HoQO@^W54&jkG;;0f#a!D=@q_sSu)&LXl@pQZTF#q$I6V1uy`R4&TYk+*I zBAX`pc$>tFR=fw`J3_wv;d}3GmfVaM*+n*}O$+umGHP5}E+pFRb zJ#NIaZhNd-juGuvMUZN8&Sp(5VX)f%=fB!p*)8KpLVmolMPVDeNz4EF&qNm2hqY?$ zhGFwz;;5zxKr`- zDIi&2)3Sg$^Q8J`qrRWc@GQbZD94unt>(jyZ0A~Z?MVlK`^4(hPEQ6Xz0&#JzHdq6 zN0-Ejhgd-UCqT$0KH#&_U4!?D77iAoRU?m7qehkr&y~49JokvRbQ{C;FM{0sim$>T zlF6u|Kil!#qHSfZTz>=FgaJ%<;`g<~=Y{a<;+{~2Np^%H8|m&vPP+lPnw9NvZjeUB zGLHc{s1p;a_r9LzQ@l2dCq%W|)amZIfEhDvD9Q$%w7rE#%$n@k>Qtd;53iAM>1iIU zwp~SbJ>nOgf|UYQF*RK}oMCHQRHLDm@$K^?GgseBExh*!{VL~6KKV8nlm$ik9DL%v z2eDGZBgZ5m$yh;4Rijp_I6Mf;d}fbT(jpx>x%3^WU zV;ol_5@-(0L2gy8?zM}fi)NZX-y5cy$f*vI)yr(;R0pPXp2Coe9jG;^9*!nbbGD40 zb80LPa-{)5MXK!$b1!WohOmvXa3yjk^#4eepjaqw@*YuRBYV(vPX(hoQEL3q*N*$_ zGuC>-Nh4?sltF&-_D!LQOPigwsB8z>e-F|wPR`aE1v8vjhth_iWnuPK=>Wa z_jWFPy$+K3FX?vqZ5eCG#na;85QaH#rUUw6wQ6E6Aj|C~V4SK>SP5OG%eF+pa~hZ= z<3lJKw*mG=m(|<~+VNGNgufP(`3pS^a0|7B#{?8x#tvbv=9=(vR;}^ zo$pO2H>h~V(b>Wreq>?5`PM&nA`omv;{Z-TehyaOTL9J#zaOI@!4OXC99o~sDnW}eAycRS1 z7s^*W2Be?gU-jDZWyDfRP{eYe0&s6X>~X&Mks`N1o7*Ovb!^hcvKc-`aPHQd@+K&% z;|-w9JsKhkeMQPEb=okokB$j^+p1PuYVbvsYx^0ZpZu}7^7`9YD$)qHLC|-wRB+gr zx-5C-e=a%nt648G{bA*n({q>q*W`x#3r6b+fGKW**(Bwsl*{}_VO5KgJNK3$y}a1v z`$5Z3tUDDD^8Ee*pJU1~vtq$$0{%455s<0?hZw=>KmPdRcXQiW&Fl%Xd+N8}VqwHS zckX^Vyzuo`nQmhXqPpF$#ypgtlc zP$1JH*m?2Z{rl%}zpjU|ifHcQYY`)C+(RYM#kBAAg~6x_=}`rPG-+O=@+Kvo)N7)Y zh}7C^UJ1I<<@#fy(RPM;JR|M48O>YoPu2!yWL)dQA3hqk!oa0EB&HAfg_I7|EAG*# znD^`V=>E*-R8|?Qad9hJrlGCb!Hc3)iM=&&&CVf6x}Z(8@pie%Vu4?Av}dMI?I>hl zK~Xtddr@~_NuSK_J^+Ufs<3p8AAdT+SIz@*S56lHPd8>$-#BJ|vADQTLbMP%+MTD< z1hEW^+R#}PRHnR_tB*{b(a@WPJPnzbT-NDm+qTX8Ef!oiA^-7f8T(wjXAA@OmDW_O zLBhtQYlk&X*wDC6otOq*mC^m1D~2JIiR$?t9;TDluXfIv-BjDmPivRrRkFYqbpy_T zPSPKuL+E`n^4qlJ9wySX`aBaZRbCqsV-lLpNidV&0Ii`h?oac=5L}s{?A4_irEa2NT% z9XzX&pf!IX$%nKh6aNE4oR!W@BcYzm@+lEto!)RaHLzJj8~qZzIl zXabnQ3kG^FW(QD(s{0`+(vA2HW(_UF*TqQOxojEMRmqCK3}n+?M8ZcAeGkmjv=6eh zEwM2Cy?0L0S!c;IV!p_J_>Z0tTH$>BuyEnkDIeKQR%^o)MCMRE&3HU?%A}oQ@2vl2 zVRe#?5e4h!|4Eo%@unrutvNG1?0hrcOGYO|69>Yd)(qFUXXW5(qv%!AWv3C#|4_Vs z)1`~ATx}>Y-hCy`EpJadICg})`!=e%0b*$*X8N#Z&0Q>Voj{c;EsW4XraxVlRaw{n z3M^mD#JV0-4Q@4SGD(A&MU&R!e{g#77attjwsmV`_&TPn%*=Wy-4^`mb5m5IBlbsN zb0HLOn&b!aB@1BX;CSQm1mtB#dD1HEYkj%?g#CsVMA{YgTuQj5pCB;sgU-kL9hd9~sEJj5OAvEE&`RFJ-32oY+xH>*$b}!Naz) z3J^b<)`A-az}=_Qr%y*PH?z}p3y9n0D%%8ey@#swXpz)z*Osak+)9kvcm4_=&Sf}} z`rqo3q18#7G7Mny>defF^nG#{RPNO1FAUZANi%4zQCKUnxCIKA2q*gjhEvK~OcHSb zJ`SMhA3(qH=*wqbxb8Hjo0}BPA^*+qcP*IhihqDZatiD^su95mUgsq|<#2KI%Pi@i zx4CP<%ze|KXS5AC_rtADmIs`*2ABqlquZ}xul`B^ATPZ7J{!wlJv|wJ)3R`_W>$f- zYyTy{FY*Lo|3*h7Mg0M+Qd95eTYkiM(PF+Cc0mD(2c;f7zx|OnAS)ne@*r#1;r`yA zj$5P4MXs?U{Sq||^haxixer1$=kot`u*-5!?yem9AG$8K{GO~H^Y4l|FNeNq%&#Ck zP=@T_Ycvg(0krkgD`r)uFhZauM?Fy)CCfsEE~KYiaudrpwRavdzo@j0dKz*w3p0^u z-)zQ=LYo}0b|?G-{a>Q4;6kQIBSL75{La&Yy!+N@iiD7&G?)`M4yp(+jS7)G>j(!E z)i?yF1582VaJ@~jr4aefpCq8kTf3AgG#@px1c0&W9<`e??c?^7gP_u6t0QOrQ>7~s zLJ;6Dd9|p6#w_z%RI&P)!xkEu)ei&azn%wo(?qLYyt>TG0vgB?pzp;minn~t-leoN z=&T9=ygeI$g46cO-g=gQ9v8~hP}2*<0x@a7d+FlEP5>7?&4-&`0p{bj@G0^}2NS+J zD>E;f8%#i)<1T+-`JxB}h~B(S1P29VGEF*k=x}8k8{>B%6A^;wqRzQfYItttd!#X8 zg2PR5MWr!?%`l3Qxg*fAxNE?tW?x`@Mq<+CWm`)-qf7G-yJzIxxwBI)a`brQhs8;? ztL~QzHOE~IZ)jxl{{-Gt#E^p!!DtKU#2I?Gc*mSha`?s^fw}I}6DyTF&=;Ic=cN~h zIMj)L5b9`q%t?4k*3B5@bxeX|^3&kH<4bZH#A{8bL}wi z`JoAEhw2(N+E2qWIcZUv?b#$HlKvQspv9V;qE>>cGk(Y=p0aI&@NC|8D2RUtTrB(^ zk`Ql|yCx4=PS9)Ct=oY;VQ;QWiSQQnC(c!_ROur4mNX(#;c{@MfR;-rIk<4&>A*7xBeEt(p8)n^6z*Gbf#rU4I`=bCtSJ0bGXG*r0Oq zhci!)M4pWmQR?I4R#~BCN*d$b;mm67I(Brw{rWS-6mkllh>`5bg>ARs%7zjbmRsE1h|bO_NdHOt|amfoLxO% zcKn*azzHJ`TGje>Z#_5j^F@A@3R_Eb3)1^oayr|2H_loU6};#(n426dO|}x1*icXf z@c=8{`8ejqyOtrM)1PQ8C|H@i=@B|Jw%Q=f4c4{$_Gk1& zOUG7^DLW~sRPNK)7raYE1r@8Bgb8(M*KYUqZx@qS4_=ByI1XM~1ZdKb5z%E%TboU1i=$FrK4}xQ>%!k+S78&?n3G{O>yX^k+TC;?uQumnI@t2PW zZbkxS3PP$rXzB3CsYX+ORN&9Y^CR!Qy1k6y#n0BN(5Ji;Cpt3c2zsyXCg|KFtQ|o6 z_&S8kHuLR#e_6CPxO4}){8Z9qZ`LsmTi#t5=ou4%uhr}ZFqn(IsVRuG)0l|7q`p~1 zM5J$G9JFuL52bMIO`X63PcDj}mi?AL-52u=3gihp<$I>_x`cGl&(;&K+DQ#je4^~> z4=qop&O6X=`opTuF5>l(iuN#Z`Za_%0v0@6nfs2oCr81h{qQfAzbYRec=F{03_|>3 z(jhO=;TQ5R6L4YyLJ?2t>4sr=b)|D7tAM%|HE!4>NJnqR%c1k^n1^L^dimRa4Hq!> z@nvcavC|5uk=>)-@V(#8GNbt4iFwV-aqnxE%eS%`=lh>&fB*B3Px>^nG=SRut!cgK z_YsRamMncMt2VFpkCku5SF2=ZmRNEi`D^*ZYL$jXQycwnPeYQm(DF!GNJRGbq-^4ZE9(m}Xj90!*; zbxI>CLBco4bE0F%N*}z|?M&(OoB69a?4-64YAaz}tJ}~-L{Jz*W6(1oTW7H1UAG)o zH|T! zj@N;RV7h!Y1pvv~lBij(a8jfGW`Vk%lU<_TAuKi>-p?|ZcbtM}{b6Hm=fu-o_#`Ml$*>s2rjQzY-m~0>(0hYpHhyrj z-k+4~lb}z6fi$_4=qcp-FeDntyQKJ8 z$}yY5v+aJqfzmQ!kmkskf><9_e%-Qp#j9<9?{twQeWh@rvK++tBWA^lsZ`%cshz?* z6K!l@vNK+h>dYdXaI=0$?>fk4_}(T)C__&l+cY}z=cB4B$Xa6~%^ixu-?q^oKfkI^ zr^ZGzliy`SL10~$73Yv&K27I3vCp2*C~5hGFxWG~$EwQgSKg_$Ito_h)Yml5)YSB) z#+K6~iy<&OPeJ_=#EQnQa<<<-40{~R!Mrurz)wYc1*>|n&%26qrLJu)f#RtLiILI} z(kwGRz_KY{sglwqX3I=;xgnPUWg4){Lm`mLeU23OqKK6&dJQG_J4_v$L^r@Zp_ev? z_A}`@tQT8p8vN?H-&h$gI2|gR=Jotw!9BB>0BSrLTzjp#;QqeADhsDT2`YoEw zTevIr|EbQehJC}5+wzU-v9@_L%J>(zhZiR@-+DhYPIb;hPcTdc3wCTn7o#{u*d9)02 zB$?sqz@wE6L3G3>2E$imOL6_f|E(%86wZp47iX}4$PG4tv>~urB|s#~YO)3|GntNy zMHTq?d`a;4J(Y+p^=3Rb>JOeWbm&l;3fp61V&06OHg&4Hq^)N?$T|}7W4B*NA3R|X zF@YIwGS;33Ch+DPm&mytk)Q}7#hOK91!Q9=`&AxU#TxDUV!hzp`cEo=^nH|hSn+*D zC$B%B2c)s#Z<-|y0tD10%f~>hX{}81PG#akPUXU1(Wky;u|+((R4z|VFqDAF%sD{} zVn696+oFL{2Qm?8lyzn3abRPN=?TbQ{2rZRF%4mqoUk3nsigM4sTIFHblt!7_T84@ z^x5tviH6W<+9%@+8n~AJ(k|EU^Gn-*3l^#lp?qo*dZx5I2~T`{>!WO3?~7>Zj3`E> z)=55m$GSBWrepWtJ__Gb^aSirSU&M~b{6eLon!AFx^_z0H5P;)wiq^qy&O9=8dT2g z6f|gQ?e>#@z4h!GD1u(2;7jn{@Bvef9k4uzAIi=znoC2xyQAO8D1%&)lP~XV;QMf*nCN`(23V19h9j6@YKr_l1 z_Wh$&m!_fXiUe2rWl|S9!Sx{Iu2FBWiD4G_+~nBvxxrG|{Nb=hLiYJ5M!yoWxnDc6 zG~uXO`Pf#fJD|I?TBp{(UHKsR8X0s>Ty*Mn5$E*Bx8mLtFFLV#4MyU6WX}44w)rpL z*$HKAK(DSF)~-z{>lGI6?A*F=3QAU+Q!S?-EqeBB% zgcr`N@vmL+`>BPKGHF(x5rm#)vN zO(b7M;l3Ny3n}sr$Y{?0s+^;?mg5@a`|h+451J(gke0;jAaESm!921x*@4Bkhk2Fe zVqGH>w_@gADp~rWTltP@`633ZU^Gxa*(4QUpk#CeFxYvr01hSFf~s&GeSNKDXbYu9lr$OOfCf6@^l~0@%EY4Kui%SbcGKrGJNz%*mE;2u z7lzRC6WFieE82bhSNRcW_Suk}|0!cg;WvvKTF{@YZKs+~s!iACjSAKJ)|tl5BvXM* z>F*RV&V`{QIomA|-Uz!_8M4LN$Gm6$yQ+czU>x*+zTNx;{*9&5|9LY1J3g6&g(aRq z=?}dqm0T`Li3C3F2luqZldT&z4@F0XRyxp`Ta8BT|7!0{qoO{ubzek{(KcYB#sR?? z%NYmI1W<8^iCW^UpoEA~1O*w40|b%5bPS0Sl``Uhb7LG(6o*1UfetN#11O3N1%gLG z0Rcq;k?H()DLJ`!t=spkUhAxNKD1xV3T5#h-uK;mKl^!}O(c^_)DO;o-SY)+9vWr+ zs^PI4f>M#q4q%WkrsdW<(?)(qZpe|9%1JM1I-O&qGC)}iz|Bxe8 z^yH#3CTj@&lOKbWYb4j`+K~rKF^<24HHDA(`&K<0X9@>tPAyBp$u5xY;I{tzY2_z`!i zgQJL;_P^jQTC@LC;;5J$(5k|PLunt~;(~KVkM7+Dbdpcta)=0pf=`|#{9SFfj0Mqv!%cF z!Q(4``+=OND*|ZA!#pGp6Qhroq^QQizXt3SaC7XUiksala)#r3Mqm`;wwkf=G$u{} z?uk{fIvirk6KeA0&)U6xQo}os&Usa}~umkqM>}2y%KNh$!V8@n z!fuE4IQtv1ZgwIS{Zk(2(%iCUv>&fb|EoBJ(mqp%>(-lCyqvHZtjd5RV3x^f?dK!HtLBv8;g0+kRdl+8)!U=?TK`d#n+B%A?j;G40n|- zP#r{a>a?D1EusN57BXeaKHu}786Mm`(4x=y#_-a}YCW;81Pu@$JKp_#(k|%_Lrs)v z0>W89@!)QA=f9J#xpF8<6@SdT^1fKjf{PxK^9SrnoH$86X^3q8-go8O2RD98$BW|< zA)21TBF+VrY1GQXKnf<|*3!P^ennr& z&|hlMNVe_@!LDY^5C@l%sK^lez@C{S zso;5s>6z2pry%OhMu$ zQE3pu(z^Qk6_Am{VfywT-f$Hg5-)Fq@ihlzjr}~bZ@+%RJQN|Dc&(gvuo7P4r05pM z^OScs`1T(0*6SZ$E)CQ3($~T5L0CDl@b18`m#)#V7@jp>@P545#?}|PV%UU^=2PF< z(ru4r*dCW7hrg*CkT!9K-4@HW=U*((z5VXQ>t{!O<&);Pw&(L*&Oe_k{=uSnoAcD8 zXaC-AcFz>O2^}|7*C+L=pW-{>nBna25+YYD+Igy^>3-On^7`w!0tzJReOOVu4GnN( zL385)r3<>}vtOOk#6n206SNd~RP5rr%=_u>SrzEEZDm5xdf{P#o=f0HmU=fb9_p1k zoRq4d{8r1U7W44~e*;U}Ez0AZy82}!t^;~iel@M-n=bX{=kR7il;}w;PNth6=>EsT z%`IVno4H3DBSjMf7H6v;6%`eoiPyCh>9{=_WlP4^Gqe|QC+HGlm16fvKFy>2%0HhF z6sX-1d-hYpT-}Ym}sN{UcQ40^xYMS!`31Y`D?D%b)tVN^*Y{Xm z(0FP^HS9^pm2o|r^-s*QSoP>9rHmqN z(^ECJ>f44>MvA(vF_mMJ^SlEbD_XVhK<_9xrm`tHFQ`5^)AeR_!ggg|WpCRE8{J%@ zplVQ8wG!g&*H^_6XJ6NDf$O)|xp!_#dq=UUeeqbu_}NK$Z95Nn%A@hY%e`;@tEqqO zv%9FSdTmQKn^@k5AJQ0!*Nr=n=USE-;hnXlg?jMl{dTp!Q!wY0hLDUiX=`A7K4R-n zKW$Uum-~F^F^Fl1_J)K%lb$2zv;{W*oV?)u&^ z^t^P4ZmLuwBp!3A62vb@qz^DLaB}vT5Y)2jS0*kAHf>|n`m8jN#E%hkA<i1w+Z_P2z1jD(dU6V`&EQPdIh3Gxjgy z4@=|`{2S+vY8u>+aw&Pa5b%6B&2nP$`-Gp9QG8^~{o=0CC~kZAUfGFV;QS*i{N^ zJnk28q{|rD-HyEwQ_7XdYz4>>?nU&S#6+YsBt=M)%b(mj1y)Io7ffZK$9pJUc%s{?9;XM(x8 z@ERc{IYlj4Lj&4AU__O00Q$-RwV{Pm6pA^w_tlFqOeG^Z%1eb-ML-tAQK7kiyH^5JOZO@+mRkAxojY^cGMGf9-uceQM-xV&BCrj@Gn1K{ zqXQ3b`C)Y6=Y45;N~0N`k|Ze7Ws({%lQyXX@pKOF=-%l?l`Dhc53AHkr|%50JNpGB zjQQ~5@i9FH+OwRRR(MS!)QhW;9w|@z1dm>%m9(Qm@SK+8k?mE&y7%gq#MO!V66$pX zD7S3aufIOqwA~1mG(8^|9-~gJfvwJ%gqhx@Foo4i>(Bf}F~H(Wmx?$$bU_H@dW+Pq zH1m4oSool787YHkO8TNb#;(68wqn$iqsM$)K}6ljaV#T#-L;>^y%N?vho)uTFk?mG z*I%ynzdqgB4TARh2z=sp35guBoyg&QdJJQnGC_}}HyvH((xz5b*A(M>f1EnSj3;2O zp2qH)hJ#6x1{&{3^)y;l<)!}h<>q}-nIbUQ+K1KZp0x`iz^O5P`XmJ-Zt=Pq24<(d z7#q8X2q101Wyiy;d^I6UnN9GsNfDxIP1z;-&iW4%Vs0K-B*H=ZL{l}DbAJN^>89#u zVq%h|2?*V@$CaCKQtqa_&0iIu2wdIyNKAT&cY$Bl6f<7jss)Q!zI{>~9`l>4ntUlhnrnGxk@s8?Z_C zR%Z|YK+OV^VseNSjr*iYKl(uH{{>2%B}YbR>V|<6kNSe)uunhDY~8vw zzZgVAQ$>U^R5|mi^&jHGx;_P}(lhLn`JAe71a`SXs8Isv*?=_eL7Tn%ZK3 z7=7&+Y&RyU?HJ7+nRUH9rvjqMXX+c67`Ztq^ETu~9qADG`4P63S@JR922e}y>|`Xb}pE!dgsph z@n5%9Z1etdaYg+(Hoz0Kdt!vfzJGFNI`1*uFz9c{UuQ6N=a|^kK;u}!Nlan{3Fu7y zwMKFGU?&JLM-+zJJrAn;{&l4TFV_`^+36o^rFeAUuth@tbXE~Ah+<16Q`Mw1HGIN5 zwFAlC+V9}HPjF;IF*-oXbOL9apmH!|plkzZGFLT0WzemJ)XiBkM4NOALZwkCV+ZUq z0u1*2{Klsv(&6$6uprXC?90NHv)7LEC6o3ni9cfK+l@CpOMNy!>Di1g@brOOjP&ky zSEhP0zB;2MOQFb%J#10yWE`4HR^nzb>H^i!XEGyo&U{=oB`3)ESv>Rzp~gzMMWvM5zzG?i?0hM5girgf{=xRvJi8SIA(w)>OcTR_=*C5b&mc{b2wktU{^KF}-KGjCg6u6y( zT~2E@jm6saip284uB#W3Lg1WL6rFcSq3F6u^~HpFCMC(y@n<_h-H?Rk!~Ow?hnys^ zAwS!D%I)vpw^4_a59b;!e_UEBxkm{>5FJh&RGqM+-^uMCyXomO8(M@2w+T14gc=yx z?pgi7P3P1k%t|RcC$kfURwJIK181sKAxbWODpE|f$H~z2id!}Z2Yez~92-)+ZrHVv z+=3L{q8egphaSmi)QtF-N;iR0Gz-6PnXZCMmzg$d=3a{sM;{VCH`DL%{-;IGvx{4? zs5gYu!^)gfkK#IwYkav~=tWqs2{&0|^HLG$J9+k=dKp!Ob3IJH-1y%sQ?S}P0c@FD zoIFmb*x@H5+KkxVnUi-_cK>r@;!O1vX*RzWM_&?kt{{c%r|iCYr)lB~nW5}=?a7Kv3`;ScLn#FfcQkP!q zpKUNRGaLEcv%;QN8_^g)y#|XH`?5JIVa+I+HaeZhNAuto%$$8|=39=edk> zy74w73n6YKTtw8v*9KyRvG??`8-BaBsbf&MSoX7md8Ab7cWOhOE|_V!;m>u`c1OIx zIjnN!4bThK98E+qH#~nHH|$yve_4ql<@ZPr-T~>zYy!tq+j|A2=k}Qb;C)C7w0j&J4rPuBx%_AS%9Q&zOS7Gj3rC^6o)iOCy&>4yFq056ydIk6Jb*b zD3{k&pFMfr7bdODN(NSTrIhn>1cz}IyQ~>A(q34JyF2ZmTOiy|lf~poX4y&aW?!Q+}&KyR=4&r61*?rP0S%laPA7gPwcNwQBtm#}+S8m&Zj1GJ8yYc~+ zqpQFAcfcLHVP zbZ%oVwaSY%Q!1U$MKbf;3#~ zl_>Lh+*KV)lH1-Z@UNdvfRX_BYC|SqKisgJbDt^#@%A~>)LHSh; zoKm4ROAWo`AMc5q03ymW@y$)XMpooH$Zuhb$$W>@Zmii+++i=gi`X8gjZy zPvvfiGrKr%!jLp}8#Zj%Tws?wOu2r+&T`h)LJBeGgXVPiexpdh75yq%!&Q`SDVV<` z38E5(w!u_Q^$_q$V4;@ zjVsRh5!Pw!ZV}!%Qeab{v}A_TpJzrcBb0}xXSGq}?LRy+fqt_|*0M;vx<)^ZgP_<6 zYis&1!Em!(@I!59VBnp7Z+E)aZqxakwlm8&98Ots<3RjhTPeOw5xWScABlSe$>xw} zt?0<40KPG0=BK*%6EA;nm8aL)MJ#s^M#}piyG>8AskH!Mi~rH^ZlS~9+j}d%OhYMi z7>~kA(ve+c_mbCOr(tIsapB;^R*H`o4X@QxwC_`FuBiP)e|no)kC@8l!f-c)dl#iO z1PS!O`j1;FI=lYYZ~m#vpWq_jKfzA_1X6knFYOKd;g5FBjPbu4wZKmOKmMnPRqYuH zLOYX>C^lmbP8|4>qt9gXmBY`TJ^Nn24d0>5fzW{(iyKK>?(xGL5ZI5`ltO)u)dbyDt~@M56UE__ zr=59dVp|!TK-?PiNjoIK{*nWyIGM0OLrf)0f$?QyBs5{nnO|-y2i06z+tIoF!(s0 zPX|1s8gmFrYuTb0yHrOm6oJ^rzv#ZMP`|sQ0FpBNQZ4@>CabK?Ha&AL_g=l@HRlpl z`|+My2gV_O@WBT%gk3(*v6BXwvJ2!pS2? z$gP{q`YrL(Ey!!eUJFyLmw+$av?%+@jwA3#qB32z#nIaQ!yH+l+_wC~>zL4S?#OUx zk;Vu4i8;9ToY)?Y0vr~0f+*~glKP~#jUj29kAv&Al$4a}@fqUDA^2}N>7hz3c`Cic z&qWVF8i^g=Fw$IcQ0Jt(%|U(Es4_h$&4V&sjy?|9BGM~x%k13ZHOotd+l@ETVC1=+ zJ@d)-mtOeF2G=YO#;L$;ImsQteClI*I0_BbikYtBHAvDa7VgsH^lCIq?_eRrFkPU` zYYt3yNR!z|iTRV?JjCgwB!W~@Tn*rvNxKs@t6i?tIrIpmAL3r5=|h~l%UXL>TDqq^ zzDOVekz`Vk%P4f-gXHof7ysT`c*`t`HQAM{N-_R-@T;~Fdsr|Wv0f!5)afvgRf~4z zxdX&pF?9f;w39?rfF~dCCgkGeBy&7cYyIJ)M6IGAyGNfcyBpZ_U3QaC$zU|WjtjbjZJ zgM(ykUcq9`L@tL->3mqmL$OAenJr{t>Tse-8T|fp7kWWU;Cy$iZ(jU{n=mc3D{HsH zR9YM3_x~W_bduTyyfS1d<}P78i#Y*E2V#`aDy}3a`TY(ZMpAdCJ|DYUjiL{m zu3+UIOi_c}n`)vHx~r01FWk?#&;-NEP*uzh&_u-5HF8(>TOKmXuZJ$y`^0NZlf#c3 z+07aw`cp@FRTK3!-H32cOL;rfs8)iNBk-L$dW8TH7`Igyvl87cbeZ_zs1frAEIUeg z7c(BE3#FV_HSyvOn@@(tld(FDPNQA3SnKe}nIdE!>?x&y(wZu8FDyu=s7Ipxbh}!P z&Pgd_k4DknNcs%2{jc<{yn^#CUc8uHV@>O57B4jPHNJOp80)y{_OYV9=&M3|g@$UK zrkwqpX&*ew6A}gQbdbu@WAGj33yVi`WFCj+8zbGxlOJ0L^O7!(e$&Q@7LC8!!>v;l z^Skz;kT%NG$nvtXvS(U79~tm#KWAZV)QLtxymi7gN{z>-e!%gMKen@xq9z@w}&rZnY-sMwbnEj4GXv}jx5q(pq-^jvL*@L_pq9)oHg=I zOVML{rmK*mML?~}AjM`R=Uq3g0Y>wrV62u*k|23TX!Y`JcW!_6>XnK8?S>rcMy1oj zpB+G6c^TS4#U8#m1&J$1NkT*}(PQ<(1pkGkEt=8>r@$d=&7B`Lc+lB7mA)M z*pyfj>OQWP9PT&_IZKEBL|sVvD;F#amXTLV73sj)9VqOxHASg_Po8!6tNsd^kYlq? zNwR+pUPr>{Qi=;X>;<>b8l*G7D(OgSH8<bDJXYrk1mtTCf_TL-pOon$a>%GrV$lhoW=-;!kGms@HM zVexzO&Y=t5pN#mC%e6e&j4Aw@mrri5kMjr9?K|+gaShMzqIrm}Tf8?B;UTX+lW;ji zCH@T6%wNmB!2FEO)Zj z>&rALPT*QCS|4&KISE;OQJDvT8Q4}fEZb@>=zdLO!6qP<6NEfMWwB^va(u;cb-VDO+K=YPd1c;^DB-hX^m_DevGxA!TivOoet|%RKj&$ zjpT(>)p&l0_xbub(Y93de4B-f!xyPwSwPcc=6zz063c*qy+=Ub?L%ApIv7}2GZhiG zM!2X=C56RYP{v}@5Sd1`kum zW5BOaN*ITL#cSsqtv-}4)^WvA&RI^7qstrjD&K{M^&$&aMfxf~XS;J1|1 zYe2Obsr?`OE#H$=rrF7K? z;uM|r(8l-PY|EjkDJipva5B0RJFw+++u9iE2AuX^HTVf%P8lvXo1`?ED9o8a+C@c< zznxlSQDO+Eq+(@19jjveSQ)J$X+DHWjvQBJXY?>#^2LN8DO?j%E&dp$qUisPffR+h sKmTH(EdRE!_5WBM{=enx3!C-IUYQ5X%QCnmm!$e~#ut&FfAjr+0^OwA4gdfE diff --git a/python/pykyber/_types.py b/python/pykyber/_types.py index 40c3ea9..578feee 100644 --- a/python/pykyber/_types.py +++ b/python/pykyber/_types.py @@ -18,6 +18,10 @@ def __repr__(self) -> str: f"shared_secret={len(self.shared_secret)} bytes)" ) + def __iter__(self): + yield self.ciphertext + yield self.shared_secret + @dataclass class Keypair: @@ -47,3 +51,7 @@ def public_key(self) -> bytes: def __repr__(self) -> str: return f"Keypair(secret_key={len(self._secret_key)} bytes, public_key={len(self._public_key)} bytes)" + + def __iter__(self): + yield self._public_key + yield self._secret_key diff --git a/python/tests/test_kyber.py b/python/tests/test_kyber.py index fb7792c..d1141eb 100644 --- a/python/tests/test_kyber.py +++ b/python/tests/test_kyber.py @@ -1506,3 +1506,67 @@ def test_performance_static_methods_kyber768(): print(f"\nKyber768 full key exchange (static methods): {elapsed/iterations*1000:.3f} ms/op ({iterations} iterations)") assert elapsed < 5.0 + + +def test_keypair_iter(): + """Test Keypair can be unpacked as tuple (public_key, secret_key).""" + keypair = pykyber.Kyber768() + pk, sk = keypair + + assert isinstance(pk, bytes) + assert isinstance(sk, bytes) + assert len(pk) == 1184 + assert len(sk) == 2400 + assert pk == keypair.public_key + assert sk == keypair.secret_key + + +def test_encapsulation_result_iter(): + """Test EncapsulationResult can be unpacked as tuple (ciphertext, shared_secret).""" + keypair = pykyber.Kyber768() + result = keypair.encapsulate() + ct, ss = result + + assert isinstance(ct, bytes) + assert isinstance(ss, bytes) + assert len(ct) == 1088 + assert len(ss) == 32 + assert ct == result.ciphertext + assert ss == result.shared_secret + + +def test_keypair_iter_all_variants(): + """Test Keypair __iter__ for all Kyber variants.""" + for cls, expected_pk_len, expected_sk_len in [ + (pykyber.Kyber512, 800, 1632), + (pykyber.Kyber768, 1184, 2400), + (pykyber.Kyber1024, 1568, 3168), + ]: + keypair = cls() + pk, sk = keypair + assert len(pk) == expected_pk_len + assert len(sk) == expected_sk_len + + +def test_encapsulation_result_iter_all_variants(): + """Test EncapsulationResult __iter__ for all Kyber variants.""" + for cls, expected_ct_len in [ + (pykyber.Kyber512, 768), + (pykyber.Kyber768, 1088), + (pykyber.Kyber1024, 1408), + ]: + keypair = cls() + result = keypair.encapsulate() + ct, ss = result + assert len(ct) == expected_ct_len + assert len(ss) == 32 + + +def test_keypair_as_tuple_in_function(): + """Test Keypair can be passed directly to functions expecting tuple.""" + pk, sk = pykyber.Kyber768() + + ciphertext, shared_secret = pykyber.Kyber768.encapsulate(pk) + decrypted = pykyber.Kyber768.decapsulate(ciphertext, sk) + + assert shared_secret == decrypted From 1a502250c5fc7e5acce9d2f13e7fe5f87acb4e66 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Wed, 25 Feb 2026 08:19:20 +0200 Subject: [PATCH 27/47] version bump --- Cargo.lock | 2 +- Cargo.toml | 2 +- pyproject.toml | 19 +++++++++++++++---- 3 files changed, 17 insertions(+), 6 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 92c189f..0bcbecb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -87,7 +87,7 @@ dependencies = [ [[package]] name = "pykyber" -version = "0.1.6" +version = "0.1.7" dependencies = [ "pyo3", "rand", diff --git a/Cargo.toml b/Cargo.toml index 86177a1..dfe21a1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pykyber" -version = "0.1.6" +version = "0.1.7" edition = "2021" [lib] diff --git a/pyproject.toml b/pyproject.toml index 4b548f9..e6be38b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,22 +4,33 @@ build-backend = "maturin" [project] name = "pykyber" -version = "0.1.6" +version = "0.1.7" description = "Kyber post-quantum key encapsulation in Rust" readme = "README.md" requires-python = ">=3.8" license = {text = "MIT"} authors = [ - {name = "Yoav Haimov"} + {name = "Yoav Haimov", email = "haimovyoav@gmail.com"} ] keywords = ["kyber", "post-quantum", "cryptography", "pqc", "key-encapsulation"] classifiers = [ - "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", "Programming Language :: Rust", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", + "Topic :: Security :: Cryptography", ] -project_urls = {Homepage = "https://github.com/Zikithezikit/pykyber"} +project_urls = { + Homepage = "https://github.com/Zikithezikit/pykyber", + Documentation = "https://github.com/Zikithezikit/pykyber#readme", + Repository = "https://github.com/Zikithezikit/pykyber", + Issues = "https://github.com/Zikithezikit/pykyber/issues", +} [tool.maturin] python-source = "python" From e26d2a3d228b447473440540d31e80b141593671 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Wed, 25 Feb 2026 08:19:20 +0200 Subject: [PATCH 28/47] version bump --- pyproject.toml | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index e6be38b..035c16b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -25,12 +25,11 @@ classifiers = [ "Operating System :: OS Independent", "Topic :: Security :: Cryptography", ] -project_urls = { - Homepage = "https://github.com/Zikithezikit/pykyber", - Documentation = "https://github.com/Zikithezikit/pykyber#readme", - Repository = "https://github.com/Zikithezikit/pykyber", - Issues = "https://github.com/Zikithezikit/pykyber/issues", -} +[project.urls] +Homepage = "https://github.com/Zikithezikit/pykyber" +Documentation = "https://github.com/Zikithezikit/pykyber#readme" +Repository = "https://github.com/Zikithezikit/pykyber" +Issues = "https://github.com/Zikithezikit/pykyber/issues" [tool.maturin] python-source = "python" From c439291d1f7653ade3484d1b3283ce0f3bfb2b6c Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Tue, 10 Mar 2026 12:54:27 +0200 Subject: [PATCH 29/47] feat: add deterministic key generation and serialization utilities --- .gitignore | 3 ++ README.md | 16 +++++++ python/pykyber/_kyber.py | 49 +++++++++++++++----- python/pykyber/_types.py | 57 ++++++++++++++++++++++- python/pykyber/_validation.py | 19 ++++++-- python/tests/test_features.py | 76 +++++++++++++++++++++++++++++++ src/lib.rs | 85 ++++++++++++++++++++++------------- 7 files changed, 260 insertions(+), 45 deletions(-) create mode 100644 python/tests/test_features.py diff --git a/.gitignore b/.gitignore index b499415..afc1e8a 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,6 @@ __pycache__/ *.so *.pyi .pytest_cache/ + +# Opencode +.opencode/ diff --git a/README.md b/README.md index b3e3863..1408f8b 100644 --- a/README.md +++ b/README.md @@ -36,6 +36,10 @@ keypair = pykyber.Kyber512() # ~AES-128 security keypair = pykyber.Kyber768() # ~AES-192 security keypair = pykyber.Kyber1024() # ~AES-256 security +# Deterministic key generation from a 64-byte seed +seed = bytes(range(64)) +keypair = pykyber.Kyber768(seed=seed) + # Access raw key bytes public_key = keypair.public_key # bytes secret_key = keypair.secret_key # bytes @@ -48,6 +52,15 @@ result = keypair.encapsulate() # result.ciphertext - bytes to send to receiver # result.shared_secret - 32 bytes shared secret +# Serialization and Utilities +hex_pk = keypair.public_key_hex # Get hex representation +b64_sk = keypair.secret_key_b64 # Get base64 representation +data = keypair.to_dict() # Get dictionary of hex keys + +# Encapsulation results also support serialization +ct_hex = result.ciphertext_hex +ss_b64 = result.shared_secret_b64 + # Or unpack directly as tuple ciphertext, shared_secret = keypair.encapsulate() # same as above @@ -61,6 +74,9 @@ result = pykyber.Kyber768.encapsulate(public_key) # Decapsulate with just ciphertext and secret key shared_secret = pykyber.Kyber768.decapsulate(ciphertext, secret_key) + +# Load a Keypair object from existing keys +keypair = pykyber.Kyber768.from_keys(public_key, secret_key) ``` ## Key Sizes diff --git a/python/pykyber/_kyber.py b/python/pykyber/_kyber.py index 404633e..91624e8 100644 --- a/python/pykyber/_kyber.py +++ b/python/pykyber/_kyber.py @@ -1,8 +1,9 @@ """Kyber post-quantum key encapsulation.""" +from typing import Optional from ._error import KyberError from ._types import EncapsulationResult, Keypair -from ._validation import _validate_encapsulate, _validate_decapsulate, _validate_keypair +from ._validation import _validate_encapsulate, _validate_decapsulate, _validate_keypair, _validate_pk class Kyber512: @@ -13,10 +14,10 @@ class Kyber512: CIPHERTEXT_SIZE = 768 SHARED_SECRET_SIZE = 32 - def __new__(cls) -> Keypair: - """Generate a new key pair.""" + def __new__(cls, seed: Optional[bytes] = None) -> Keypair: + """Generate a new key pair, optionally from a 64-byte seed.""" from . import _pykyber - pk, sk = _validate_keypair(_pykyber._keypair_512)() + pk, sk = _validate_keypair(_pykyber._keypair_512)(seed) return Keypair(sk, pk, _validate_encapsulate(_pykyber._encapsulate_512, Kyber512.PUBLIC_KEY_SIZE, "Kyber512"), _validate_decapsulate(_pykyber._decapsulate_512, Kyber512.CIPHERTEXT_SIZE, "Kyber512")) @@ -33,6 +34,15 @@ def decapsulate(ciphertext: bytes, secret_key: bytes) -> bytes: from . import _pykyber return _validate_decapsulate(_pykyber._decapsulate_512, Kyber512.CIPHERTEXT_SIZE, "Kyber512.decapsulate")(ciphertext, secret_key) + @classmethod + def from_keys(cls, public_key: bytes, secret_key: bytes) -> Keypair: + """Create a Keypair object from existing public and secret keys.""" + from . import _pykyber + _validate_pk(public_key, cls.PUBLIC_KEY_SIZE, f"{cls.__name__}.from_keys") + return Keypair(secret_key, public_key, + _validate_encapsulate(_pykyber._encapsulate_512, cls.PUBLIC_KEY_SIZE, cls.__name__), + _validate_decapsulate(_pykyber._decapsulate_512, cls.CIPHERTEXT_SIZE, cls.__name__)) + class Kyber768: """Kyber-768 key encapsulation (security ~AES-192).""" @@ -42,10 +52,10 @@ class Kyber768: CIPHERTEXT_SIZE = 1088 SHARED_SECRET_SIZE = 32 - def __new__(cls) -> Keypair: - """Generate a new key pair.""" + def __new__(cls, seed: Optional[bytes] = None) -> Keypair: + """Generate a new key pair, optionally from a 64-byte seed.""" from . import _pykyber - pk, sk = _validate_keypair(_pykyber._keypair_768)() + pk, sk = _validate_keypair(_pykyber._keypair_768)(seed) return Keypair(sk, pk, _validate_encapsulate(_pykyber._encapsulate_768, Kyber768.PUBLIC_KEY_SIZE, "Kyber768"), _validate_decapsulate(_pykyber._decapsulate_768, Kyber768.CIPHERTEXT_SIZE, "Kyber768")) @@ -62,6 +72,15 @@ def decapsulate(ciphertext: bytes, secret_key: bytes) -> bytes: from . import _pykyber return _validate_decapsulate(_pykyber._decapsulate_768, Kyber768.CIPHERTEXT_SIZE, "Kyber768.decapsulate")(ciphertext, secret_key) + @classmethod + def from_keys(cls, public_key: bytes, secret_key: bytes) -> Keypair: + """Create a Keypair object from existing public and secret keys.""" + from . import _pykyber + _validate_pk(public_key, cls.PUBLIC_KEY_SIZE, f"{cls.__name__}.from_keys") + return Keypair(secret_key, public_key, + _validate_encapsulate(_pykyber._encapsulate_768, cls.PUBLIC_KEY_SIZE, cls.__name__), + _validate_decapsulate(_pykyber._decapsulate_768, cls.CIPHERTEXT_SIZE, cls.__name__)) + class Kyber1024: """Kyber-1024 key encapsulation (security ~AES-256).""" @@ -71,10 +90,10 @@ class Kyber1024: CIPHERTEXT_SIZE = 1408 SHARED_SECRET_SIZE = 32 - def __new__(cls) -> Keypair: - """Generate a new key pair.""" + def __new__(cls, seed: Optional[bytes] = None) -> Keypair: + """Generate a new key pair, optionally from a 64-byte seed.""" from . import _pykyber - pk, sk = _validate_keypair(_pykyber._keypair_1024)() + pk, sk = _validate_keypair(_pykyber._keypair_1024)(seed) return Keypair(sk, pk, _validate_encapsulate(_pykyber._encapsulate_1024, Kyber1024.PUBLIC_KEY_SIZE, "Kyber1024"), _validate_decapsulate(_pykyber._decapsulate_1024, Kyber1024.CIPHERTEXT_SIZE, "Kyber1024")) @@ -90,3 +109,13 @@ def decapsulate(ciphertext: bytes, secret_key: bytes) -> bytes: """Decapsulate a shared secret using ciphertext and secret key (no keypair needed).""" from . import _pykyber return _validate_decapsulate(_pykyber._decapsulate_1024, Kyber1024.CIPHERTEXT_SIZE, "Kyber1024.decapsulate")(ciphertext, secret_key) + + @classmethod + def from_keys(cls, public_key: bytes, secret_key: bytes) -> Keypair: + """Create a Keypair object from existing public and secret keys.""" + from . import _pykyber + _validate_pk(public_key, cls.PUBLIC_KEY_SIZE, f"{cls.__name__}.from_keys") + return Keypair(secret_key, public_key, + _validate_encapsulate(_pykyber._encapsulate_1024, cls.PUBLIC_KEY_SIZE, cls.__name__), + _validate_decapsulate(_pykyber._decapsulate_1024, cls.CIPHERTEXT_SIZE, cls.__name__)) + diff --git a/python/pykyber/_types.py b/python/pykyber/_types.py index 578feee..6cbfc3c 100644 --- a/python/pykyber/_types.py +++ b/python/pykyber/_types.py @@ -1,7 +1,8 @@ """Kyber types and data structures.""" +import base64 from dataclasses import dataclass -from typing import Tuple, Callable +from typing import Tuple, Callable, Dict, Any @dataclass(frozen=True) @@ -11,6 +12,33 @@ class EncapsulationResult: ciphertext: bytes shared_secret: bytes + @property + def ciphertext_hex(self) -> str: + """Return the ciphertext in hex format.""" + return self.ciphertext.hex() + + @property + def shared_secret_hex(self) -> str: + """Return the shared secret in hex format.""" + return self.shared_secret.hex() + + @property + def ciphertext_b64(self) -> str: + """Return the ciphertext in base64 format.""" + return base64.b64encode(self.ciphertext).decode("utf-8") + + @property + def shared_secret_b64(self) -> str: + """Return the shared secret in base64 format.""" + return base64.b64encode(self.shared_secret).decode("utf-8") + + def to_dict(self) -> Dict[str, Any]: + """Convert result to a dictionary.""" + return { + "ciphertext": self.ciphertext_hex, + "shared_secret": self.shared_secret_hex, + } + def __repr__(self) -> str: return ( f"EncapsulationResult(" @@ -48,6 +76,33 @@ def secret_key(self) -> bytes: def public_key(self) -> bytes: """Return the raw public key bytes.""" return self._public_key + + @property + def public_key_hex(self) -> str: + """Return the public key in hex format.""" + return self._public_key.hex() + + @property + def secret_key_hex(self) -> str: + """Return the secret key in hex format.""" + return self._secret_key.hex() + + @property + def public_key_b64(self) -> str: + """Return the public key in base64 format.""" + return base64.b64encode(self._public_key).decode("utf-8") + + @property + def secret_key_b64(self) -> str: + """Return the secret key in base64 format.""" + return base64.b64encode(self._secret_key).decode("utf-8") + + def to_dict(self) -> Dict[str, Any]: + """Convert keypair to a dictionary (using hex encoding).""" + return { + "public_key": self.public_key_hex, + "secret_key": self.secret_key_hex, + } def __repr__(self) -> str: return f"Keypair(secret_key={len(self._secret_key)} bytes, public_key={len(self._public_key)} bytes)" diff --git a/python/pykyber/_validation.py b/python/pykyber/_validation.py index 8c07e41..2b078b9 100644 --- a/python/pykyber/_validation.py +++ b/python/pykyber/_validation.py @@ -1,6 +1,6 @@ """Kyber validation helpers.""" -from typing import Tuple, Callable +from typing import Tuple, Callable, Optional from ._error import KyberError @@ -15,6 +15,16 @@ def _validate_pk(pk: bytes, expected_size: int, method_name: str) -> None: ) +def _validate_seed(seed: Optional[bytes], expected_size: int = 64) -> None: + """Validate seed length.""" + if seed is not None: + actual_size = len(seed) + if actual_size != expected_size: + raise KyberError( + f"Invalid seed size: expected {expected_size} bytes, got {actual_size}." + ) + + def _validate_encapsulate(fn: Callable[[bytes], Tuple[bytes, bytes]], expected_pk_size: int, method_name: str) -> Callable[[bytes], Tuple[bytes, bytes]]: """Validate public key and call Rust encapsulate function.""" def wrapper(pk: bytes) -> Tuple[bytes, bytes]: @@ -46,11 +56,12 @@ def wrapper(ct: bytes, sk: bytes) -> bytes: return wrapper -def _validate_keypair(fn: Callable[[], Tuple[bytes, bytes]]) -> Callable[[], Tuple[bytes, bytes]]: +def _validate_keypair(fn: Callable[[Optional[bytes]], Tuple[bytes, bytes]]) -> Callable[[Optional[bytes]], Tuple[bytes, bytes]]: """Wrap a Rust keypair function to raise KyberError on failure.""" - def wrapper() -> Tuple[bytes, bytes]: + def wrapper(seed: Optional[bytes] = None) -> Tuple[bytes, bytes]: + _validate_seed(seed) try: - return fn() + return fn(seed) except Exception as e: raise KyberError(str(e)) from None return wrapper diff --git a/python/tests/test_features.py b/python/tests/test_features.py new file mode 100644 index 0000000..b0d2484 --- /dev/null +++ b/python/tests/test_features.py @@ -0,0 +1,76 @@ +import pykyber +import pytest +import base64 + + +def test_deterministic_keypair(): + """Test that the same seed produces the same keypair.""" + seed = bytes(range(64)) + + # Kyber-512 + k512_1 = pykyber.Kyber512(seed=seed) + k512_2 = pykyber.Kyber512(seed=seed) + assert k512_1.public_key == k512_2.public_key + assert k512_1.secret_key == k512_2.secret_key + + # Kyber-768 + k768_1 = pykyber.Kyber768(seed=seed) + k768_2 = pykyber.Kyber768(seed=seed) + assert k768_1.public_key == k768_2.public_key + assert k768_1.secret_key == k768_2.secret_key + + # Kyber-1024 + k1024_1 = pykyber.Kyber1024(seed=seed) + k1024_2 = pykyber.Kyber1024(seed=seed) + assert k1024_1.public_key == k1024_2.public_key + assert k1024_1.secret_key == k1024_2.secret_key + + +def test_invalid_seed_size(): + """Test that invalid seed size raises KyberError.""" + seed = b"too short" + with pytest.raises(pykyber.KyberError, match="Invalid seed size"): + pykyber.Kyber768(seed=seed) + + +def test_serialization_utilities(): + """Test the hex, base64 and dict serialization properties.""" + k768 = pykyber.Kyber768() + + # Keypair serialization + assert k768.public_key_hex == k768.public_key.hex() + assert k768.secret_key_hex == k768.secret_key.hex() + assert k768.public_key_b64 == base64.b64encode(k768.public_key).decode("utf-8") + assert k768.secret_key_b64 == base64.b64encode(k768.secret_key).decode("utf-8") + + d = k768.to_dict() + assert d["public_key"] == k768.public_key_hex + assert d["secret_key"] == k768.secret_key_hex + + # EncapsulationResult serialization + res = k768.encapsulate() + assert res.ciphertext_hex == res.ciphertext.hex() + assert res.shared_secret_hex == res.shared_secret.hex() + assert res.ciphertext_b64 == base64.b64encode(res.ciphertext).decode("utf-8") + assert res.shared_secret_b64 == base64.b64encode(res.shared_secret).decode("utf-8") + + rd = res.to_dict() + assert rd["ciphertext"] == res.ciphertext_hex + assert rd["shared_secret"] == res.shared_secret_hex + + +def test_from_keys(): + """Test creating a Keypair from existing keys.""" + k768 = pykyber.Kyber768() + pk = k768.public_key + sk = k768.secret_key + + k768_new = pykyber.Kyber768.from_keys(pk, sk) + assert k768_new.public_key == pk + assert k768_new.secret_key == sk + + # Verify it can still decapsulate + res = k768.encapsulate() + ss1 = k768.decapsulate(res.ciphertext) + ss2 = k768_new.decapsulate(res.ciphertext) + assert ss1 == ss2 diff --git a/src/lib.rs b/src/lib.rs index eeb406a..0d8274d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -15,45 +15,70 @@ fn make_kyber_error(msg: &str) -> PyErr { } #[pyfunction] -fn generate_keypair() -> PyResult<(Vec, Vec)> { - let mut rng = thread_rng(); - keypair(&mut rng) - .map(|keys| (keys.public.to_vec(), keys.secret.to_vec())) - .map_err(|e| make_kyber_error(&e.to_string())) +fn generate_keypair(seed: Option<&[u8]>) -> PyResult<(Vec, Vec)> { + if let Some(s) = seed { + if s.len() != 64 { + return Err(make_kyber_error("Seed must be 64 bytes")); + } + kyber::derive(s) + .map(|keys| (keys.public.to_vec(), keys.secret.to_vec())) + .map_err(|e| make_kyber_error(&e.to_string())) + } else { + let mut rng = thread_rng(); + keypair(&mut rng) + .map(|keys| (keys.public.to_vec(), keys.secret.to_vec())) + .map_err(|e| make_kyber_error(&e.to_string())) + } } #[pyfunction] -fn encapsulate_key(pk: &[u8]) -> PyResult<(Vec, Vec)> { +fn generate_keypair_512(seed: Option<&[u8]>) -> PyResult<(Vec, Vec)> { let mut rng = thread_rng(); - encapsulate(pk, &mut rng) - .map(|(ct, ss)| (ct.to_vec(), ss.to_vec())) + let mut pk = vec![0u8; KYBER_512_PUBLICKEYBYTES]; + let mut sk = vec![0u8; KYBER_512_SECRETKEYBYTES]; + let s_opt = if let Some(s) = seed { + if s.len() != 64 { + return Err(make_kyber_error("Seed must be 64 bytes")); + } + Some((&s[..32], &s[32..])) + } else { + None + }; + crypto_kem_keypair_512(&mut pk, &mut sk, &mut rng, s_opt) + .map(|_| (pk, sk)) .map_err(|e| make_kyber_error(&e.to_string())) } #[pyfunction] -fn decapsulate_key(ct: &[u8], sk: &[u8]) -> PyResult> { - decapsulate(ct, sk) - .map(|ss| ss.to_vec()) +fn generate_keypair_1024(seed: Option<&[u8]>) -> PyResult<(Vec, Vec)> { + let mut rng = thread_rng(); + let mut pk = vec![0u8; KYBER_1024_PUBLICKEYBYTES]; + let mut sk = vec![0u8; KYBER_1024_SECRETKEYBYTES]; + let s_opt = if let Some(s) = seed { + if s.len() != 64 { + return Err(make_kyber_error("Seed must be 64 bytes")); + } + Some((&s[..32], &s[32..])) + } else { + None + }; + crypto_kem_keypair_1024(&mut pk, &mut sk, &mut rng, s_opt) + .map(|_| (pk, sk)) .map_err(|e| make_kyber_error(&e.to_string())) } #[pyfunction] -fn generate_keypair_512() -> PyResult<(Vec, Vec)> { +fn encapsulate_key(pk: &[u8]) -> PyResult<(Vec, Vec)> { let mut rng = thread_rng(); - let mut pk = vec![0u8; KYBER_512_PUBLICKEYBYTES]; - let mut sk = vec![0u8; KYBER_512_SECRETKEYBYTES]; - crypto_kem_keypair_512(&mut pk, &mut sk, &mut rng, None) - .map(|_| (pk, sk)) + encapsulate(pk, &mut rng) + .map(|(ct, ss)| (ct.to_vec(), ss.to_vec())) .map_err(|e| make_kyber_error(&e.to_string())) } #[pyfunction] -fn generate_keypair_1024() -> PyResult<(Vec, Vec)> { - let mut rng = thread_rng(); - let mut pk = vec![0u8; KYBER_1024_PUBLICKEYBYTES]; - let mut sk = vec![0u8; KYBER_1024_SECRETKEYBYTES]; - crypto_kem_keypair_1024(&mut pk, &mut sk, &mut rng, None) - .map(|_| (pk, sk)) +fn decapsulate_key(ct: &[u8], sk: &[u8]) -> PyResult> { + decapsulate(ct, sk) + .map(|ss| ss.to_vec()) .map_err(|e| make_kyber_error(&e.to_string())) } @@ -128,8 +153,8 @@ mod _pykyber { use pyo3::prelude::*; #[pyfunction] - pub fn _generate_keypair() -> PyResult<(Vec, Vec)> { - super::generate_keypair() + pub fn _generate_keypair(seed: Option<&[u8]>) -> PyResult<(Vec, Vec)> { + super::generate_keypair(seed) } #[pyfunction] @@ -143,18 +168,18 @@ mod _pykyber { } #[pyfunction] - pub fn _keypair_512() -> PyResult<(Vec, Vec)> { - super::generate_keypair_512() + pub fn _keypair_512(seed: Option<&[u8]>) -> PyResult<(Vec, Vec)> { + super::generate_keypair_512(seed) } #[pyfunction] - pub fn _keypair_768() -> PyResult<(Vec, Vec)> { - super::generate_keypair() + pub fn _keypair_768(seed: Option<&[u8]>) -> PyResult<(Vec, Vec)> { + super::generate_keypair(seed) } #[pyfunction] - pub fn _keypair_1024() -> PyResult<(Vec, Vec)> { - super::generate_keypair_1024() + pub fn _keypair_1024(seed: Option<&[u8]>) -> PyResult<(Vec, Vec)> { + super::generate_keypair_1024(seed) } #[pyfunction] From ab9bd57f3b973433ff35220e4116f802a887d06b Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Tue, 10 Mar 2026 12:56:31 +0200 Subject: [PATCH 30/47] docs: add invalid seed size to common error cases in README --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 1408f8b..3a4088c 100644 --- a/README.md +++ b/README.md @@ -107,6 +107,7 @@ Common error cases: - **Invalid public key size**: Wrong number of bytes for the Kyber variant - **Invalid ciphertext size**: Wrong number of bytes when decapsulating - **Invalid secret key size**: Wrong number of bytes for the Kyber variant +- **Invalid seed size**: Seed must be exactly 64 bytes for deterministic generation ## Performance From 0e495e16a42ae26ef459bf76445f33f6ea71f0ca Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Tue, 10 Mar 2026 13:19:07 +0200 Subject: [PATCH 31/47] security: implement memory zeroing and harden cryptographic primitives --- Cargo.lock | 21 +++++++++ Cargo.toml | 1 + python/pykyber/_kyber.py | 2 +- python/tests/test_kyber.py | 16 +++---- src/kyber/api.rs | 5 +- src/kyber/cbd.rs | 4 ++ src/kyber/fips202.rs | 5 +- src/kyber/indcpa.rs | 56 +++++++++++++++-------- src/kyber/kem.rs | 28 ++++++++++++ src/kyber/params.rs | 19 +++++--- src/kyber/poly.rs | 67 +++++++++++++++++++++++++-- src/kyber/polyvec.rs | 94 ++++++++++++++++++++++---------------- src/kyber/symmetric.rs | 4 ++ 13 files changed, 243 insertions(+), 79 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0bcbecb..9f5ef5a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -92,6 +92,7 @@ dependencies = [ "pyo3", "rand", "rand_core", + "zeroize", ] [[package]] @@ -254,3 +255,23 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zeroize" +version = "1.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0" +dependencies = [ + "zeroize_derive", +] + +[[package]] +name = "zeroize_derive" +version = "1.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] diff --git a/Cargo.toml b/Cargo.toml index dfe21a1..2e922ca 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,6 +9,7 @@ crate-type = ["lib", "cdylib"] [dependencies] pyo3 = { version = "0.27.0", features = ["extension-module", "abi3-py38"] } +zeroize = { version = "1.7", features = ["derive"] } rand = "0.8" rand_core = "0.6" diff --git a/python/pykyber/_kyber.py b/python/pykyber/_kyber.py index 91624e8..877a06d 100644 --- a/python/pykyber/_kyber.py +++ b/python/pykyber/_kyber.py @@ -87,7 +87,7 @@ class Kyber1024: PUBLIC_KEY_SIZE = 1568 SECRET_KEY_SIZE = 3168 - CIPHERTEXT_SIZE = 1408 + CIPHERTEXT_SIZE = 1568 SHARED_SECRET_SIZE = 32 def __new__(cls, seed: Optional[bytes] = None) -> Keypair: diff --git a/python/tests/test_kyber.py b/python/tests/test_kyber.py index d1141eb..1b787d3 100644 --- a/python/tests/test_kyber.py +++ b/python/tests/test_kyber.py @@ -41,7 +41,7 @@ def test_kyber1024_new_api(): assert len(keypair.public_key) == 1568 assert len(keypair.secret_key) == 3168 - assert len(result.ciphertext) == 1408 + assert len(result.ciphertext) == 1568 assert len(result.shared_secret) == 32 assert result.shared_secret == shared_secret2 @@ -451,7 +451,7 @@ def test_encapsulate_static_method_kyber1024(): result = pykyber.Kyber1024.encapsulate(pk) assert isinstance(result, pykyber._kyber.EncapsulationResult) - assert len(result.ciphertext) == 1408 + assert len(result.ciphertext) == 1568 assert len(result.shared_secret) == 32 ss = keypair.decapsulate(result.ciphertext) @@ -562,7 +562,7 @@ def test_kyber1024_invalid_ciphertext_length(): def test_kyber1024_invalid_secret_key_length(): """Test Kyber1024 with invalid secret key length.""" - ct = bytes(1408) + ct = bytes(1568) with pytest.raises(pykyber.KyberError) as exc_info: pykyber._decapsulate_1024(ct, b"short") assert "Invalid input for 'sk'" in str(exc_info.value) @@ -867,7 +867,7 @@ def test_all_zero_public_key_1024(): """Test encapsulation with all-zero public key (Kyber1024).""" zero_pk = bytes(1568) ct, ss = pykyber._encapsulate_1024(zero_pk) - assert len(ct) == 1408 + assert len(ct) == 1568 assert len(ss) == 32 @@ -891,7 +891,7 @@ def test_all_ones_public_key_1024(): """Test encapsulation with all-ones public key (Kyber1024).""" ones_pk = bytes([255] * 1568) ct, ss = pykyber._encapsulate_1024(ones_pk) - assert len(ct) == 1408 + assert len(ct) == 1568 assert len(ss) == 32 @@ -922,7 +922,7 @@ def test_decapsulate_with_all_zero_ciphertext_768(): def test_decapsulate_with_all_zero_ciphertext_1024(): """Test decapsulation with all-zero ciphertext (Kyber1024).""" pk, sk = pykyber._keypair_1024() - zero_ct = bytes(1408) + zero_ct = bytes(1568) ss = pykyber._decapsulate_1024(zero_ct, sk) assert len(ss) == 32 @@ -1231,7 +1231,7 @@ def test_static_decapsulate_invalid_ciphertext_length_kyber1024(): def test_static_decapsulate_invalid_secret_key_length_kyber1024(): """Test static decapsulate with invalid secret key length (Kyber1024).""" - ct = bytes(1408) + ct = bytes(1568) with pytest.raises(pykyber.KyberError) as exc_info: pykyber.Kyber1024.decapsulate(ct, b"short") assert "Invalid input for 'sk'" in str(exc_info.value) @@ -1553,7 +1553,7 @@ def test_encapsulation_result_iter_all_variants(): for cls, expected_ct_len in [ (pykyber.Kyber512, 768), (pykyber.Kyber768, 1088), - (pykyber.Kyber1024, 1408), + (pykyber.Kyber1024, 1568), ]: keypair = cls() result = keypair.encapsulate() diff --git a/src/kyber/api.rs b/src/kyber/api.rs index df04cff..2cc0997 100644 --- a/src/kyber/api.rs +++ b/src/kyber/api.rs @@ -50,7 +50,10 @@ pub fn decapsulate(ct: &[u8], sk: &[u8]) -> Decapsulated { Ok(ss) } -#[derive(Copy, Clone, Debug, Eq, PartialEq)] +use zeroize::Zeroize; + +#[derive(Clone, Debug, Eq, PartialEq, Zeroize)] +#[zeroize(drop)] pub struct Keypair { pub public: PublicKey, pub secret: SecretKey, diff --git a/src/kyber/cbd.rs b/src/kyber/cbd.rs index 47e680d..b820b5a 100644 --- a/src/kyber/cbd.rs +++ b/src/kyber/cbd.rs @@ -49,6 +49,10 @@ pub fn poly_cbd_eta1(r: &mut Poly, buf: &[u8]) { cbd2(r, buf) } +pub fn poly_cbd_eta1_512(r: &mut Poly, buf: &[u8]) { + cbd3(r, buf) +} + pub fn poly_cbd_eta2(r: &mut Poly, buf: &[u8]) { cbd2(r, buf) } diff --git a/src/kyber/fips202.rs b/src/kyber/fips202.rs index 9bde2a5..0d5ad87 100644 --- a/src/kyber/fips202.rs +++ b/src/kyber/fips202.rs @@ -6,7 +6,10 @@ const SHA3_256_RATE: usize = 136; const SHA3_512_RATE: usize = 72; const NROUNDS: usize = 24; -#[derive(Copy, Clone)] +use zeroize::Zeroize; + +#[derive(Clone, Zeroize)] +#[zeroize(drop)] pub struct KeccakState { pub s: [u64; 25], pub pos: usize, diff --git a/src/kyber/indcpa.rs b/src/kyber/indcpa.rs index 403f14c..be3748a 100644 --- a/src/kyber/indcpa.rs +++ b/src/kyber/indcpa.rs @@ -6,6 +6,7 @@ use super::symmetric::{ hash_sha3_512, xof_absorb_bytes, xof_squeeze_blocks, XofState, XOF_BLOCKBYTES, }; use rand_core::{CryptoRng, RngCore}; +use zeroize::Zeroize; fn pack_pk(r: &mut [u8], pk: &mut Polyvec, seed: &[u8]) { const END: usize = KYBER_SYMBYTES + KYBER_POLYVECBYTES; @@ -28,7 +29,7 @@ fn unpack_sk(sk: &mut Polyvec, packedsk: &[u8]) { } fn pack_ciphertext(r: &mut [u8], b: &mut Polyvec, v: Poly) { - polyvec_compress(r, *b); + polyvec_compress(r, b.clone()); poly_compress(&mut r[KYBER_POLYVECCOMPRESSEDBYTES..], v); } @@ -108,7 +109,7 @@ pub fn indcpa_keypair( where R: CryptoRng + RngCore, { - let mut a = [Polyvec::new(); KYBER_K]; + let mut a: [Polyvec; KYBER_K] = core::array::from_fn(|_| Polyvec::new()); let (mut e, mut pkpv, mut skpv) = (Polyvec::new(), Polyvec::new(), Polyvec::new()); let mut nonce = 0u8; let mut buf = [0u8; 2 * KYBER_SYMBYTES]; @@ -146,11 +147,15 @@ where pack_sk(sk, &mut skpv); pack_pk(pk, &mut pkpv, publicseed); + + a.zeroize(); + buf.zeroize(); + randbuf.zeroize(); Ok(()) } pub fn indcpa_enc(c: &mut [u8], m: &[u8], pk: &[u8], coins: &[u8]) { - let mut at = [Polyvec::new(); KYBER_K]; + let mut at: [Polyvec; KYBER_K] = core::array::from_fn(|_| Polyvec::new()); let (mut sp, mut pkpv, mut ep, mut b) = ( Polyvec::new(), Polyvec::new(), @@ -191,7 +196,8 @@ pub fn indcpa_enc(c: &mut [u8], m: &[u8], pk: &[u8], coins: &[u8]) { polyvec_reduce(&mut b); poly_reduce(&mut v); - pack_ciphertext(c, &mut b, v); + pack_ciphertext(c, &mut b, v.clone()); + seed.zeroize(); } pub fn indcpa_dec(m: &mut [u8], c: &[u8], sk: &[u8]) { @@ -224,7 +230,7 @@ fn unpack_pk_512(pk: &mut Polyvec512, seed: &mut [u8], packedpk: &[u8]) { } fn pack_ciphertext_512(r: &mut [u8], b: &mut Polyvec512, v: Poly) { - polyvec_compress_512(r, *b); + polyvec_compress_512(r, b.clone()); poly_compress(&mut r[KYBER_512_POLYVECCOMPRESSEDBYTES..], v); } @@ -285,7 +291,7 @@ where R: CryptoRng + RngCore, { const K: usize = KYBER_512_K; - let mut a = [Polyvec512::new(); K]; + let mut a: [Polyvec512; K] = core::array::from_fn(|_| Polyvec512::new()); let (mut e, mut pkpv, mut skpv) = (Polyvec512::new(), Polyvec512::new(), Polyvec512::new()); let mut nonce = 0u8; let mut buf = [0u8; 2 * KYBER_SYMBYTES]; @@ -303,11 +309,11 @@ where gen_a_512(&mut a, publicseed); for i in 0..K { - poly_getnoise_eta1(&mut skpv.vec[i], noiseseed, nonce); + poly_getnoise_eta1_512(&mut skpv.vec[i], noiseseed, nonce); nonce += 1; } for i in 0..K { - poly_getnoise_eta1(&mut e.vec[i], noiseseed, nonce); + poly_getnoise_eta1_512(&mut e.vec[i], noiseseed, nonce); nonce += 1; } @@ -323,12 +329,16 @@ where polyvec_tobytes_512(sk, &skpv); pack_pk_512(pk, &mut pkpv, publicseed); + + a.zeroize(); + buf.zeroize(); + randbuf.zeroize(); Ok(()) } pub fn indcpa_enc_512(c: &mut [u8], m: &[u8], pk: &[u8], coins: &[u8]) { const K: usize = KYBER_512_K; - let mut at = [Polyvec512::new(); K]; + let mut at: [Polyvec512; K] = core::array::from_fn(|_| Polyvec512::new()); let (mut sp, mut pkpv, mut ep, mut b) = ( Polyvec512::new(), Polyvec512::new(), @@ -344,14 +354,14 @@ pub fn indcpa_enc_512(c: &mut [u8], m: &[u8], pk: &[u8], coins: &[u8]) { gen_at_512(&mut at, &seed); for i in 0..K { - poly_getnoise_eta1(&mut sp.vec[i], coins, nonce); + poly_getnoise_eta1_512(&mut sp.vec[i], coins, nonce); nonce += 1; } for i in 0..K { - poly_getnoise_eta2(&mut ep.vec[i], coins, nonce); + poly_getnoise_eta2_512(&mut ep.vec[i], coins, nonce); nonce += 1; } - poly_getnoise_eta2(&mut epp, coins, nonce); + poly_getnoise_eta2_512(&mut epp, coins, nonce); polyvec_ntt_512(&mut sp); @@ -369,7 +379,9 @@ pub fn indcpa_enc_512(c: &mut [u8], m: &[u8], pk: &[u8], coins: &[u8]) { polyvec_reduce_512(&mut b); poly_reduce(&mut v); - pack_ciphertext_512(c, &mut b, v); + pack_ciphertext_512(c, &mut b, v.clone()); + at.zeroize(); + seed.zeroize(); } pub fn indcpa_dec_512(m: &mut [u8], c: &[u8], sk: &[u8]) { @@ -402,13 +414,13 @@ fn unpack_pk_1024(pk: &mut Polyvec1024, seed: &mut [u8], packedpk: &[u8]) { } fn pack_ciphertext_1024(r: &mut [u8], b: &mut Polyvec1024, v: Poly) { - polyvec_compress_1024(r, *b); - poly_compress(&mut r[KYBER_1024_POLYVECCOMPRESSEDBYTES..], v); + polyvec_compress_1024(r, b.clone()); + poly_compress_1024(&mut r[KYBER_1024_POLYVECCOMPRESSEDBYTES..], v); } fn unpack_ciphertext_1024(b: &mut Polyvec1024, v: &mut Poly, c: &[u8]) { polyvec_decompress_1024(b, c); - poly_decompress(v, &c[KYBER_1024_POLYVECCOMPRESSEDBYTES..]); + poly_decompress_1024(v, &c[KYBER_1024_POLYVECCOMPRESSEDBYTES..]); } fn gen_matrix_1024(a: &mut [Polyvec1024], seed: &[u8], transposed: bool) { @@ -463,7 +475,7 @@ where R: CryptoRng + RngCore, { const K: usize = KYBER_1024_K; - let mut a = [Polyvec1024::new(); K]; + let mut a: [Polyvec1024; K] = core::array::from_fn(|_| Polyvec1024::new()); let (mut e, mut pkpv, mut skpv) = (Polyvec1024::new(), Polyvec1024::new(), Polyvec1024::new()); let mut nonce = 0u8; let mut buf = [0u8; 2 * KYBER_SYMBYTES]; @@ -501,12 +513,16 @@ where polyvec_tobytes_1024(sk, &skpv); pack_pk_1024(pk, &mut pkpv, publicseed); + + a.zeroize(); + buf.zeroize(); + randbuf.zeroize(); Ok(()) } pub fn indcpa_enc_1024(c: &mut [u8], m: &[u8], pk: &[u8], coins: &[u8]) { const K: usize = KYBER_1024_K; - let mut at = [Polyvec1024::new(); K]; + let mut at: [Polyvec1024; K] = core::array::from_fn(|_| Polyvec1024::new()); let (mut sp, mut pkpv, mut ep, mut b) = ( Polyvec1024::new(), Polyvec1024::new(), @@ -547,7 +563,9 @@ pub fn indcpa_enc_1024(c: &mut [u8], m: &[u8], pk: &[u8], coins: &[u8]) { polyvec_reduce_1024(&mut b); poly_reduce(&mut v); - pack_ciphertext_1024(c, &mut b, v); + pack_ciphertext_1024(c, &mut b, v.clone()); + at.zeroize(); + seed.zeroize(); } pub fn indcpa_dec_1024(m: &mut [u8], c: &[u8], sk: &[u8]) { diff --git a/src/kyber/kem.rs b/src/kyber/kem.rs index 8e243a6..cbcfcd2 100644 --- a/src/kyber/kem.rs +++ b/src/kyber/kem.rs @@ -7,6 +7,7 @@ use super::params::*; use super::symmetric::{hash_sha3_256, hash_sha3_512, shake256_kdf}; use super::verify::{cmov, verify}; use rand_core::{CryptoRng, RngCore}; +use zeroize::Zeroize; pub fn crypto_kem_keypair( pk: &mut [u8], @@ -62,6 +63,10 @@ where hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_CIPHERTEXTBYTES); shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); + + kr.zeroize(); + buf.zeroize(); + randbuf.zeroize(); Ok(()) } @@ -103,6 +108,11 @@ pub fn crypto_kem_dec(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> Result<(), KyberEr hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_CIPHERTEXTBYTES); cmov(&mut kr, &sk[END..], KYBER_SYMBYTES, fail); shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); + + buf.zeroize(); + kr.zeroize(); + cmp.zeroize(); + pk.zeroize(); Ok(()) } @@ -161,6 +171,10 @@ where hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_512_CIPHERTEXTBYTES); shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); + + kr.zeroize(); + buf.zeroize(); + randbuf.zeroize(); Ok(()) } @@ -202,6 +216,11 @@ pub fn crypto_kem_dec_512(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> Result<(), Kyb hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_512_CIPHERTEXTBYTES); cmov(&mut kr, &sk[END..], KYBER_SYMBYTES, fail); shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); + + buf.zeroize(); + kr.zeroize(); + cmp.zeroize(); + pk.zeroize(); Ok(()) } @@ -260,6 +279,10 @@ where hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_1024_CIPHERTEXTBYTES); shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); + + kr.zeroize(); + buf.zeroize(); + randbuf.zeroize(); Ok(()) } @@ -301,5 +324,10 @@ pub fn crypto_kem_dec_1024(ss: &mut [u8], ct: &[u8], sk: &[u8]) -> Result<(), Ky hash_sha3_256(&mut kr[KYBER_SYMBYTES..], ct, KYBER_1024_CIPHERTEXTBYTES); cmov(&mut kr, &sk[END..], KYBER_SYMBYTES, fail); shake256_kdf(ss, &kr, 2 * KYBER_SYMBYTES); + + buf.zeroize(); + kr.zeroize(); + cmp.zeroize(); + pk.zeroize(); Ok(()) } diff --git a/src/kyber/params.rs b/src/kyber/params.rs index 1c5dd1d..77ccc44 100644 --- a/src/kyber/params.rs +++ b/src/kyber/params.rs @@ -25,40 +25,45 @@ pub const KYBER_SECRETKEYBYTES: usize = KYBER_INDCPA_SECRETKEYBYTES + KYBER_INDCPA_PUBLICKEYBYTES + 2 * KYBER_SYMBYTES; pub const KYBER_CIPHERTEXTBYTES: usize = KYBER_INDCPA_BYTES; -// Kyber-512 constants (k=2) +// Kyber-512 constants (k=2, du=10, dv=4, eta1=3, eta2=2) pub const KYBER_512_K: usize = 2; +pub const KYBER_512_ETA1: usize = 3; +pub const KYBER_512_ETA2: usize = 2; pub const KYBER_512_POLYVECBYTES: usize = KYBER_512_K * KYBER_POLYBYTES; pub const KYBER_512_POLYVECCOMPRESSEDBYTES: usize = KYBER_512_K * 320; +pub const KYBER_512_POLYCOMPRESSEDBYTES: usize = 128; pub const KYBER_512_INDCPA_PUBLICKEYBYTES: usize = KYBER_512_POLYVECBYTES + KYBER_SYMBYTES; pub const KYBER_512_INDCPA_SECRETKEYBYTES: usize = KYBER_512_POLYVECBYTES; pub const KYBER_512_INDCPA_BYTES: usize = - KYBER_512_POLYVECCOMPRESSEDBYTES + KYBER_POLYCOMPRESSEDBYTES; + KYBER_512_POLYVECCOMPRESSEDBYTES + KYBER_512_POLYCOMPRESSEDBYTES; pub const KYBER_512_PUBLICKEYBYTES: usize = KYBER_512_INDCPA_PUBLICKEYBYTES; pub const KYBER_512_SECRETKEYBYTES: usize = KYBER_512_INDCPA_SECRETKEYBYTES + KYBER_512_INDCPA_PUBLICKEYBYTES + 2 * KYBER_SYMBYTES; pub const KYBER_512_CIPHERTEXTBYTES: usize = KYBER_512_INDCPA_BYTES; -// Kyber-768 constants (k=3) +// Kyber-768 constants (k=3, du=10, dv=4) pub const KYBER_768_K: usize = 3; pub const KYBER_768_POLYVECBYTES: usize = KYBER_768_K * KYBER_POLYBYTES; pub const KYBER_768_POLYVECCOMPRESSEDBYTES: usize = KYBER_768_K * 320; +pub const KYBER_768_POLYCOMPRESSEDBYTES: usize = 128; pub const KYBER_768_INDCPA_PUBLICKEYBYTES: usize = KYBER_768_POLYVECBYTES + KYBER_SYMBYTES; pub const KYBER_768_INDCPA_SECRETKEYBYTES: usize = KYBER_768_POLYVECBYTES; pub const KYBER_768_INDCPA_BYTES: usize = - KYBER_768_POLYVECCOMPRESSEDBYTES + KYBER_POLYCOMPRESSEDBYTES; + KYBER_768_POLYVECCOMPRESSEDBYTES + KYBER_768_POLYCOMPRESSEDBYTES; pub const KYBER_768_PUBLICKEYBYTES: usize = KYBER_768_INDCPA_PUBLICKEYBYTES; pub const KYBER_768_SECRETKEYBYTES: usize = KYBER_768_INDCPA_SECRETKEYBYTES + KYBER_768_INDCPA_PUBLICKEYBYTES + 2 * KYBER_SYMBYTES; pub const KYBER_768_CIPHERTEXTBYTES: usize = KYBER_768_INDCPA_BYTES; -// Kyber-1024 constants (k=4) +// Kyber-1024 constants (k=4, du=11, dv=5) pub const KYBER_1024_K: usize = 4; pub const KYBER_1024_POLYVECBYTES: usize = KYBER_1024_K * KYBER_POLYBYTES; -pub const KYBER_1024_POLYVECCOMPRESSEDBYTES: usize = KYBER_1024_K * 320; +pub const KYBER_1024_POLYVECCOMPRESSEDBYTES: usize = KYBER_1024_K * 352; +pub const KYBER_1024_POLYCOMPRESSEDBYTES: usize = 160; pub const KYBER_1024_INDCPA_PUBLICKEYBYTES: usize = KYBER_1024_POLYVECBYTES + KYBER_SYMBYTES; pub const KYBER_1024_INDCPA_SECRETKEYBYTES: usize = KYBER_1024_POLYVECBYTES; pub const KYBER_1024_INDCPA_BYTES: usize = - KYBER_1024_POLYVECCOMPRESSEDBYTES + KYBER_POLYCOMPRESSEDBYTES; + KYBER_1024_POLYVECCOMPRESSEDBYTES + KYBER_1024_POLYCOMPRESSEDBYTES; pub const KYBER_1024_PUBLICKEYBYTES: usize = KYBER_1024_INDCPA_PUBLICKEYBYTES; pub const KYBER_1024_SECRETKEYBYTES: usize = KYBER_1024_INDCPA_SECRETKEYBYTES + KYBER_1024_INDCPA_PUBLICKEYBYTES + 2 * KYBER_SYMBYTES; diff --git a/src/kyber/poly.rs b/src/kyber/poly.rs index 72b1099..babcad7 100644 --- a/src/kyber/poly.rs +++ b/src/kyber/poly.rs @@ -1,11 +1,15 @@ use super::cbd::poly_cbd_eta1; +use super::cbd::poly_cbd_eta1_512; use super::cbd::poly_cbd_eta2; use super::ntt::{base_multiply, ntt_forward, ntt_inverse, ZETAS}; use super::params::*; use super::reduce::{barrett_reduce, montgomery_reduce}; use super::symmetric::shake256_prf_expand; -#[derive(Clone, Copy)] +use zeroize::Zeroize; + +#[derive(Clone, Zeroize)] +#[zeroize(drop)] pub struct Poly { pub coeffs: [i16; KYBER_N], } @@ -33,7 +37,8 @@ pub fn poly_compress(r: &mut [u8], a: Poly) { for j in 0..8 { u = a.coeffs[8 * i + j]; u += (u >> 15) & KYBER_Q as i16; - t[j] = (((((u as u16) << 4) + KYBER_Q as u16 / 2) / KYBER_Q as u16) & 15) as u8; + let d = (((u as u32) << 4) + 1664) as u64; + t[j] = (((d * 10321345) >> 35) & 15) as u8; } r[k] = t[0] | (t[1] << 4); r[k + 1] = t[2] | (t[3] << 4); @@ -43,6 +48,27 @@ pub fn poly_compress(r: &mut [u8], a: Poly) { } } +pub fn poly_compress_1024(r: &mut [u8], a: Poly) { + let mut t = [0u8; 8]; + let mut k = 0usize; + let mut u: i16; + + for i in 0..KYBER_N / 8 { + for j in 0..8 { + u = a.coeffs[8 * i + j]; + u += (u >> 15) & KYBER_Q as i16; + let d = (((u as u32) << 5) + 1664) as u64; + t[j] = (((d * 10321345) >> 35) & 31) as u8; + } + r[k] = t[0] | (t[1] << 5); + r[k + 1] = (t[1] >> 3) | (t[2] << 2) | (t[3] << 7); + r[k + 2] = (t[3] >> 1) | (t[4] << 4); + r[k + 3] = (t[4] >> 4) | (t[5] << 1) | (t[6] << 6); + r[k + 4] = (t[6] >> 2) | (t[7] << 3); + k += 5; + } +} + pub fn poly_decompress(r: &mut Poly, a: &[u8]) { let mut idx = 0usize; for i in 0..KYBER_N / 2 { @@ -52,6 +78,26 @@ pub fn poly_decompress(r: &mut Poly, a: &[u8]) { } } +pub fn poly_decompress_1024(r: &mut Poly, a: &[u8]) { + let mut idx = 0usize; + for i in 0..KYBER_N / 8 { + r.coeffs[8 * i + 0] = ((((a[idx + 0] & 31) as usize * KYBER_Q) + 16) >> 5) as i16; + r.coeffs[8 * i + 1] = + (((((a[idx + 0] >> 5) | ((a[idx + 1] & 3) << 3)) as usize * KYBER_Q) + 16) >> 5) as i16; + r.coeffs[8 * i + 2] = (((((a[idx + 1] >> 2) & 31) as usize * KYBER_Q) + 16) >> 5) as i16; + r.coeffs[8 * i + 3] = + (((((a[idx + 1] >> 7) | ((a[idx + 2] & 15) << 1)) as usize * KYBER_Q) + 16) >> 5) + as i16; + r.coeffs[8 * i + 4] = + (((((a[idx + 2] >> 4) | ((a[idx + 3] & 1) << 4)) as usize * KYBER_Q) + 16) >> 5) as i16; + r.coeffs[8 * i + 5] = (((((a[idx + 3] >> 1) & 31) as usize * KYBER_Q) + 16) >> 5) as i16; + r.coeffs[8 * i + 6] = + (((((a[idx + 3] >> 6) | ((a[idx + 4] & 7) << 2)) as usize * KYBER_Q) + 16) >> 5) as i16; + r.coeffs[8 * i + 7] = ((((a[idx + 4] >> 3) as usize * KYBER_Q) + 16) >> 5) as i16; + idx += 5; + } +} + pub fn poly_tobytes(r: &mut [u8], a: Poly) { let (mut t0, mut t1); @@ -82,6 +128,13 @@ pub fn poly_getnoise_eta1(r: &mut Poly, seed: &[u8], nonce: u8) { poly_cbd_eta1(r, &buf); } +pub fn poly_getnoise_eta1_512(r: &mut Poly, seed: &[u8], nonce: u8) { + const LENGTH: usize = KYBER_512_ETA1 * KYBER_N / 4; + let mut buf = [0u8; LENGTH]; + shake256_prf_expand(&mut buf, LENGTH, seed, nonce); + poly_cbd_eta1_512(r, &buf); +} + pub fn poly_getnoise_eta2(r: &mut Poly, seed: &[u8], nonce: u8) { const LENGTH: usize = KYBER_ETA2 * KYBER_N / 4; let mut buf = [0u8; LENGTH]; @@ -89,6 +142,13 @@ pub fn poly_getnoise_eta2(r: &mut Poly, seed: &[u8], nonce: u8) { poly_cbd_eta2(r, &buf); } +pub fn poly_getnoise_eta2_512(r: &mut Poly, seed: &[u8], nonce: u8) { + const LENGTH: usize = KYBER_512_ETA2 * KYBER_N / 4; + let mut buf = [0u8; LENGTH]; + shake256_prf_expand(&mut buf, LENGTH, seed, nonce); + poly_cbd_eta2(r, &buf); +} + pub fn poly_ntt(r: &mut Poly) { ntt_forward(&mut r.coeffs); poly_reduce(r); @@ -159,7 +219,8 @@ pub fn poly_tomsg(msg: &mut [u8], a: Poly) { for j in 0..8 { t = a.coeffs[8 * i + j]; t += (t >> 15) & KYBER_Q as i16; - t = (((t << 1) + KYBER_Q as i16 / 2) / KYBER_Q as i16) & 1; + let d = (((t as u32) << 1) + 1664) as u64; + t = (((d * 10321345) >> 35) & 1) as i16; msg[i] |= (t << j) as u8; } } diff --git a/src/kyber/polyvec.rs b/src/kyber/polyvec.rs index 1bbdcb8..92712d7 100644 --- a/src/kyber/polyvec.rs +++ b/src/kyber/polyvec.rs @@ -2,7 +2,10 @@ use super::params::*; use super::poly::*; -#[derive(Clone, Copy)] +use zeroize::Zeroize; + +#[derive(Clone, Zeroize)] +#[zeroize(drop)] pub struct Polyvec512 { pub vec: [Poly; KYBER_512_K], } @@ -10,7 +13,7 @@ pub struct Polyvec512 { impl Polyvec512 { pub fn new() -> Self { Polyvec512 { - vec: [Poly::new(); KYBER_512_K], + vec: core::array::from_fn(|_| Poly::new()), } } } @@ -21,7 +24,8 @@ impl Default for Polyvec512 { } } -#[derive(Clone, Copy)] +#[derive(Clone, Zeroize)] +#[zeroize(drop)] pub struct Polyvec768 { pub vec: [Poly; KYBER_768_K], } @@ -29,7 +33,7 @@ pub struct Polyvec768 { impl Polyvec768 { pub fn new() -> Self { Polyvec768 { - vec: [Poly::new(); KYBER_768_K], + vec: core::array::from_fn(|_| Poly::new()), } } } @@ -40,7 +44,8 @@ impl Default for Polyvec768 { } } -#[derive(Clone, Copy)] +#[derive(Clone, Zeroize)] +#[zeroize(drop)] pub struct Polyvec1024 { pub vec: [Poly; KYBER_1024_K], } @@ -48,7 +53,7 @@ pub struct Polyvec1024 { impl Polyvec1024 { pub fn new() -> Self { Polyvec1024 { - vec: [Poly::new(); KYBER_1024_K], + vec: core::array::from_fn(|_| Poly::new()), } } } @@ -59,7 +64,8 @@ impl Default for Polyvec1024 { } } -#[derive(Clone, Copy)] +#[derive(Clone, Zeroize)] +#[zeroize(drop)] pub struct Polyvec { pub vec: [Poly; KYBER_K], } @@ -67,7 +73,7 @@ pub struct Polyvec { impl Polyvec { pub fn new() -> Self { Polyvec { - vec: [Poly::new(); KYBER_K], + vec: core::array::from_fn(|_| Poly::new()), } } } @@ -87,8 +93,8 @@ pub fn polyvec_compress_512(r: &mut [u8], a: Polyvec512) { for k in 0..4 { t[k] = a.vec[i].coeffs[4 * j + k] as u16; t[k] = t[k].wrapping_add((((t[k] as i16) >> 15) & KYBER_Q as i16) as u16); - t[k] = (((((t[k] as u32) << 10) + KYBER_Q as u32 / 2) / KYBER_Q as u32) & 0x3ff) - as u16; + let d = (((t[k] as u32) << 10) + 1664) as u64; + t[k] = (((d * 10321345) >> 35) & 0x3ff) as u16; } r[idx + 0] = (t[0] >> 0) as u8; r[idx + 1] = ((t[0] >> 8) | (t[1] << 2)) as u8; @@ -106,7 +112,7 @@ pub fn polyvec_decompress_512(r: &mut Polyvec512, a: &[u8]) { const K: usize = KYBER_512_K; for i in 0..K { for j in 0..KYBER_N / 4 { - t[0] = (a[idx + 0] >> 0) as u16 | (a[idx + 1] as u16) << 8; + t[0] = (a[idx + 0] as u16) | (a[idx + 1] as u16) << 8; t[1] = (a[idx + 1] >> 2) as u16 | (a[idx + 2] as u16) << 6; t[2] = (a[idx + 2] >> 4) as u16 | (a[idx + 3] as u16) << 4; t[3] = (a[idx + 3] >> 6) as u16 | (a[idx + 4] as u16) << 2; @@ -123,7 +129,7 @@ pub fn polyvec_decompress_512(r: &mut Polyvec512, a: &[u8]) { pub fn polyvec_tobytes_512(r: &mut [u8], a: &Polyvec512) { const K: usize = KYBER_512_K; for i in 0..K { - poly_tobytes(&mut r[i * KYBER_POLYBYTES..], a.vec[i]); + poly_tobytes(&mut r[i * KYBER_POLYBYTES..], a.vec[i].clone()); } } @@ -174,42 +180,52 @@ pub fn polyvec_add_512(r: &mut Polyvec512, b: &Polyvec512) { } pub fn polyvec_compress_1024(r: &mut [u8], a: Polyvec1024) { - let mut t = [0u16; 4]; + let mut t = [0u16; 8]; let mut idx = 0usize; const K: usize = KYBER_1024_K; for i in 0..K { - for j in 0..KYBER_N / 4 { - for k in 0..4 { - t[k] = a.vec[i].coeffs[4 * j + k] as u16; + for j in 0..KYBER_N / 8 { + for k in 0..8 { + t[k] = a.vec[i].coeffs[8 * j + k] as u16; t[k] = t[k].wrapping_add((((t[k] as i16) >> 15) & KYBER_Q as i16) as u16); - t[k] = (((((t[k] as u32) << 10) + KYBER_Q as u32 / 2) / KYBER_Q as u32) & 0x3ff) - as u16; + let d = (((t[k] as u32) << 11) + 1664) as u64; + t[k] = (((d * 10321345) >> 35) & 0x7ff) as u16; } r[idx + 0] = (t[0] >> 0) as u8; - r[idx + 1] = ((t[0] >> 8) | (t[1] << 2)) as u8; - r[idx + 2] = ((t[1] >> 6) | (t[2] << 4)) as u8; - r[idx + 3] = ((t[2] >> 4) | (t[3] << 6)) as u8; - r[idx + 4] = (t[3] >> 2) as u8; - idx += 5; + r[idx + 1] = ((t[0] >> 8) | (t[1] << 3)) as u8; + r[idx + 2] = ((t[1] >> 5) | (t[2] << 6)) as u8; + r[idx + 3] = (t[2] >> 2) as u8; + r[idx + 4] = ((t[2] >> 10) | (t[3] << 1)) as u8; + r[idx + 5] = ((t[3] >> 7) | (t[4] << 4)) as u8; + r[idx + 6] = ((t[4] >> 4) | (t[5] << 7)) as u8; + r[idx + 7] = (t[5] >> 1) as u8; + r[idx + 8] = ((t[5] >> 9) | (t[6] << 2)) as u8; + r[idx + 9] = ((t[6] >> 6) | (t[7] << 5)) as u8; + r[idx + 10] = (t[7] >> 3) as u8; + idx += 11; } } } pub fn polyvec_decompress_1024(r: &mut Polyvec1024, a: &[u8]) { let mut idx = 0usize; - let mut t = [0u16; 4]; + let mut t = [0u16; 8]; const K: usize = KYBER_1024_K; for i in 0..K { - for j in 0..KYBER_N / 4 { - t[0] = (a[idx + 0] >> 0) as u16 | (a[idx + 1] as u16) << 8; - t[1] = (a[idx + 1] >> 2) as u16 | (a[idx + 2] as u16) << 6; - t[2] = (a[idx + 2] >> 4) as u16 | (a[idx + 3] as u16) << 4; - t[3] = (a[idx + 3] >> 6) as u16 | (a[idx + 4] as u16) << 2; - idx += 5; - - for k in 0..4 { - r.vec[i].coeffs[4 * j + k] = - ((((t[k] as u32) & 0x3FF) * KYBER_Q as u32 + 512) >> 10) as i16; + for j in 0..KYBER_N / 8 { + t[0] = (a[idx + 0] as u16) | (a[idx + 1] as u16) << 8; + t[1] = (a[idx + 1] >> 3) as u16 | (a[idx + 2] as u16) << 5; + t[2] = (a[idx + 2] >> 6) as u16 | (a[idx + 3] as u16) << 2 | (a[idx + 4] as u16) << 10; + t[3] = (a[idx + 4] >> 1) as u16 | (a[idx + 5] as u16) << 7; + t[4] = (a[idx + 5] >> 4) as u16 | (a[idx + 6] as u16) << 4; + t[5] = (a[idx + 6] >> 7) as u16 | (a[idx + 7] as u16) << 1 | (a[idx + 8] as u16) << 9; + t[6] = (a[idx + 8] >> 2) as u16 | (a[idx + 9] as u16) << 6; + t[7] = (a[idx + 9] >> 5) as u16 | (a[idx + 10] as u16) << 3; + idx += 11; + + for k in 0..8 { + r.vec[i].coeffs[8 * j + k] = + ((((t[k] as u32) & 0x7FF) * KYBER_Q as u32 + 1024) >> 11) as i16; } } } @@ -218,7 +234,7 @@ pub fn polyvec_decompress_1024(r: &mut Polyvec1024, a: &[u8]) { pub fn polyvec_tobytes_1024(r: &mut [u8], a: &Polyvec1024) { const K: usize = KYBER_1024_K; for i in 0..K { - poly_tobytes(&mut r[i * KYBER_POLYBYTES..], a.vec[i]); + poly_tobytes(&mut r[i * KYBER_POLYBYTES..], a.vec[i].clone()); } } @@ -276,8 +292,8 @@ pub fn polyvec_compress(r: &mut [u8], a: Polyvec) { for k in 0..4 { t[k] = a.vec[i].coeffs[4 * j + k] as u16; t[k] = t[k].wrapping_add((((t[k] as i16) >> 15) & KYBER_Q as i16) as u16); - t[k] = (((((t[k] as u32) << 10) + KYBER_Q as u32 / 2) / KYBER_Q as u32) & 0x3ff) - as u16; + let d = (((t[k] as u32) << 10) + 1664) as u64; + t[k] = (((d * 10321345) >> 35) & 0x3ff) as u16; } r[idx + 0] = (t[0] >> 0) as u8; r[idx + 1] = ((t[0] >> 8) | (t[1] << 2)) as u8; @@ -294,7 +310,7 @@ pub fn polyvec_decompress(r: &mut Polyvec, a: &[u8]) { let mut t = [0u16; 4]; for i in 0..KYBER_K { for j in 0..KYBER_N / 4 { - t[0] = (a[idx + 0] >> 0) as u16 | (a[idx + 1] as u16) << 8; + t[0] = (a[idx + 0] as u16) | (a[idx + 1] as u16) << 8; t[1] = (a[idx + 1] >> 2) as u16 | (a[idx + 2] as u16) << 6; t[2] = (a[idx + 2] >> 4) as u16 | (a[idx + 3] as u16) << 4; t[3] = (a[idx + 3] >> 6) as u16 | (a[idx + 4] as u16) << 2; @@ -310,7 +326,7 @@ pub fn polyvec_decompress(r: &mut Polyvec, a: &[u8]) { pub fn polyvec_tobytes(r: &mut [u8], a: &Polyvec) { for i in 0..KYBER_K { - poly_tobytes(&mut r[i * KYBER_POLYBYTES..], a.vec[i]); + poly_tobytes(&mut r[i * KYBER_POLYBYTES..], a.vec[i].clone()); } } diff --git a/src/kyber/symmetric.rs b/src/kyber/symmetric.rs index 9c5fde7..3daabba 100644 --- a/src/kyber/symmetric.rs +++ b/src/kyber/symmetric.rs @@ -1,5 +1,7 @@ #![allow(dead_code)] +use zeroize::Zeroize; + pub use super::fips202::{ sha3_256, sha3_512, shake128_absorb_once, shake256, KeccakState, SHAKE128_RATE, }; @@ -55,6 +57,7 @@ fn kyber_shake128_absorb(state: &mut KeccakState, input: &[u8], x_coord: u8, y_c extseed[32] = x_coord; extseed[33] = y_coord; shake128_absorb_once(state, &extseed, 34); + extseed.zeroize(); } /// Internal: Squeezes output blocks from SHAKE128 XOF state. @@ -69,4 +72,5 @@ fn shake256_prf(output: &mut [u8], outlen: usize, key: &[u8], nonce: u8) { extkey[..32].copy_from_slice(key); extkey[32] = nonce; shake256(output, outlen, &extkey, 33); + extkey.zeroize(); } From 8a6de5054932b279961c246db7542543060f7257 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Tue, 10 Mar 2026 16:14:36 +0200 Subject: [PATCH 32/47] feat: implement comprehensive security hardening and compliance fixes This commit introduces significant security and cryptographic robustness improvements to the pykyber library: - Mitigated timing side-channel attacks by replacing value-dependent division operators with constant-time modular arithmetic in polynomial compression and message extraction functions. - Integrated the zeroize crate to ensure that sensitive cryptographic material, including secret keys and intermediate state buffers, is explicitly wiped from memory when dropped. - Achieved full NIST FIPS 203 compliance for Kyber-1024 by correcting the compression parameters (du=11, dv=5) and bit-packing logic, resulting in a standard-compliant 1568-byte ciphertext. - Hardened the Kyber-512 implementation by updating the noise parameter eta1 to 3 and utilizing the correct CBD3 noise distribution as specified in the standard. - Improved arithmetic robustness in the NTT implementation by using 32-bit intermediate types to prevent potential overflows and refactored Keccak squeezing to ensure memory safety for arbitrary output lengths. - Added a full suite of verification tests and updated benchmarks to reflect the new security-first architecture. --- README.md | 8 +-- performance-tests/operation_breakdown.png | Bin 56474 -> 56435 bytes performance-tests/performance_comparison.png | Bin 56485 -> 57257 bytes performance-tests/scalability.png | Bin 110134 -> 103439 bytes performance-tests/throughput.png | Bin 70066 -> 63219 bytes python/tests/test_features.py | 68 +++++++++++++++++++ src/kyber/fips202.rs | 19 ++++-- src/kyber/ntt.rs | 10 +-- src/kyber/poly.rs | 2 +- src/kyber/reduce.rs | 6 +- 10 files changed, 93 insertions(+), 20 deletions(-) diff --git a/README.md b/README.md index 3a4088c..d7f337f 100644 --- a/README.md +++ b/README.md @@ -85,7 +85,7 @@ keypair = pykyber.Kyber768.from_keys(public_key, secret_key) |-----------|------------|------------|------------|---------------| | Kyber-512 | 800 bytes | 1632 bytes | 768 bytes | 32 bytes | | Kyber-768 | 1184 bytes | 2400 bytes | 1088 bytes | 32 bytes | -| Kyber-1024| 1568 bytes | 3168 bytes | 1408 bytes | 32 bytes | +| Kyber-1024| 1568 bytes | 3168 bytes | 1568 bytes | 32 bytes | ## Error Handling @@ -116,9 +116,9 @@ Performance benchmarks (100 iterations each): | Variant | Keypair | Encapsulate | Decapsulate | |---------|---------|-------------|-------------| -| Kyber512 | 0.27 ms (3,667/s) | 0.39 ms (2,548/s) | 0.48 ms (2,101/s) | -| Kyber768 | 0.48 ms (2,069/s) | 0.62 ms (1,605/s) | 0.78 ms (1,279/s) | -| Kyber1024 | 0.78 ms (1,289/s) | 0.94 ms (1,064/s) | 1.04 ms (959/s) | +| Kyber512 | 0.44 ms (2,262/s) | 0.58 ms (1,721/s) | 0.71 ms (1,404/s) | +| Kyber768 | 0.76 ms (1,312/s) | 0.90 ms (1,111/s) | 1.08 ms (930/s) | +| Kyber1024 | 1.08 ms (928/s) | 1.35 ms (743/s) | 1.55 ms (645/s) | Run benchmarks and generate graphs: diff --git a/performance-tests/operation_breakdown.png b/performance-tests/operation_breakdown.png index 29a22db998121a0a024a12b6beb78dd40e8cde0a..88644a774759a6bb5cfe1ffec02f8772bae4419e 100644 GIT binary patch literal 56435 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⪙iXcC7%W@>{LsTUv+cjn7F;OH+32 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 literal 56474 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 diff --git a/performance-tests/performance_comparison.png b/performance-tests/performance_comparison.png index af127a7f666a5c17528d1d8adb4fe0e873aa57a0..b2a299adbc2c4eea118ac20f3e2160bfc0f2e227 100644 GIT binary patch literal 57257 zcmeFa30Thi`z{*GJdYt#c$3l~Dv1U|cvYf#P|-X}lr*;%mPLrSXrjN_>+`)V{!aP(oRm(PQ}K=&f&yqV>ZPTcBiat?5xZU zxX&7&K4Wfka+{FI79j}%ZZkW(Q)eWFg{^{AD|&aknqSVI3l z#WeUezN=|DbKh>&b9Xu$99Gc$nV*+uan;*qWX$%*G{?1fe+LK)vl<= z>8e_qo14e%;j>sFFPKu9qoOR=B`>fp(c9Y1eaJW`U%_Ax%e=T__}oX^?KO`}?WJ3a z3;&hsK2{^L^4k6oT*1$m#57*#6~BJN#>U;XXwlT)zg=*_W6|&5oZ_B#;rDMm{#eI7 z?f382%$l<9_ix_G&YCsl_wQ!zk;M}Jd`T>ty64xg*`ECQzu;GSOfEYA^mvc`=i*h) zz86&=nw76lF)QCQF)?x4!6EHj!xZk6J3G$gx94uheV$tLeZ>xntXsEEUFMX_x1wjy z_TsHhT`4tv!!5xbA6|Hxt2h6%cmu2dzL|?lR)$0ON&Dc9iUFyt*~DI2%j zG^!pv_zylU{&krAW~HEAFa1P9-ZnIRYHki`uZroo>(EF)lkR}$w=<9n9iBtFXUthzw!gsPXA=1{?cFuwY)t$9Tf~hH1waUGp zOT1%ZVmSHt9y@kt{e}(8SFMW5ot)4)^SSuw#Mp3ug_2Cv$%c#pAz^0j*f-D5Wx+Px zTiNEOooslGo9=7&l4&o!yHkC1*SW8<8u7=Da6Gqm z@~)CTe(~<1fq_9^t!Z#uWt2+5PKWsHqMM8t`T5Z*5r;>*(wYQPQ!Hx^H<#5(7l%yX!Qkd zw+RXmvkb4%cbAHj7hTH988^^XZ`t-bjJ;mc;Y;j|8;f@A+!^6|Vu1i2hDGh8u(nap z6~Y$vsn!{1y8^Uw{rpzicQ@)5cyVc@TGhVJPzcnVdpu`+K*zrA^@{~nY_AayYH25R z8#3&R3<94XKZ1|$e=RRuh=96z^QPqKkN->zw{WexwtuIpr_YUTriT@ScGWf-wBs>Gd3dlTrE<9q?ap@Uf7CkK;Lubn#_cln^}cqBMVMNQx|UT(V|J$7(EFJ? zcJyrOPF4>+xY%=Hl1)QK7;dOzu*rS9Wv)|yG`rBT$S)0<5yqFrGu#-3^(%N=izehS(lLOW5+sn-yyUsm4 z9JI^-<4SB^_Ldu8C4;1#)w^>ia}N1zTDNfFLR_Wd9f|VKz4Gy~T1gh|l~L+xaCYFaAb;NUPkIvS&uWD+20A6>Pm+jjTv-Rw2%7>s?a2o6S&_=#wb}w-~`!=b1?egV3Ob!u)3oqPe+kZh|-<7miZp?DLC1SXLxq#-8 zZ0Et$^x%n!QJd`H&w>0$?s;rADULk$_;i$cMYuNNizQ}LpQ_m8(tGW%^XL0tZcd0i zcys-?Z{L*vp0^5Nf8S;JTa;e56Nj`*`o#EP6Qkfz`!4L@h$(-}h}?I1$;&%Cl6LLd zr5b;1hb!U{2}qCCyivk+B$f?}0Na-t#ALCn5gHO0JQ z|Ma=+s@1VtczV%vF9t8JwAUmApY3kEYjlm7-Mwb#Sp_NQ0aaO9y4_9g?(X*OmCTt7 z*NU!gM#^)V93NCmHaq$_Gqb3oLdCwL+O@q`Hh5S3)8nuFx0xD=a)>z(Sc#dv;;!v3 zG`E*QOlo5LD8J9Uc#BVEBjTWU61B9CrB8aljq z@nYun#cS4B9UVooWH3*hIMLpanKoxRKLg=pTo$B@XJ6&epYwww{aIIDOAQJWAz7bK&>f#5JW5c~ABbqziG&TJakB015Ph)PC z+_`f#ZYQwS7SO^LMIj%N$&k!%Hk`k5%afH$mm1oyu}rWn2@t!6tS4?#$a-N=e_{4g zR%}rK(x$f5euLAWi_Ob(cb}iZK5k%Wc4(#C6u z^c#D9`-!{@5o>#UXe$SBc7OX+l%IcXb$zl8a_7};CdCI6>o#oIfNSXwzKgeTpJArO-JNM7}JQXJw|W=`Gi$_Cv#aRmrMzw-8T@$vEbJI;J2I3^-0TInaKle*8V z0b6um*;DPwKV~k_9N*zIwpO8CYKP#L7Cx2mmD`N|J)US?$l}=_Qf{^jyQ->LiceCq zZfK+3~8!U&b-75XkWTOA#`>Z%OrDX*3p?c5gP z=_&u9xjIIp3|0QwKK<1Qo&(>pn#VHlw;m7iA?l+CT5Nsu@L0Wa_kK+ znY=AEQ57bSw_6KxC-=9U`}pro^#b7NQ=+@h6Vg6wJ33$;r<+;*paH3<_L1>6*CynB zPt#(>yOL@MKyk}V=fQaOSj`jFpS!x^OiBW3Rm%XI1nT~tzd9WIktah53BM}UTBqdh z&YDX0wQJ*zi*83DtC_g25Y~%rZ8b|u-QIX^FTzhLt_vCH^y$;eU3DpH_hhHs-Q}pf zdizNqY>$q?iP7#Dl!cexyk1dVD17SJdjhw&6$eRW{`J>iAKTiZkXz~KAEQzj0-WtAK6NRUMfLSMxQj|W)hK?o z=t!ktX;vtzY8%jr$tdDx4?Qba{l}+`nXGa%)sE`8I3aJHR4c7p!uongj~>;|JRA37 z+sFN0YvT^x;*Vl_Z!A-DRz{N8$mCa#^@~=E33s0uK2V=#lh#_1WU9nejz9Le^5KcS zy18z;G3s$!GcRGkZajP^65y2Kl!aQuXVaMVt*=iN_+dE^#b%9oGwhQLpd_uPgxm>j zo9zDENKu28y-Mkqva_?*a@|~Cym(=br^{Y+4iHsG-)%T7D=VwG4tOx8xxh>3YRBi# z;rN0`**~W`0i99B?rO?yYXA1Y+}2Cl9LZL_-aDx;Q4HTEDmXYKffQerps&B<^v73! z{xLJzrb#-f3kyXHfMgZV@XhoI#gjeA!j(j1*mtz&U7X7f(yk-^P2OC-+Jk5ESc#>jrB3}-8fuY8)-|NtZYZzW z$%opPY_?f1E1h38@*eg?2M~dzeY;OyUS6zp!PebgYo+X3U#;^Tz($L9>Th@Y`tHx_ zI2}_bB_^=AfLg5P(eA9?QWZpBahR+ z-du^Ta_a0gUi2+r_aqw6cps;eb`_78X_v2e>eRy*=>T$DI+~HkMT(5@K-j-mAcNTF zCX1wpjXUNA;AXWtk=t}V-TK?Bl3E>xzMk-OtF|b-vF^MrK�(P?xbi`^y7du13`f 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 BsaF61 literal 56485 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 diff --git a/performance-tests/scalability.png b/performance-tests/scalability.png index f192419002553825737143efec3c68579fdd4292..890aa51ad76e853c4392159eee5d7fb8cb8e8a4c 100644 GIT binary patch literal 103439 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

G(H+vHJMR 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 diff --git a/performance-tests/throughput.png b/performance-tests/throughput.png index 0f1811a9b2167e231aac2f51ed26c3d176bf778e..1ec261f5f650c60d09588d4bd84328008235e940 100644 GIT binary patch literal 63219 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 I{*RCU3lx4!5&!@I literal 70066 zcmd43XH=Be8a9lv#U2Zam8hVi6j6GOQ9(dJ=|w<5K{`k;111(?0TfU=sPx|JP>cwO zQk32iQDA_fcNloDZIZLzzu#K#k1uPTbu=30nP=~P-&ec$!z&8XTQ=_7$i&37Mds24 zB_^h|9ZXEC@BO?E|As0w`40alVs}x)PT9)H&QbsNO(uDLJ8N?*J986*Umb4Vwl%S` zJj=~{np=qT*IRaW*0v%%JQn}^8{Ag6jd}jowy(iY*DwmsV*!NH6>KMl8!mjUBBSH#p3G-u~5(llh_l?@BVQ z0dYy1N6x-r@u$ema2+m}sB&j4kA+OyhYmeC8_N65rlhlmUcTs3(%n2%P$S%2RamoF z$o*KKNy|^5xyboiWY)Oe^v=#r?g#y{c)~ z&xJ^IyDwUZT-eOyvkkB3j&#=)tzLfR*Sy7N!nQ`=KL#jH4>dQ(U5&Kss|xbm-J7Og zs`NbWlB}#!e@&Qt1)q7#mGt!VZCo=eXELLP?~27JMuc~Ht`SpVrA$5ZJ}7F$@K|1& zZ+vxreQfz5QHRTh&K5D7_Lt}G?qX(suCRU8n@Arl?-xmY=zbB(LY7*}wfMj9u1~!F_n-UD z-1uw9jvaNPeET0hd^q^&)!i6{Fw@**llmB~JnL75MMd?8&oKF{&fGR9;xIfg!C0EC zm0TFktTk_2w`CujqGIi?iZBU^R4?5MQe{KU<&ii)AHWsgOi z#$LKF(2f_)_l2C)NPAh}IGTdLmA}Liu5wV+A9n~R%%IFRRwcYPAC zx@kqPz)t3<)RRjUe=&Xe-1n>t+yANB*WTXb#IsnkkglFfzWCBpgNdnw6|5dv?M)ds z<*I|uN*_A3d|D)%wt98&+QwVno^07pfsfF zNt(4||4q-dTb*(o>7cRfWfBXXdwhs#ti`muxaf>=4W~?jJEOp1v@01)-##58XcfLs z&@xHDqD^f07mIggW$~(sYFdR(>76+_7VV}BQ?%QTjvjM=Fg(9k`c>%vM5_uq8&g{* z$5RxA9UtiJyg-Z9*?Va0{laXw2fg@yeSy6hHk|N*Nqp}(o8IzA4YffpM5_X=5(sk-t%NVa}+#@o_kQ2{uf?;%7R_} z4OeV#)p#ZLwQJU#ICe~`zc!+|tH^a49~gVy-{}{Nwye+XRwc>r-d&K%mEjX}J*)C{5s6u_`Om(0inDO!UR>P9f z%QZN6d$I8TzIxr}wE3ADY_RDX(b1M7Ngmz8xZPY@x7u?oI?{GJJ*f)j|CmA#bL{$z zvwpez<8g)1PZ>8qCe70Rj^t5Kxt5?D>#dfob<-k5#6Cgl3Cpvup6N_uY+rd?ncjGO zz%yG0b9NRwXJ)@}ogL|fsEjjDIb&uzWIyqiOo(%^xBzQ@0-326nOt&O2i#L@i7Y#o{2I zvhAzN(BNFaB7{j4Po+7H8}OSpTsn8|+{Da`+DJ$K^u$LVvyU&hwpIjoe&L^A9sPI@ z&tTDPmvYdVn@Oo<#gxV1noI|}R?&F*{*%fvPcn>aEsL(|T)OmETb4;=&{^XcC*`i4 z#}$MqtH1agIDG4m@K7s#u;uw#V+Hc?R$YZSMqb!qJRIMf|I9QnG@LHmqZcRp{N%*! zY=DoC&&EC6NxDTYG?d`2711jD88|R5L&>=+NgBL2Klsa__%+(ripOH_MmtGt+I8Z( zU_Um^<;CEzS$uAb#mbkv+lI?)0(p-%)?Sn~stGljTydM9ptTxD*te`CrWV&pt}Gcg zOWgi;Y0Dw8mJ}7W2b=fu>AziLPj73qtU?Xp^H_GH&iD`dj<#k>W4V-H{eJ)3&`{!? zJ52ZQ-!~a-h?kX>z1{aT+p1e)3(M)>UcGv?apOi`JbcED%GXby{(?Wy#fM~WF1=*4 zRk~LH_uv04US2S3jJtYX`1ZG_R4Vm@KZoH#$K@qw##FuHKE7K|2OAS(jl-R#{{H*# z4}rXqg@uK?PBrAwNZl&zZFnW(-Debbzkxv~WwNv5!u>=xAZ@7{AKP-&Uc{%HcdJXBt(H2(LWc zd7RH~;7VhHsvP?Fv((hoGe%W$f3Dr6B{vb>7cP!-*7)X+)vA$FTTuU`_nx_NrTod> z=>}!Rc$eux^tSinwL|E1{7z%nQ8=qzs^8<~PJI6uyGPIMYJ~ejJhyIP;MW5jI?Xeq z-Kis;RP9tV(q5mRRGpe`))Tc)5_KF=sqj9SoLY1(|8_if=0cArYp8^xqgiW4boEN) z>(^Q4tr?5q+nAO!H#0FEvO&o?%hoFH%_?cxR-#wp9>YLeFk^Y3e?Z9kO_~O$K>I|0 ztrgp`W5G4K);+&d^9P$#t?G>jKD~-rEJX3&zI(S(L9$hMam?a=A?ueq-HzRq=ALfLMtn-lrp!txF0Kg*6Z^yr30Pb z5F1YlNAN(+JkG-YScR}NVQ10B6-vsh`idt-`m1b*s%&j|)^9tM6_RK_)WqS>LYsOgZX5pg@GTkLXL}xi8W4k(EF-Gq^C zL+7Y*?5o-vsbBg)Axv3PQnFq+MTcr+H}L6jS--%1&(M&W+tPT2l#-G!?V5Lr8F1;< zN6p!&&0T+adD%OKMz~GLJnA1tCFa99h)9?%)bCh6xG=IzZ_Adm*~}#NkkE-k&hhej zj)M)ASu4*^sV7lTvy5{otr<6CCbP|3>rzIsTPzlYWb-^9JP6L&#&Y^i&-gN9w%ftu z#@e-OgN~(e>lK?jIXkybZTb1DJws*TtdYOcx#+>cw=m-ryI{!J(#;|^y zKvj4zPTbzEuCAC#v4jn?PoF+@4PR|#W!3xX)p><7KX$p@N40azV_-^UiyPAu4**e(wwq_a&Dnv+Fg!Sql z>+oPqt5YMyXI-3JT=tz(PqAAl{QlwjP`Ir~L3k6Mx3T|i;|51#y%2ASDiP~1ceelX z%hLqI6F^=jb)BDWhX%5pB{$4|`Es4=jM8@9Zm6kRBkR_)aRRkmYW53SvY>9sHVTi8 zkMjzcw_F$Les$h6bYbtarPFeGdPOe$jjVl_&a~xPS?%*{wXY6pE@tb!yG`PBm@NpD zf|sM+0S*~i*^I>^Hf&1{$!APsYhFJf#Nj*O!vg9dy>0bRKYi=(H)gD8TNOoP7qm?Q z(pxpWJhwU|XJFtKHT8p0ZMY8Vi^IwA_wO%Jb7s3-6-zz0ISL)a&vcpp9>9+-WY&)N zl6|9c2ftNUN6hHk`0)2XRcbs1C_GmG|5k3-MPY zr9Om-=4R7tC0A6i@#!Dd+^7y#)z{bG`18-7Ksttty%}IAX29P+%6~8Fcj$CCo>UD0 z2`!%AqCJNmZdm^jb&Or6F;QI|v?a@aNR7IGo04H!|Zz zbA_ai91q|uaG6f%oJ&wm9HhlYH09g&XSqz9hAgx_(2qm;JgJ@%`r!pv$e^LTSF~I} zaMSEGIwY{$E*6$J9Bm!auker~u9B7gZ`#|n(e0Ff`|XbV{P#U!;;v0G-Gtm2lx>Xd zsyMC~?r*n9(FDoc`{32sm^D?{=Ya5QGy_5Tj|bVindZ>EKLG(-I< z&v~hgz@mx|&rkKIt$-BDw_}?PH!O#{jtGO`RK#!z2&myHRLM6x;JP$tBa=JYd?i_n z|023`vz|vIN~OiZMJXxMxA!(ULz+Re-9o3A^#yz~pm<%laA5$)C?kk!Q1-~7|12BZxA5_9dPlyk>F3w?J8KUC zM-xNO`J?fS|w>|lqW&KX+|iN(Eq`D^UV(dcCtLV8XeIr26pqRikbj>ax9 zZXO;Uonkjlbc(t^Ri_Ockr9kv5}JQ>kl$dU=qHDGD!KT^U(=lk0GpRnprBIL)QPqD|8wY zAZLN*-oQW>yz$FufGRoWtx0qn8ynM4FaJPk)uYazx%nXqh4_?^kjCfFpW9FfvFyhC zl(96!x}Lr&QJ1!>CTpqk^74`gDaqI@ zw`g_I4mW*@mnP(>zBI}PvE6a35}FtTcAb@jHaJ8 zt{E6^%~U8#UG?SRvziSaOiUw{LChn-7H3h3zF1#$28g2fap@N3$+KbssTsduXQYQD zdaNuv*a~a)xX&8C`)j+x!O78*6-&V!KvxGwxW}?H)!is@s>)z|YKjj)!LZ({>=AQ} z-nnAeXu`+k)!%jI*_6g~w`H5r)#CBEt$#gwltJqs5UvRo&ZMc=rRo+9HaK6F(Mqz; z)!-~Ibe>G2KnakSTlVKrE~hz(iHmy)+xE3gD@v>fstGbVuxU4E8f^t5#a?wSN=A|lU2_2Rq*br z*s@=M57_r6eb2#z7U=yIDSCjWblHHs+xJ~%Z5#$Z{cTsXsIRu}qdBup#)h580?UhC zXDwrAa>2>!#~nR}-kY<>u|;AV2qZT1VBP#rs(wfT>Yg_**3U%ktZ)7fvSL2t3Z13? zwme~yo#}yP0ZT5AA3x5dx%S(eqe7MgFvzR-9BXn$iKd3~#Yn^q+ z%NbsnTUgi!j3>Z2a`fmHJv}{YF)G&W!NShbX}&XO>Qa0ntuBJr*8la_U#DGWhD{EL zI&hXv`t8VM9`R+=E=5ZF>;pJYAKJ5TpJ~0-(%iTM1tiXV4*@e4VgTa~6zDb<^*qs5 zl5Wr=98zB`&hI4%=O`4Ot+R$R*hCrQ&|7*BmTh zVXAC708Dq9PJVRAe3iR*0hPKR;!`#)7c!D(_mRQ?$SW;gHdA6hz43cQgtBM-C-x2v zmsV6%Wc7{YcDtK3&yHx(K-x2gCIOn-s=u4REyBWV9dhbQ26c6)^hAr(&W(`t=;9XE zg%(nuUu8gRi1#zm%k&jFy1) zRKMm2Hq@!Nos6pDn2{6VC{Hmgo|;F}Ky_m%6<+&|o15$F>+>Aw!P!2EJ4aBFV(cv? z7l+SM=f8ga`UE7mby{BjZKt_z=9+t&m1{C*(?K<9)4g-!y)hNpw>}>UarZHN%NW^q zl)aU5$su<8QK`Uk_iyjFW7naNkzM!c#*4s-$;q?wTLFr?>}o`Z!b8}-j$IDCzONT0 zpT5wPp!zW-qE&+Ql_`74!-xNFf#fmX>Dav&C%5=>iHAodmRky>#|s24xQQw#w<}il ztvClqWmd<<(XJx-{$VIKI^Cp9*R(Tq6=zYfTn@_9N}sI1`NA4oJ2uPQ{n2U$(}iz z5D*Yx10YQmw(YO6z@kS8*NRO((P5RAWbJaBtadH#uMVUP%+xDNcG@0b5|imz1LY?W z#J{gLA~iPL<%6X*b|W(j%dL8Wn;&+uv$0+B1?Wv8d)YiyDf)wW$xmUvGJeP6p|3ea zYgBdUEWA0rd8j#q9eBb$W6{M1bvx8M8XPo+Zgf*%W~9?hoTok4DtB?C`?YJKKdoMU zGhJi&5a4oVh!tAL?2}sH2zq<2W8alSdyU4sG#?#r4U0AyiN+^v&1DD8e6ivL*d@Q1 zOE5YY`Xu0uwMckFTfS|qPS6qQbfD3;=kl^#>XPfBu<#bS?>ceiHvohTGsTa#^JyKL zE+;f!aB3cyam=bty74FoIIn(2^y3|2rC5c7^$e`G4xTsLtYmV&6?>s`MzGtheo90w zRacx^jLH&|N~hY>>b{4wix9o%@Aa%F0L2q<=nEX^34lCiRe`(<5T2$R)%9pZp#gpz zF4rw|8V~2q`w*`jYyN@4E?3Rpj~3IUbc`dvdv*eAkPIXol7ptH0lDFdhDIP!K`0

j-$QNKERqYtb@Xhis1(_j;CUA?-usmPXAT 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%0D@c;|vRSu)e7tnHW3feA}p{$|URoWxjt&4y< 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 lUw!|-t)~9pdim!be{l%Q44QXwj(h^u len(res.ciphertext_hex) / 2 + assert len(res.shared_secret_b64) == 44 # 32 bytes -> 44 chars in b64 + + # Test to_dict + d = res.to_dict() + assert d["ciphertext"] == res.ciphertext_hex + assert d["shared_secret"] == res.shared_secret_hex diff --git a/src/kyber/fips202.rs b/src/kyber/fips202.rs index 0d5ad87..f064ce0 100644 --- a/src/kyber/fips202.rs +++ b/src/kyber/fips202.rs @@ -405,14 +405,19 @@ fn keccak_squeeze( pos = 0 } let mut i = pos; - let mut w = i / 8; - while i < r && i < pos + outlen { - store_u64(&mut out[idx..], s[w]); - i += 8; - w += 1; - idx += 8; + while i < r && outlen > 0 { + if outlen >= 8 && i % 8 == 0 && i + 8 <= r { + store_u64(&mut out[idx..], s[i / 8]); + idx += 8; + outlen -= 8; + i += 8; + } else { + out[idx] = (s[i / 8] >> (8 * (i % 8))) as u8; + idx += 1; + outlen -= 1; + i += 1; + } } - outlen -= i - pos; pos = i; } pos diff --git a/src/kyber/ntt.rs b/src/kyber/ntt.rs index 9eb4756..42228a9 100644 --- a/src/kyber/ntt.rs +++ b/src/kyber/ntt.rs @@ -36,8 +36,8 @@ pub fn ntt_forward(coeffs: &mut [i16]) { j = start; while j < (start + layer_length) { temp = field_multiply(zeta, coeffs[j + layer_length]); - coeffs[j + layer_length] = coeffs[j] - temp; - coeffs[j] += temp; + coeffs[j + layer_length] = (coeffs[j] as i32 - temp as i32) as i16; + coeffs[j] = (coeffs[j] as i32 + temp as i32) as i16; j += 1; } start = j + layer_length; @@ -48,7 +48,7 @@ pub fn ntt_forward(coeffs: &mut [i16]) { /// Inverse Number Theuristic Transform (INTT) on a polynomial. /// Transforms coefficients from NTT domain back to standard representation. -/// Uses inverse butterflies withBarrett reduction and final scaling factor. +/// Uses inverse butterflies with Barrett reduction and final scaling factor. pub fn ntt_inverse(coeffs: &mut [i16]) { let mut j; let mut zeta_index = 127usize; @@ -63,8 +63,8 @@ pub fn ntt_inverse(coeffs: &mut [i16]) { j = start; while j < (start + layer_length) { temp = coeffs[j]; - coeffs[j] = barrett_reduce(temp + coeffs[j + layer_length]); - coeffs[j + layer_length] = coeffs[j + layer_length] - temp; + coeffs[j] = barrett_reduce(temp as i32 + coeffs[j + layer_length] as i32); + coeffs[j + layer_length] = (coeffs[j + layer_length] as i32 - temp as i32) as i16; coeffs[j + layer_length] = field_multiply(zeta, coeffs[j + layer_length]); j += 1 } diff --git a/src/kyber/poly.rs b/src/kyber/poly.rs index babcad7..669a08e 100644 --- a/src/kyber/poly.rs +++ b/src/kyber/poly.rs @@ -185,7 +185,7 @@ pub fn poly_tomont(r: &mut Poly) { pub fn poly_reduce(r: &mut Poly) { for i in 0..KYBER_N { - r.coeffs[i] = barrett_reduce(r.coeffs[i]); + r.coeffs[i] = barrett_reduce(r.coeffs[i] as i32); } } diff --git a/src/kyber/reduce.rs b/src/kyber/reduce.rs index 38f6b6b..239261b 100644 --- a/src/kyber/reduce.rs +++ b/src/kyber/reduce.rs @@ -11,10 +11,10 @@ pub fn montgomery_reduce(a: i32) -> i16 { t as i16 } -pub fn barrett_reduce(a: i16) -> i16 { +pub fn barrett_reduce(a: i32) -> i16 { let v = ((1u32 << 26) / KYBER_Q as u32 + 1) as i32; - let mut t = v * a as i32 + (1 << 25); + let mut t = v * a + (1 << 25); t >>= 26; t *= KYBER_Q as i32; - a - t as i16 + (a - t) as i16 } From 6a4de71654389f2e12425aa80072ea6a18882818 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Tue, 10 Mar 2026 16:29:07 +0200 Subject: [PATCH 33/47] Bump version to 0.2.0 --- Cargo.toml | 2 +- pyproject.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 2e922ca..54ecc24 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pykyber" -version = "0.1.7" +version = "0.2.0" edition = "2021" [lib] diff --git a/pyproject.toml b/pyproject.toml index 035c16b..529ff3c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "maturin" [project] name = "pykyber" -version = "0.1.7" +version = "0.2.0" description = "Kyber post-quantum key encapsulation in Rust" readme = "README.md" requires-python = ">=3.8" From 2703cacde51741a5936e13a9015ecfd1073b7c26 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 10:42:36 +0300 Subject: [PATCH 34/47] Release v1.0.0 - Public domain (Unlicense) license - Add CHANGELOG.md - Add docs/ with API reference and index - Bump version to 1.0.0 - Add AGENTS.md for OpenCode sessions --- CHANGELOG.md | 72 +++++++++++++++++++++++++ Cargo.toml | 2 +- LICENSE | 37 +++++++------ README.md | 3 +- docs/api.md | 140 +++++++++++++++++++++++++++++++++++++++++++++++++ docs/index.md | 9 ++++ pyproject.toml | 8 +-- 7 files changed, 248 insertions(+), 23 deletions(-) create mode 100644 CHANGELOG.md create mode 100644 docs/api.md create mode 100644 docs/index.md diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..0e99299 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,72 @@ +# Changelog + +## v1.0.0 + +First stable release. Public domain (Unlicense). + +### Features +- Kyber-512, Kyber-768, Kyber-1024 post-quantum KEM +- Object-oriented Python API (`Kyber512`, `Kyber768`, `Kyber1024` classes) +- Static methods for encapsulate/decapsulate without a keypair instance +- Deterministic key generation from 64-byte seed +- Serialization: hex, base64, dict for both `Keypair` and `EncapsulationResult` +- Tuple unpacking for `Keypair` → `(pk, sk)` and `EncapsulationResult` → `(ct, ss)` +- Input validation with clear `KyberError` messages + +### Security +- Constant-time arithmetic to mitigate timing side-channels +- Corrected Kyber-512 noise distribution (ETA1=3) +- NIST FIPS-203 compliant Kyber-1024 compression parameters (du=11, dv=5) +- Secret material zeroed on drop via `zeroize` crate +- Safe Keccak squeeze (no buffer overruns) +- Hardened NTT butterfly bounds + +### Performance +| Variant | Keypair | Encapsulate | Decapsulate | +|---------|---------|-------------|-------------| +| Kyber-512 | 0.44 ms | 0.58 ms | 0.71 ms | +| Kyber-768 | 0.76 ms | 0.90 ms | 1.08 ms | +| Kyber-1024 | 1.08 ms | 1.35 ms | 1.55 ms | + +## v0.2.0 + +- Merge security hardening and deterministic key feature branch +- Memory zeroing and cryptographic primitive hardening +- Deterministic key generation and serialization utilities + +## v0.1.7 + +- Version bump (pre-security-hardening) + +## v0.1.6 + +- New decapsulate feature +- Stress tests and performance graphs + +## v0.1.5 + +- Error handling section in README + +## v0.1.4 + +- Better Python file structure +- More verbose error messages +- Additional panic tests and error handling + +## v0.1.3 + +- LSP syntax support (`.pyi` stubs) + +## v0.1.2 + +- Python 3.8+ support via `abi3` +- Termux (aarch64, armv7) wheel builds + +## v0.1.1 + +- Python 3.8+ support with `abi3` + +## v0.1.0 + +- Initial release to PyPI +- Basic Kyber-768 support diff --git a/Cargo.toml b/Cargo.toml index 54ecc24..9270af0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pykyber" -version = "0.2.0" +version = "1.0.0" edition = "2021" [lib] diff --git a/LICENSE b/LICENSE index c5b4af4..fdddb29 100644 --- a/LICENSE +++ b/LICENSE @@ -1,21 +1,24 @@ -MIT License +This is free and unencumbered software released into the public domain. -Copyright (c) 2026 Ziki +Anyone is free to copy, modify, publish, use, compile, sell, or +distribute this software, either in source code form or as a compiled +binary, for any purpose, commercial or non-commercial, and by any +means. -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: +In jurisdictions that recognize copyright laws, the author or authors +of this software dedicate any and all copyright interest in the +software to the public domain. We make this dedication for the benefit +of the public at large and to the detriment of our heirs and +successors. We intend this dedication to be an overt act of +relinquishment in perpetuity of all present and future rights to this +software under copyright law. -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. +For more information, please refer to diff --git a/README.md b/README.md index d7f337f..1158e5f 100644 --- a/README.md +++ b/README.md @@ -143,4 +143,5 @@ Generated graphs: ## License -MIT +This is free and unencumbered software released into the public domain. +See [LICENSE](LICENSE) or . diff --git a/docs/api.md b/docs/api.md new file mode 100644 index 0000000..5a8a1cb --- /dev/null +++ b/docs/api.md @@ -0,0 +1,140 @@ +# pykyber API Reference + +## Classes + +### `Kyber512`, `Kyber768`, `Kyber1024` + +Each variant has the same interface with variant-specific key sizes. + +#### Class constants + +| Constant | Kyber512 | Kyber768 | Kyber1024 | +|----------|----------|----------|-----------| +| `PUBLIC_KEY_SIZE` | 800 | 1184 | 1568 | +| `SECRET_KEY_SIZE` | 1632 | 2400 | 3168 | +| `CIPHERTEXT_SIZE` | 768 | 1088 | 1568 | +| `SHARED_SECRET_SIZE` | 32 | 32 | 32 | + +#### `__new__(seed: Optional[bytes] = None) -> Keypair` + +Generate a new keypair. If `seed` is provided, it must be exactly 64 bytes for deterministic key generation. + +```python +keypair = pykyber.Kyber768() +keypair = pykyber.Kyber768(seed=bytes(range(64))) +``` + +#### `encapsulate(public_key: bytes) -> EncapsulationResult` *(static)* + +Encapsulate a shared secret using a public key without creating a keypair instance. + +```python +result = pykyber.Kyber768.encapsulate(public_key) +``` + +#### `decapsulate(ciphertext: bytes, secret_key: bytes) -> bytes` *(static)* + +Decapsulate a shared secret using ciphertext and secret key without a keypair instance. + +```python +ss = pykyber.Kyber768.decapsulate(ciphertext, secret_key) +``` + +#### `from_keys(public_key: bytes, secret_key: bytes) -> Keypair` *(classmethod)* + +Create a `Keypair` from existing key bytes. + +```python +keypair = pykyber.Kyber768.from_keys(pk, sk) +``` + +--- + +### `Keypair` + +Returned by `Kyber*()` instantiation and `from_keys()`. + +#### Properties + +- `public_key` — raw public key bytes +- `secret_key` — raw secret key bytes +- `public_key_hex` — hex string +- `secret_key_hex` — hex string +- `public_key_b64` — base64 string +- `secret_key_b64` — base64 string + +#### Methods + +- `encapsulate() -> EncapsulationResult` — encapsulate using own public key +- `decapsulate(ciphertext: bytes) -> bytes` — decapsulate using own secret key +- `to_dict() -> dict` — `{"public_key": ..., "secret_key": ...}` (hex) + +#### Tuple unpacking + +```python +public_key, secret_key = keypair # __iter__ yields (pk, sk) +``` + +--- + +### `EncapsulationResult` + +Returned by `encapsulate()` and static `Kyber*.encapsulate()`. + +#### Properties + +- `ciphertext` — raw ciphertext bytes +- `shared_secret` — raw shared secret bytes (32 bytes) +- `ciphertext_hex` — hex string +- `shared_secret_hex` — hex string +- `ciphertext_b64` — base64 string +- `shared_secret_b64` — base64 string + +#### Methods + +- `to_dict() -> dict` — `{"ciphertext": ..., "shared_secret": ...}` (hex) + +#### Tuple unpacking + +```python +ciphertext, shared_secret = result # __iter__ yields (ct, ss) +``` + +--- + +## Exceptions + +### `KyberError` + +Subclass of `Exception`. Raised on: +- Invalid public key size +- Invalid ciphertext size +- Invalid secret key size +- Invalid seed size (not 64 bytes) + +```python +try: + pykyber.Kyber768.encapsulate(b"too_short") +except pykyber.KyberError as e: + print(e) +``` + +--- + +## Low-level functions + +These are variant-generic (Kyber-768): + +| Function | Returns | Description | +|----------|---------|-------------| +| `_generate_keypair(seed)` | `(pk, sk)` | Kyber-768 keypair | +| `_encapsulate(pk)` | `(ct, ss)` | Kyber-768 encapsulate | +| `_decapsulate(ct, sk)` | `ss` | Kyber-768 decapsulate | + +Variant-specific low-level functions: + +| Function | Kyber-512 | Kyber-768 | Kyber-1024 | +|----------|-----------|-----------|------------| +| keypair | `_keypair_512(seed)` | `_keypair_768(seed)` | `_keypair_1024(seed)` | +| encapsulate | `_encapsulate_512(pk)` | `_encapsulate_768(pk)` | `_encapsulate_1024(pk)` | +| decapsulate | `_decapsulate_512(ct, sk)` | `_decapsulate_768(ct, sk)` | `_decapsulate_1024(ct, sk)` | diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..945c3a8 --- /dev/null +++ b/docs/index.md @@ -0,0 +1,9 @@ +# pykyber docs + +- [API Reference](api.md) — full class and function documentation + +## Quick links + +- [README](../README.md) — installation and quick start +- [CHANGELOG](../CHANGELOG.md) — release history +- [LICENSE](../LICENSE) — public domain (Unlicense) diff --git a/pyproject.toml b/pyproject.toml index 529ff3c..763878a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,11 +4,11 @@ build-backend = "maturin" [project] name = "pykyber" -version = "0.2.0" +version = "1.0.0" description = "Kyber post-quantum key encapsulation in Rust" readme = "README.md" requires-python = ">=3.8" -license = {text = "MIT"} +license = {text = "Unlicense"} authors = [ {name = "Yoav Haimov", email = "haimovyoav@gmail.com"} ] @@ -21,13 +21,13 @@ classifiers = [ "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Rust", - "License :: OSI Approved :: MIT License", + "License :: OSI Approved :: Unlicense", "Operating System :: OS Independent", "Topic :: Security :: Cryptography", ] [project.urls] Homepage = "https://github.com/Zikithezikit/pykyber" -Documentation = "https://github.com/Zikithezikit/pykyber#readme" +Documentation = "https://github.com/Zikithezikit/pykyber/tree/v1.0.0/docs" Repository = "https://github.com/Zikithezikit/pykyber" Issues = "https://github.com/Zikithezikit/pykyber/issues" From 2b0b42292b82c9e3f1045866d0536710bd5acee2 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 10:45:47 +0300 Subject: [PATCH 35/47] v1.0.1: fix PyPI classifier for Unlicense --- CHANGELOG.md | 4 ++++ Cargo.toml | 2 +- pyproject.toml | 4 ++-- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0e99299..4deb920 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,9 @@ # Changelog +## v1.0.1 + +Fix PyPI classifier for Unlicense (use `License :: Public Domain`). + ## v1.0.0 First stable release. Public domain (Unlicense). diff --git a/Cargo.toml b/Cargo.toml index 9270af0..1cff531 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pykyber" -version = "1.0.0" +version = "1.0.1" edition = "2021" [lib] diff --git a/pyproject.toml b/pyproject.toml index 763878a..26636e4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "maturin" [project] name = "pykyber" -version = "1.0.0" +version = "1.0.1" description = "Kyber post-quantum key encapsulation in Rust" readme = "README.md" requires-python = ">=3.8" @@ -21,7 +21,7 @@ classifiers = [ "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Rust", - "License :: OSI Approved :: Unlicense", + "License :: Public Domain", "Operating System :: OS Independent", "Topic :: Security :: Cryptography", ] From fee06d991775bf09f69e4a525876faf382915e40 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 11:07:29 +0300 Subject: [PATCH 36/47] v1.0.2: bump version --- CHANGELOG.md | 4 ++++ Cargo.toml | 2 +- pyproject.toml | 4 ++-- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4deb920..80c8cb6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,9 @@ # Changelog +## v1.0.2 + +- chore: bump version to v1.0.2 + ## v1.0.1 Fix PyPI classifier for Unlicense (use `License :: Public Domain`). diff --git a/Cargo.toml b/Cargo.toml index 1cff531..dcf2130 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pykyber" -version = "1.0.1" +version = "1.0.2" edition = "2021" [lib] diff --git a/pyproject.toml b/pyproject.toml index 26636e4..7b2306d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "maturin" [project] name = "pykyber" -version = "1.0.1" +version = "1.0.2" description = "Kyber post-quantum key encapsulation in Rust" readme = "README.md" requires-python = ">=3.8" @@ -27,7 +27,7 @@ classifiers = [ ] [project.urls] Homepage = "https://github.com/Zikithezikit/pykyber" -Documentation = "https://github.com/Zikithezikit/pykyber/tree/v1.0.0/docs" +Documentation = "https://github.com/Zikithezikit/pykyber/tree/v1.0.2/docs" Repository = "https://github.com/Zikithezikit/pykyber" Issues = "https://github.com/Zikithezikit/pykyber/issues" From f0d2687c6d5dce5eaff4bf6ab08ca8a64a5c2f64 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 11:25:17 +0300 Subject: [PATCH 37/47] v1.0.3: restore PyPy wheels in CI --- .github/workflows/CI.yml | 6 ++++++ CHANGELOG.md | 4 ++++ Cargo.toml | 2 +- pyproject.toml | 5 +++-- 4 files changed, 14 insertions(+), 3 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 7012597..c39a765 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -40,6 +40,9 @@ jobs: - uses: actions/setup-python@v6 with: python-version: '3.12' + - uses: actions/setup-python@v6 + with: + python-version: 'pypy-3.11' - name: Build wheels uses: PyO3/maturin-action@v1 with: @@ -71,6 +74,9 @@ jobs: - uses: actions/setup-python@v6 with: python-version: '3.12' + - uses: actions/setup-python@v6 + with: + python-version: 'pypy-3.11' - name: Build wheels uses: PyO3/maturin-action@v1 with: diff --git a/CHANGELOG.md b/CHANGELOG.md index 80c8cb6..478eafc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,9 @@ # Changelog +## v1.0.3 + +- CI: add PyPy 3.11 setup step to restore PyPy wheel builds + ## v1.0.2 - chore: bump version to v1.0.2 diff --git a/Cargo.toml b/Cargo.toml index dcf2130..991dd4c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pykyber" -version = "1.0.2" +version = "1.0.3" edition = "2021" [lib] diff --git a/pyproject.toml b/pyproject.toml index 7b2306d..8b05ecc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "maturin" [project] name = "pykyber" -version = "1.0.2" +version = "1.0.3" description = "Kyber post-quantum key encapsulation in Rust" readme = "README.md" requires-python = ">=3.8" @@ -25,9 +25,10 @@ classifiers = [ "Operating System :: OS Independent", "Topic :: Security :: Cryptography", ] + [project.urls] Homepage = "https://github.com/Zikithezikit/pykyber" -Documentation = "https://github.com/Zikithezikit/pykyber/tree/v1.0.2/docs" +Documentation = "https://github.com/Zikithezikit/pykyber/tree/v1.0.3/docs" Repository = "https://github.com/Zikithezikit/pykyber" Issues = "https://github.com/Zikithezikit/pykyber/issues" From f45135393debfdeff052483c1726d0c6b6c078e7 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 11:59:07 +0300 Subject: [PATCH 38/47] v1.0.5: add Android armv7 + multi-version Python wheels --- .github/workflows/CI.yml | 123 ++++++++++++++++++++++++++++++++++----- CHANGELOG.md | 5 ++ Cargo.toml | 2 +- pyproject.toml | 4 +- 4 files changed, 115 insertions(+), 19 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index c39a765..050f0a6 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -40,9 +40,6 @@ jobs: - uses: actions/setup-python@v6 with: python-version: '3.12' - - uses: actions/setup-python@v6 - with: - python-version: 'pypy-3.11' - name: Build wheels uses: PyO3/maturin-action@v1 with: @@ -56,6 +53,31 @@ jobs: name: wheels-linux-${{ matrix.platform.target }} path: dist + linux-pypy: + runs-on: ubuntu-22.04 + strategy: + matrix: + target: + - x86_64 + steps: + - uses: actions/checkout@v6 + - uses: actions/setup-python@v6 + with: + python-version: 'pypy-3.11' + - name: Build wheels + uses: PyO3/maturin-action@v1 + with: + target: ${{ matrix.target }} + args: --release --out dist --interpreter pypy3.11 + sccache: ${{ !startsWith(github.ref, 'refs/tags/') }} + manylinux: 2_17 + container: off + - name: Upload wheels + uses: actions/upload-artifact@v5 + with: + name: wheels-linux-pypy-${{ matrix.target }} + path: dist + musllinux: runs-on: ${{ matrix.platform.runner }} strategy: @@ -74,9 +96,6 @@ jobs: - uses: actions/setup-python@v6 with: python-version: '3.12' - - uses: actions/setup-python@v6 - with: - python-version: 'pypy-3.11' - name: Build wheels uses: PyO3/maturin-action@v1 with: @@ -143,28 +162,100 @@ jobs: args: --release --out dist --find-interpreter sccache: ${{ !startsWith(github.ref, 'refs/tags/') }} - termux: - runs-on: ubuntu-latest + android: + runs-on: ubuntu-22.04 strategy: matrix: target: - - aarch64-unknown-linux-gnu - - armv7-unknown-linux-gnueabihf + - aarch64-linux-android + - armv7-linux-androideabi + - x86_64-linux-android + python-version: + - "3.8" + - "3.9" + - "3.10" + - "3.11" + - "3.12" + - "3.13" + - "3.14" steps: - uses: actions/checkout@v6 - - uses: actions/setup-python@v6 + - uses: nttld/setup-ndk@v1 + id: setup-ndk with: - python-version: '3.12' + ndk-version: r27d + local-cache: true + - name: Prepare PYO3_CROSS_LIB_DIR + run: | + NDK="$ANDROID_NDK_ROOT" + TOOLCHAIN="$NDK/toolchains/llvm/prebuilt/linux-x86_64" + ANDROID_API=24 + PYVER="${{ matrix.python-version }}" + MOCK_DIR="${{ github.workspace }}/android_python_${{ matrix.target }}_${{ matrix.python-version }}" + mkdir -p "$MOCK_DIR" + + case "${{ matrix.target }}" in + aarch64-linux-android) CLANG_TARGET="aarch64-linux-android${ANDROID_API}" ;; + armv7-linux-androideabi) CLANG_TARGET="armv7a-linux-androideabi${ANDROID_API}" ;; + x86_64-linux-android) CLANG_TARGET="x86_64-linux-android${ANDROID_API}" ;; + esac + + "$TOOLCHAIN/bin/clang" --target="$CLANG_TARGET" -shared \ + -Wl,-soname,"libpython${PYVER}.so" \ + -o "$MOCK_DIR/libpython${PYVER}.so" -xc /dev/null + + case "${{ matrix.target }}" in + aarch64-linux-android) LIBDL_ARCH="aarch64-linux-android" ;; + armv7-linux-androideabi) LIBDL_ARCH="arm-linux-androideabi" ;; + x86_64-linux-android) LIBDL_ARCH="x86_64-linux-android" ;; + esac + LIBDL=$(find "$TOOLCHAIN/sysroot/usr/lib/$LIBDL_ARCH" -name libdl.so | head -1) + [ -n "$LIBDL" ] && cp "$LIBDL" "$MOCK_DIR/" + + SYSCONFIG_NAME="_sysconfigdata__linux_${{ matrix.target }}" + cat > "$MOCK_DIR/${SYSCONFIG_NAME}.py" << EOF + build_time_vars = { + 'abiflags': '', + 'ABIFLAGS': '', + 'SO': '.so', + 'SOABI': 'cpython-${PYVER}', + 'EXT_SUFFIX': '.so', + 'LIBDIR': '$MOCK_DIR', + 'LDLIBRARY': 'libpython${PYVER}.so', + 'Py_ENABLE_SHARED': 1, + 'CC': 'clang', + 'CXX': 'clang++', + 'VERSION': '${PYVER}', + 'LDSHARED': 'clang -shared', + 'LDFLAGS': '-L$MOCK_DIR', + 'CCSHARED': '-fPIC', + 'GNULD': 'yes', + 'Py_DEBUG': 0, + 'WITH_PYMALLOC': 1, + } + EOF + + echo "PYO3_CROSS_LIB_DIR=$MOCK_DIR" >> "$GITHUB_ENV" + echo "PYO3_CROSS_PYTHON_VERSION=$PYVER" >> "$GITHUB_ENV" + echo "_PYTHON_SYSCONFIGDATA_NAME=$SYSCONFIG_NAME" >> "$GITHUB_ENV" + + RFLAGS_VAR="CARGO_TARGET_$(echo "${{ matrix.target }}" | tr '[:lower:]-' '[:upper:]_')_RUSTFLAGS" + echo "$RFLAGS_VAR=-C link-arg=-Wl,--no-as-needed -C link-arg=-lpython${PYVER} -C link-arg=-Wl,--unresolved-symbols=ignore-all" >> "$GITHUB_ENV" + env: + ANDROID_NDK_ROOT: ${{ steps.setup-ndk.outputs.ndk-path }} - name: Build wheels uses: PyO3/maturin-action@v1 with: target: ${{ matrix.target }} - args: --release --out dist --find-interpreter - manylinux: auto + args: --release --out dist + sccache: ${{ !startsWith(github.ref, 'refs/tags/') }} + manylinux: off + env: + ANDROID_NDK_ROOT: ${{ steps.setup-ndk.outputs.ndk-path }} - name: Upload wheels uses: actions/upload-artifact@v5 with: - name: wheels-termux-${{ matrix.target }} + name: wheels-android-${{ matrix.target }}-${{ matrix.python-version }} path: dist sdist: @@ -186,7 +277,7 @@ jobs: name: Release runs-on: ubuntu-latest if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }} - needs: [linux, musllinux, windows, macos, termux, sdist] + needs: [linux, linux-pypy, musllinux, windows, macos, android, sdist] permissions: # Use to sign the release artifacts id-token: write diff --git a/CHANGELOG.md b/CHANGELOG.md index 478eafc..a44532b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,10 @@ # Changelog +## v1.0.5 + +- CI: add Android wheel builds (aarch64-linux-android, armv7-linux-androideabi, x86_64-linux-android × Python 3.8–3.14) — proper Termux support via PEP 738 android platform tags +- CI: remove redundant termux job (built manylinux aarch64/armv7, already covered by linux job; not Termux-compatible) + ## v1.0.3 - CI: add PyPy 3.11 setup step to restore PyPy wheel builds diff --git a/Cargo.toml b/Cargo.toml index 991dd4c..6f88410 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pykyber" -version = "1.0.3" +version = "1.0.5" edition = "2021" [lib] diff --git a/pyproject.toml b/pyproject.toml index 8b05ecc..2cc3c87 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "maturin" [project] name = "pykyber" -version = "1.0.3" +version = "1.0.5" description = "Kyber post-quantum key encapsulation in Rust" readme = "README.md" requires-python = ">=3.8" @@ -28,7 +28,7 @@ classifiers = [ [project.urls] Homepage = "https://github.com/Zikithezikit/pykyber" -Documentation = "https://github.com/Zikithezikit/pykyber/tree/v1.0.3/docs" +Documentation = "https://github.com/Zikithezikit/pykyber/tree/v1.0.5/docs" Repository = "https://github.com/Zikithezikit/pykyber" Issues = "https://github.com/Zikithezikit/pykyber/issues" From 7597bb159eb6c248bb70af21cb9781393649f5fe Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 12:01:46 +0300 Subject: [PATCH 39/47] fix: bump linux-pypy manylinux to 2_34, remove _PYTHON_SYSCONFIGDATA_NAME from global env --- .github/workflows/CI.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 050f0a6..4446744 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -70,7 +70,7 @@ jobs: target: ${{ matrix.target }} args: --release --out dist --interpreter pypy3.11 sccache: ${{ !startsWith(github.ref, 'refs/tags/') }} - manylinux: 2_17 + manylinux: 2_34 container: off - name: Upload wheels uses: actions/upload-artifact@v5 @@ -237,7 +237,6 @@ jobs: echo "PYO3_CROSS_LIB_DIR=$MOCK_DIR" >> "$GITHUB_ENV" echo "PYO3_CROSS_PYTHON_VERSION=$PYVER" >> "$GITHUB_ENV" - echo "_PYTHON_SYSCONFIGDATA_NAME=$SYSCONFIG_NAME" >> "$GITHUB_ENV" RFLAGS_VAR="CARGO_TARGET_$(echo "${{ matrix.target }}" | tr '[:lower:]-' '[:upper:]_')_RUSTFLAGS" echo "$RFLAGS_VAR=-C link-arg=-Wl,--no-as-needed -C link-arg=-lpython${PYVER} -C link-arg=-Wl,--unresolved-symbols=ignore-all" >> "$GITHUB_ENV" From 23cfb7aca3a45ac5313f0ce6800b9f07cb39dc23 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 12:03:05 +0300 Subject: [PATCH 40/47] fix: use target-prefixed clang (NDK r27d removed generic clang) --- .github/workflows/CI.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 4446744..119aa5a 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -200,7 +200,7 @@ jobs: x86_64-linux-android) CLANG_TARGET="x86_64-linux-android${ANDROID_API}" ;; esac - "$TOOLCHAIN/bin/clang" --target="$CLANG_TARGET" -shared \ + "$TOOLCHAIN/bin/${CLANG_TARGET}-clang" -shared \ -Wl,-soname,"libpython${PYVER}.so" \ -o "$MOCK_DIR/libpython${PYVER}.so" -xc /dev/null From 583ab88d2fb719e0c5b33e8dccbb1b24eebb992e Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 12:05:47 +0300 Subject: [PATCH 41/47] fix: use versioned clang binary directly (NDK r27d wrappers still reference removed generic clang) --- .github/workflows/CI.yml | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 119aa5a..f480f6f 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -200,7 +200,13 @@ jobs: x86_64-linux-android) CLANG_TARGET="x86_64-linux-android${ANDROID_API}" ;; esac - "$TOOLCHAIN/bin/${CLANG_TARGET}-clang" -shared \ + # The wrapper scripts (${CLANG_TARGET}-clang) reference generic "clang" + # which was removed in NDK r27d. Use the versioned clang directly. + CLANG=$(ls "$TOOLCHAIN/bin/clang"[0-9]* 2>/dev/null | head -1) + if [ -z "$CLANG" ]; then + echo "ERROR: no versioned clang found in $TOOLCHAIN/bin/"; exit 1 + fi + "$CLANG" --target="$CLANG_TARGET" -shared \ -Wl,-soname,"libpython${PYVER}.so" \ -o "$MOCK_DIR/libpython${PYVER}.so" -xc /dev/null From 05ee55d1bd14c20814b61e956e729dad5ebae82b Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 12:13:38 +0300 Subject: [PATCH 42/47] fix: search for clang-* (versioned) with hyphen; NDK r27d clang binary is clang-18 not clang18 --- .github/workflows/CI.yml | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index f480f6f..1f87b50 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -200,11 +200,16 @@ jobs: x86_64-linux-android) CLANG_TARGET="x86_64-linux-android${ANDROID_API}" ;; esac - # The wrapper scripts (${CLANG_TARGET}-clang) reference generic "clang" - # which was removed in NDK r27d. Use the versioned clang directly. - CLANG=$(ls "$TOOLCHAIN/bin/clang"[0-9]* 2>/dev/null | head -1) + # NDK r27d removed the generic clang launcher; use versioned clang (e.g. clang-18) + CLANG=$(ls "$TOOLCHAIN/bin/clang-"[0-9]* 2>/dev/null | head -1) if [ -z "$CLANG" ]; then - echo "ERROR: no versioned clang found in $TOOLCHAIN/bin/"; exit 1 + # Fallback: generic clang (NDK r26 and earlier) + CLANG="$TOOLCHAIN/bin/clang" + if [ ! -f "$CLANG" ]; then + echo "ERROR: no clang found in $TOOLCHAIN/bin/" + ls -la "$TOOLCHAIN/bin/" | head -30 + exit 1 + fi fi "$CLANG" --target="$CLANG_TARGET" -shared \ -Wl,-soname,"libpython${PYVER}.so" \ From a6bae769cfe709664bfd30161c8fcd07c7d9f4da Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 12:19:19 +0300 Subject: [PATCH 43/47] fix: add --ld-path for clang (NDK r27d removed ld.lld symlink) --- .github/workflows/CI.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 1f87b50..a1b785e 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -211,7 +211,9 @@ jobs: exit 1 fi fi + # NDK r27d also removed the ld.lld symlink; use --ld-path to point to lld directly "$CLANG" --target="$CLANG_TARGET" -shared \ + --ld-path="$TOOLCHAIN/bin/lld" \ -Wl,-soname,"libpython${PYVER}.so" \ -o "$MOCK_DIR/libpython${PYVER}.so" -xc /dev/null From 07b125f123b968b872d5fea4ea5e130a10b6dfa3 Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 12:21:20 +0300 Subject: [PATCH 44/47] fix: recreate ld.lld symlink (removed in NDK r27d); lld needs argv[0] as ld.lld --- .github/workflows/CI.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index a1b785e..ee64723 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -211,9 +211,9 @@ jobs: exit 1 fi fi - # NDK r27d also removed the ld.lld symlink; use --ld-path to point to lld directly + # NDK r27d removed ld.lld symlink; recreate it so clang can find the linker + ln -sf lld "$TOOLCHAIN/bin/ld.lld" "$CLANG" --target="$CLANG_TARGET" -shared \ - --ld-path="$TOOLCHAIN/bin/lld" \ -Wl,-soname,"libpython${PYVER}.so" \ -o "$MOCK_DIR/libpython${PYVER}.so" -xc /dev/null From c5fa21c6a986aea6c2e18a85d59fd94cf7d835db Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 12:23:29 +0300 Subject: [PATCH 45/47] fix: restore clang/clang++/ld.lld symlinks removed in NDK r27d --- .github/workflows/CI.yml | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index ee64723..4ec4be8 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -200,18 +200,21 @@ jobs: x86_64-linux-android) CLANG_TARGET="x86_64-linux-android${ANDROID_API}" ;; esac - # NDK r27d removed the generic clang launcher; use versioned clang (e.g. clang-18) + # NDK r27d removed generic clang/ld.lld symlinks; restore them so + # maturin-action's target-prefixed wrappers (${TARGET}-clang) can work. CLANG=$(ls "$TOOLCHAIN/bin/clang-"[0-9]* 2>/dev/null | head -1) if [ -z "$CLANG" ]; then - # Fallback: generic clang (NDK r26 and earlier) CLANG="$TOOLCHAIN/bin/clang" if [ ! -f "$CLANG" ]; then echo "ERROR: no clang found in $TOOLCHAIN/bin/" ls -la "$TOOLCHAIN/bin/" | head -30 exit 1 fi + else + CLANG_BASE=$(basename "$CLANG") + ln -sf "$CLANG_BASE" "$TOOLCHAIN/bin/clang" + ln -sf "$CLANG_BASE" "$TOOLCHAIN/bin/clang++" fi - # NDK r27d removed ld.lld symlink; recreate it so clang can find the linker ln -sf lld "$TOOLCHAIN/bin/ld.lld" "$CLANG" --target="$CLANG_TARGET" -shared \ -Wl,-soname,"libpython${PYVER}.so" \ From 284cc050c663823d3b0caf0b2de0283694edf8ce Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 12:25:17 +0300 Subject: [PATCH 46/47] fix: add libpython3.so symlink for pyo3's -lpython3 linker flag --- .github/workflows/CI.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index 4ec4be8..dd594bc 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -219,6 +219,8 @@ jobs: "$CLANG" --target="$CLANG_TARGET" -shared \ -Wl,-soname,"libpython${PYVER}.so" \ -o "$MOCK_DIR/libpython${PYVER}.so" -xc /dev/null + # pyo3 also links -lpython3 (versionless); provide it as a symlink + ln -sf "libpython${PYVER}.so" "$MOCK_DIR/libpython3.so" case "${{ matrix.target }}" in aarch64-linux-android) LIBDL_ARCH="aarch64-linux-android" ;; From e065e8daa095bed93cf6f27c46981b694b4285eb Mon Sep 17 00:00:00 2001 From: Zikithezikit Date: Sat, 6 Jun 2026 12:27:39 +0300 Subject: [PATCH 47/47] fix: set ANDROID_API_LEVEL env var for maturin --- .github/workflows/CI.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index dd594bc..fc9a638 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -255,6 +255,7 @@ jobs: echo "PYO3_CROSS_LIB_DIR=$MOCK_DIR" >> "$GITHUB_ENV" echo "PYO3_CROSS_PYTHON_VERSION=$PYVER" >> "$GITHUB_ENV" + echo "ANDROID_API_LEVEL=$ANDROID_API" >> "$GITHUB_ENV" RFLAGS_VAR="CARGO_TARGET_$(echo "${{ matrix.target }}" | tr '[:lower:]-' '[:upper:]_')_RUSTFLAGS" echo "$RFLAGS_VAR=-C link-arg=-Wl,--no-as-needed -C link-arg=-lpython${PYVER} -C link-arg=-Wl,--unresolved-symbols=ignore-all" >> "$GITHUB_ENV"