python-swoosh 0.1.0__tar.gz → 0.1.1__tar.gz

{python_swoosh-0.1.0 → python_swoosh-0.1.1}/Cargo.lock

@@ -321,7 +321,7 @@ checksum = "ba467056f1b547ed52077911161fc86985becbc60e8e1857c8a144dab0def891"
 
 [[package]]
 name = "swoosh"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "pyo3",
  "ref0",

{python_swoosh-0.1.0 → python_swoosh-0.1.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "swoosh"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 description = "Python bindings for the SWOOSH lattice-based NIKE reference implementation"
 license = "MIT"

{python_swoosh-0.1.0 → python_swoosh-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-swoosh
-Version: 0.1.0
+Version: 0.1.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython
@@ -52,6 +52,7 @@ shared secrets are 32 bytes.
 ## API
 
 - `keygen(is_party_a: bool) -> (secret_key: bytes, public_key: bytes)`
+- `keygen_seeded(is_party_a: bool, seed: bytes) -> (secret_key: bytes, public_key: bytes)` — deterministic; `seed` must be 32 bytes. Same seed + same party gives the same keypair. Never reuse seeds in production.
 - `derive_shared_secret(own_pk: bytes, other_pk: bytes, sk: bytes, is_party_a: bool) -> bytes`
 
 ## Building from source

{python_swoosh-0.1.0 → python_swoosh-0.1.1}/README.md

@@ -37,6 +37,7 @@ shared secrets are 32 bytes.
 ## API
 
 - `keygen(is_party_a: bool) -> (secret_key: bytes, public_key: bytes)`
+- `keygen_seeded(is_party_a: bool, seed: bytes) -> (secret_key: bytes, public_key: bytes)` — deterministic; `seed` must be 32 bytes. Same seed + same party gives the same keypair. Never reuse seeds in production.
 - `derive_shared_secret(own_pk: bytes, other_pk: bytes, sk: bytes, is_party_a: bool) -> bytes`
 
 ## Building from source

{python_swoosh-0.1.0 → python_swoosh-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "python-swoosh"
-version = "0.1.0"
+version = "0.1.1"
 description = "Python bindings for the SWOOSH lattice-based NIKE reference implementation"
 readme = "README.md"
 requires-python = ">=3.8"

{python_swoosh-0.1.0 → python_swoosh-0.1.1}/src/lib.rs

@@ -1,7 +1,7 @@
 use pyo3::prelude::*;
 use pyo3::types::PyBytes;
 use pyo3::exceptions::{PyRuntimeError, PyValueError};
-use ref0::{pswoosh_keygen, pswoosh_skey_deriv, sysA, SYMBYTES, PUBLICKEY_BYTES, SECRETKEY_BYTES};
+use ref0::{pswoosh_keygen, pswoosh_keygen_seeded, pswoosh_skey_deriv, sysA, SYMBYTES, PUBLICKEY_BYTES, SECRETKEY_BYTES};
 
 /// Stack size for the worker thread.
 ///
@@ -53,6 +53,37 @@ fn keygen<'py>(py: Python<'py>, is_party_a: bool) -> PyResult<(&'py PyBytes, &'p
     Ok((PyBytes::new(py, &keys.0), PyBytes::new(py, &keys.1)))
 }
 
+/// Deterministically generates a (secret_key, public_key) tuple from a 32-byte seed.
+/// Same seed + same party => same keypair. Useful for tests and reproducibility.
+/// Pass is_party_a=True for Party A, or False for Party B.
+///
+/// WARNING: reusing a seed reuses the secret key. In production, use a fresh,
+/// secret seed every time (or just `keygen`, which samples from the OS RNG).
+#[pyfunction]
+fn keygen_seeded<'py>(
+    py: Python<'py>,
+    is_party_a: bool,
+    seed: &[u8],
+) -> PyResult<(&'py PyBytes, &'py PyBytes)> {
+    let seed: &[u8; SYMBYTES] = seed.try_into().map_err(|_| {
+        PyValueError::new_err(format!("seed must be exactly {SYMBYTES} bytes"))
+    })?;
+    let seed = Box::new(*seed);
+
+    let keys = py.allow_threads(move || {
+        run_isolated(move || {
+            let (sk, pk) = if is_party_a {
+                pswoosh_keygen_seeded(&sysA::A, true, &seed)
+            } else {
+                pswoosh_keygen_seeded(&sysA::At, false, &seed)
+            };
+            Box::new((sk, pk))
+        })
+    })?;
+
+    Ok((PyBytes::new(py, &keys.0), PyBytes::new(py, &keys.1)))
+}
+
 /// Derives the 32-byte shared secret given (pk1, pk2, sk, is_party_a)
 #[pyfunction]
 fn derive_shared_secret<'py>(
@@ -88,6 +119,7 @@ fn derive_shared_secret<'py>(
 #[pymodule]
 fn _swoosh(_py: Python, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(keygen, m)?)?;
+    m.add_function(wrap_pyfunction!(keygen_seeded, m)?)?;
     m.add_function(wrap_pyfunction!(derive_shared_secret, m)?)?;
     Ok(())
 }

