neva256-native 0.1.0__tar.gz

neva256_native-0.1.0/Cargo.lock

@@ -0,0 +1,180 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
+
+[[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.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a37b2691796cffeb8a8cd305ac66e65841559f147f4e63231d0eafa4db5384d1"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.191"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "neva256-native"
+version = "0.1.0"
+dependencies = [
+ "pyo3",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"

neva256_native-0.1.0/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "neva256-native"
+version = "0.1.0"
+edition = "2021"
+description = "NEVA-256 native accelerator (Rust/PyO3) for the neva256 Python package"
+license = "MIT"
+readme = "README.md"
+
+[lib]
+name = "neva256_native"
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+pyo3 = { version = "0.23", features = ["extension-module"] }
+
+[profile.release]
+opt-level = 3
+lto = true
+codegen-units = 1
+panic = "abort"

neva256_native-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: neva256-native
+Version: 0.1.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Security :: Cryptography
+Summary: NEVA-256 native accelerator (Rust/PyO3) — experimental cipher, NOT for production secrets
+Keywords: cipher,experimental,native,rust,pyo3
+Author: EWX-AI
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/ewxai/ewxai
+
+# neva256-native — NEVA-256 Rust accelerator
+
+Native (Rust/PyO3) backend for the [`neva256`](https://pypi.org/project/neva256/)
+Python package. Bit-exact with the TypeScript and pure-Python implementations,
+roughly 1000× faster than pure Python, with the GIL released during compute.
+
+> ⚠️ EKSPERIMENTAL — NEVA belum pernah dianalisis kriptografer. Jangan pakai
+> untuk data rahasia sungguhan; gunakan AES-256-GCM/libsodium.
+
+## Instalasi
+
+Biasanya tidak perlu dipasang manual — cukup:
+
+```bash
+pip install neva256[fast]
+```
+
+atau:
+
+```bash
+pip install neva256-native
+```
+
+Paket Python `neva256` otomatis memakai backend native ini bila tersedia dan
+jatuh kembali ke pure Python kalau tidak.
+
+## Pemakaian langsung
+
+```python
+from neva256_native import NativeCipher
+
+c = NativeCipher(b"\x00" * 32, b"\x01" * 16)
+blob = c.encrypt_bytes(b"halo")
+assert c.decrypt_bytes(blob, True) == b"halo"
+```
+
+## Build dari sumber
+
+Butuh Rust toolchain:
+
+```bash
+pip install maturin
+maturin build --release          # wheel untuk platform ini
+maturin develop --release        # install ke venv aktif
+```
+
+## Test kompatibilitas
+
+Test parity (native == pure Python) ada di `../tests/test_neva.py`.
+

neva256_native-0.1.0/README.md

@@ -0,0 +1,49 @@
+# neva256-native — NEVA-256 Rust accelerator
+
+Native (Rust/PyO3) backend for the [`neva256`](https://pypi.org/project/neva256/)
+Python package. Bit-exact with the TypeScript and pure-Python implementations,
+roughly 1000× faster than pure Python, with the GIL released during compute.
+
+> ⚠️ EKSPERIMENTAL — NEVA belum pernah dianalisis kriptografer. Jangan pakai
+> untuk data rahasia sungguhan; gunakan AES-256-GCM/libsodium.
+
+## Instalasi
+
+Biasanya tidak perlu dipasang manual — cukup:
+
+```bash
+pip install neva256[fast]
+```
+
+atau:
+
+```bash
+pip install neva256-native
+```
+
+Paket Python `neva256` otomatis memakai backend native ini bila tersedia dan
+jatuh kembali ke pure Python kalau tidak.
+
+## Pemakaian langsung
+
+```python
+from neva256_native import NativeCipher
+
+c = NativeCipher(b"\x00" * 32, b"\x01" * 16)
+blob = c.encrypt_bytes(b"halo")
+assert c.decrypt_bytes(blob, True) == b"halo"
+```
+
+## Build dari sumber
+
+Butuh Rust toolchain:
+
+```bash
+pip install maturin
+maturin build --release          # wheel untuk platform ini
+maturin develop --release        # install ke venv aktif
+```
+
+## Test kompatibilitas
+
+Test parity (native == pure Python) ada di `../tests/test_neva.py`.

neva256_native-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["maturin>=1.5,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "neva256-native"
+version = "0.1.0"
+description = "NEVA-256 native accelerator (Rust/PyO3) — experimental cipher, NOT for production secrets"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+authors = [{ name = "EWX-AI" }]
+keywords = ["cipher", "experimental", "native", "rust", "pyo3"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Topic :: Security :: Cryptography",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/ewxai/ewxai"
+
+[tool.maturin]
+module-name = "neva256_native"
+features = ["pyo3/extension-module"]

neva256_native-0.1.0/src/lib.rs

@@ -0,0 +1,280 @@
+//! NEVA-256 native accelerator (Rust/PyO3).
+//!
+//! Bit-exact port of the `neva256` Python package / the TypeScript
+//! implementation in `src/neva/neva.ts`. Provides the same results, ~1000x
+//! faster than the pure-Python fallback.
+//!
+//! EXPERIMENTAL — not for production secrets.
+
+use pyo3::create_exception;
+use pyo3::exceptions::{PyException, PyValueError};
+use pyo3::prelude::*;
+use pyo3::types::PyBytes;
+
+const KEY_BYTES: usize = 32;
+const NONCE_BYTES: usize = 16;
+const TAG_BYTES: usize = 16;
+
+const GOLDEN: u32 = 0x9e3779b9;
+const SEED_SECOND: u32 = 0x85ebca6b;
+
+const SALT_VORTEX: u32 = 0x1;
+const SALT_COMET: u32 = 0x7e3;
+const SALT_TAG: u32 = 0xc0ffee;
+
+pub const VERSION: &str = "NEVA-256-native/0.1.0";
+
+create_exception!(neva256_native, NativeNevaError, PyException);
+
+#[inline(always)]
+fn swirl(w: &mut [u32; 8], rnd: u32) {
+    for i in 0..8u32 {
+        let a = w[i as usize];
+        let b = w[((i + 1) & 7) as usize];
+        let c = w[((i + 3) & 7) as usize];
+        let r = 1 + ((a >> ((rnd + i) & 7)) % 31);
+        w[i as usize] = (a ^ b)
+            .rotate_left(r & 31)
+            .wrapping_add(c)
+            .wrapping_add((rnd + i).wrapping_mul(GOLDEN));
+    }
+}
+
+fn seed_words(salt: u32) -> [u32; 8] {
+    [
+        0x6e657661 ^ salt,
+        0x2d766f72 ^ salt.wrapping_mul(GOLDEN),
+        0x74657820,
+        0x636f7265,
+        0x0e3d25c1 ^ salt,
+        0x656c6961,
+        0x24bd08e5 ^ salt.wrapping_mul(0x27d4eb2f),
+        0x1a2b3c4d,
+    ]
+}
+
+fn absorb_bytes(v: &mut [u32; 8], data: &[u8]) {
+    let mut acc: u32 = 0;
+    let mut count: u32 = 0;
+    for &byte in data {
+        acc |= (byte as u32) << (8 * (count & 3));
+        count += 1;
+        if count & 3 == 0 {
+            let lane = ((count >> 2) & 7) as usize;
+            v[lane] ^= acc ^ count.wrapping_mul(GOLDEN);
+            swirl(v, lane as u32);
+            acc = 0;
+        }
+    }
+    if count & 3 != 0 {
+        let lane = (count & 7) as usize;
+        v[lane] ^= acc ^ (count + 1).wrapping_mul(GOLDEN);
+        swirl(v, lane as u32);
+    }
+}
+
+fn schedule(key: &[u8], nonce: &[u8], salt: u32) -> [u32; 8] {
+    let mut v = seed_words(salt);
+    swirl(&mut v, salt & 7);
+    v[0] ^= (salt + 1).wrapping_mul(GOLDEN);
+    absorb_bytes(&mut v, key);
+    swirl(&mut v, 1);
+    swirl(&mut v, 2);
+    absorb_bytes(&mut v, nonce);
+    for i in 0..8u32 {
+        swirl(&mut v, 3 + (i & 7));
+    }
+    v
+}
+
+#[inline(always)]
+fn stream_byte(core: &[u32; 8], reg: u32, pos: u32) -> u8 {
+    let mut w = *core;
+    w[0] ^= reg ^ (pos + 1).wrapping_mul(GOLDEN);
+    w[1] ^= (reg >> 16) ^ (pos + 1).wrapping_mul(SEED_SECOND);
+    w[2] = w[2].wrapping_add(pos);
+    w[7] ^= reg ^ (reg << 13);
+    swirl(&mut w, 0);
+    swirl(&mut w, 3);
+    swirl(&mut w, 6);
+    swirl(&mut w, 9);
+    ((w[((pos * 5) & 7) as usize] >> ((pos & 3) * 8)) & 0xff) as u8
+}
+
+fn vortex_layer(data: &[u8], core: &[u32; 8], decoding: bool) -> Vec<u8> {
+    let mut out = vec![0u8; data.len()];
+    let mut reg: u32 = 0;
+    for i in 0..data.len() {
+        let sb = stream_byte(core, reg, i as u32);
+        let c = data[i] ^ sb;
+        out[i] = c;
+        let feed = if decoding { data[i] } else { c };
+        reg = (reg >> 8) | ((feed as u32) << 24);
+    }
+    out
+}
+
+fn make_permutation(n: usize, seeds: &[u32; 4]) -> Vec<u32> {
+    let mut rng = *seeds;
+    if (rng[0] | rng[1] | rng[2] | rng[3]) == 0 {
+        rng[0] = GOLDEN;
+    }
+    let mut p: Vec<u32> = (0..n as u32).collect();
+    for i in (1..n).rev() {
+        // xorshift128
+        let t = rng[3];
+        let w = rng[0];
+        rng[3] = rng[2];
+        rng[2] = rng[1];
+        rng[1] = w;
+        let mut t2 = t ^ (t << 11);
+        t2 ^= t2 >> 8;
+        rng[0] = t2 ^ w ^ (w >> 19);
+        let j = (rng[0] as usize) % (i + 1);
+        p.swap(i, j);
+    }
+    p
+}
+
+fn compute_tag(tag_state: &[u32; 8], data: &[u8], length: usize) -> [u8; TAG_BYTES] {
+    let mut v = *tag_state;
+    absorb_bytes(&mut v, data);
+    let len = length as u32;
+    let len_digest = [
+        (len & 0xff) as u8,
+        ((len >> 8) & 0xff) as u8,
+        ((len >> 16) & 0xff) as u8,
+        ((len >> 24) & 0xff) as u8,
+        0x5a,
+    ];
+    absorb_bytes(&mut v, &len_digest);
+    for i in 0..8u32 {
+        swirl(&mut v, (i + 1) & 7);
+    }
+    let mut out = [0u8; TAG_BYTES];
+    for i in 0..4usize {
+        out[i * 4] = (v[i] & 0xff) as u8;
+        out[i * 4 + 1] = ((v[i] >> 8) & 0xff) as u8;
+        out[i * 4 + 2] = ((v[i] >> 16) & 0xff) as u8;
+        out[i * 4 + 3] = ((v[i] >> 24) & 0xff) as u8;
+    }
+    out
+}
+
+#[pyclass]
+struct NativeCipher {
+    vortex: [u32; 8],
+    comet: [u32; 4],
+    tag: [u32; 8],
+}
+
+impl NativeCipher {
+    fn encrypt_impl(&self, data: &[u8]) -> Vec<u8> {
+        let n = data.len();
+        let masked = vortex_layer(data, &self.vortex, false);
+        let payload: Vec<u8> = if n > 1 {
+            let p = make_permutation(n, &self.comet);
+            let mut out = vec![0u8; n];
+            for i in 0..n {
+                out[i] = masked[p[i] as usize];
+            }
+            out
+        } else {
+            masked
+        };
+        let mut result = payload.clone();
+        result.extend_from_slice(&compute_tag(&self.tag, &payload, n));
+        result
+    }
+
+    fn decrypt_impl(&self, blob: &[u8], verify: bool) -> Result<Vec<u8>, String> {
+        if blob.len() < TAG_BYTES {
+            return Err("ciphertext too short: missing divergence tag".to_string());
+        }
+        let n = blob.len() - TAG_BYTES;
+        let payload = &blob[..n];
+        let tag = &blob[n..];
+        if verify {
+            let expected = compute_tag(&self.tag, payload, n);
+            if expected.as_slice() != tag {
+                return Err("integrity check failed: ciphertext was modified".to_string());
+            }
+        }
+        let masked: Vec<u8> = if n > 1 {
+            let p = make_permutation(n, &self.comet);
+            let mut out = vec![0u8; n];
+            for i in 0..n {
+                out[p[i] as usize] = payload[i];
+            }
+            out
+        } else {
+            payload.to_vec()
+        };
+        Ok(vortex_layer(&masked, &self.vortex, true))
+    }
+}
+
+#[pymethods]
+impl NativeCipher {
+    #[new]
+    fn new(key: &[u8], nonce: &[u8]) -> PyResult<Self> {
+        if key.len() != KEY_BYTES {
+            return Err(PyValueError::new_err(format!(
+                "key must be exactly {} bytes (got {})",
+                KEY_BYTES,
+                key.len()
+            )));
+        }
+        if nonce.len() != NONCE_BYTES {
+            return Err(PyValueError::new_err(format!(
+                "nonce must be exactly {} bytes (got {})",
+                NONCE_BYTES,
+                nonce.len()
+            )));
+        }
+        let vortex = schedule(key, nonce, SALT_VORTEX);
+        let comet = schedule(key, nonce, SALT_COMET);
+        let tag = schedule(key, nonce, SALT_TAG);
+        Ok(Self {
+            vortex,
+            comet: [comet[0], comet[1], comet[2], comet[3]],
+            tag,
+        })
+    }
+
+    /// Encrypt bytes -> ciphertext || 16-byte tag (GIL released during compute).
+    fn encrypt_bytes<'py>(&self, py: Python<'py>, data: &[u8]) -> Bound<'py, PyBytes> {
+        let out = py.allow_threads(|| self.encrypt_impl(data));
+        PyBytes::new(py, &out)
+    }
+
+    /// Decrypt bytes produced by `encrypt_bytes`.
+    fn decrypt_bytes<'py>(
+        &self,
+        py: Python<'py>,
+        blob: &[u8],
+        verify: bool,
+    ) -> PyResult<Bound<'py, PyBytes>> {
+        match py.allow_threads(|| self.decrypt_impl(blob, verify)) {
+            Ok(out) => Ok(PyBytes::new(py, &out)),
+            Err(message) => Err(NativeNevaError::new_err(message)),
+        }
+    }
+}
+
+#[pyfunction]
+fn version() -> &'static str {
+    VERSION
+}
+
+#[pymodule]
+fn neva256_native(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<NativeCipher>()?;
+    m.add_function(wrap_pyfunction!(version, m)?)?;
+    m.add("NativeNevaError", m.py().get_type::<NativeNevaError>())?;
+    m.add("KEY_BYTES", KEY_BYTES)?;
+    m.add("NONCE_BYTES", NONCE_BYTES)?;
+    m.add("TAG_BYTES", TAG_BYTES)?;
+    m.add("__version__", env!("CARGO_PKG_VERSION"))?;
+    Ok(())
+}