python_swoosh-0.1.1/swoosh/__init__.py

@@ -0,0 +1,6 @@
+"""Python bindings for the SWOOSH lattice-based NIKE."""
+
+from ._swoosh import derive_shared_secret, keygen, keygen_seeded
+
+__version__ = "0.1.1"
+__all__ = ["keygen", "keygen_seeded", "derive_shared_secret"]

{python_swoosh-0.1.0 → python_swoosh-0.1.1}/swoosh/__init__.pyi

@@ -8,6 +8,14 @@ def keygen(is_party_a: bool) -> tuple[bytes, bytes]:
     """
     ...
 
+def keygen_seeded(is_party_a: bool, seed: bytes) -> tuple[bytes, bytes]:
+    """Deterministically generate a (secret_key, public_key) pair from a 32-byte seed.
+
+    Same seed + same party => same keypair. WARNING: reusing a seed reuses
+    the secret key; use a fresh secret seed (or plain `keygen`) in production.
+    """
+    ...
+
 def derive_shared_secret(
     own_pk: bytes,
     other_pk: bytes,

{python_swoosh-0.1.0 → python_swoosh-0.1.1}/vendor/ref0/src/lib.rs

@@ -41,21 +41,34 @@ pub fn pswoosh_keygen(a: &Matrix, f:bool) -> ([u8; SECRETKEY_BYTES], [u8; PUBLIC
     kg(a, f)
 }
 
+/*
+ * Seeded key generation wrapper (deterministic: same seed => same keypair).
+ * The seed must be 32 bytes, fresh and secret in production use.
+ */
+pub fn pswoosh_keygen_seeded(a: &Matrix, f: bool, noiseseed: &[u8; SYMBYTES]) -> ([u8; SECRETKEY_BYTES], [u8; PUBLICKEY_BYTES]) {
+    kg_seeded(a, f, noiseseed)
+}
+
 
 /*
  * Generate secret and error vectors and compute public key
  */
 fn kg(a: &Matrix, _f: bool) -> ([u8; SECRETKEY_BYTES], [u8; PUBLICKEY_BYTES]) {
-    let mut nonce: u8 = 0;
     let mut noiseseed: [u8; SYMBYTES] = [0; SYMBYTES];
-    let skv: [u8; SECRETKEY_BYTES];
-    let pkv: [u8; PUBLICKEY_BYTES];
 
     getrandom::getrandom(&mut noiseseed).expect("getrandom failed");
 
-    let mut s: PolyVec = getnoise(&noiseseed, nonce);
+    kg_seeded(a, _f, &noiseseed)
+}
+
+fn kg_seeded(a: &Matrix, _f: bool, noiseseed: &[u8; SYMBYTES]) -> ([u8; SECRETKEY_BYTES], [u8; PUBLICKEY_BYTES]) {
+    let mut nonce: u8 = 0;
+    let skv: [u8; SECRETKEY_BYTES];
+    let pkv: [u8; PUBLICKEY_BYTES];
+
+    let mut s: PolyVec = getnoise(noiseseed, nonce);
     nonce += 1;
-    let mut e: PolyVec = getnoise(&noiseseed, nonce);
+    let mut e: PolyVec = getnoise(noiseseed, nonce);
 
     let pk: PolyVec = gen_pk(a, &mut s, &mut e);
 

{python_swoosh-0.1.0 → python_swoosh-0.1.1}/vendor/ref0/src/sysA.rs

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
-name: python_swoosh-0.1.0/vendor/ref0/src/sysA.rs
+name: python_swoosh-0.1.1/vendor/ref0/src/sysA.rs
 size: 39287679 bytes
 sha256: 5714d2f2ac7f1c75d73f191069eb628e15aefa47a8ea7cb7d6c805f5be036fe1

python_swoosh-0.1.0/swoosh/__init__.py

@@ -1,6 +0,0 @@
-"""Python bindings for the SWOOSH lattice-based NIKE."""
-
-from ._swoosh import derive_shared_secret, keygen
-
-__version__ = "0.1.0"
-__all__ = ["keygen", "derive_shared_secret"]