neva256 0.1.0__tar.gz

neva256-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: neva256
+Version: 0.1.0
+Summary: NEVA-256: experimental self-synchronizing cipher (NOT for production secrets)
+Author: EWX-AI
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ewxai/ewxai
+Project-URL: Repository, https://github.com/ewxai/ewxai
+Keywords: cipher,experimental,self-synchronizing,educational,ctf
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Education
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: fast
+Requires-Dist: neva256-native<0.2,>=0.1.0; extra == "fast"
+
+# neva256 — NEVA-256 for Python
+
+Port bit-exact dari implementasi TypeScript di `src/neva/neva.ts`.
+Ciphertext yang dihasilkan **kompatibel lintas bahasa** (diverifikasi lewat
+known-answer test + uji silang Python ↔ Node).
+
+> ⚠️ **EKSPERIMENTAL.** NEVA belum pernah dianalisis kriptografer. Jangan pakai
+> untuk melindungi data rahasia sungguhan — gunakan AES-256-GCM, libsodium,
+> atau `cryptography` untuk produksi. Cocok untuk: belajar, CTF, obfuscation,
+> watermark, dan eksperimen.
+
+## Instalasi
+
+```bash
+pip install neva256                 # pure Python (jalan di mana saja)
+pip install "neva256[fast]"        # + akselerator Rust/PyO3 (~360x lebih cepat)
+```
+
+Dari repo ini:
+
+```bash
+cd python && pip install -e .              # pure Python
+cd python/rust && pip install maturin && maturin develop --release   # + native
+```
+
+Backend native dipakai otomatis bila tersedia, dan jatuh kembali ke pure Python
+kalau tidak. Eksplisit: `NevaCipher(key, nonce, use_native=True/False)`; cek
+`cipher.backend` (`"native"` atau `"python"`) dan konstanta `NATIVE_AVAILABLE`.
+
+## Pemakaian
+
+```python
+from neva256 import NevaCipher, generate_key, generate_nonce
+
+key = generate_key()            # simpan ini (32 byte)
+nonce = generate_nonce()        # acak per pesan (16 byte)
+
+cipher = NevaCipher(key, nonce)
+
+blob = cipher.encrypt_text("halo dunia 🌪️")   # string base64 (ct || tag)
+print(cipher.decrypt_text(blob))             # 'halo dunia 🌪️'
+
+# bytes
+data = b"\x00\x01\x02"
+sealed = cipher.encrypt_bytes(data)
+assert cipher.decrypt_bytes(sealed) == data
+
+# mode toleran kerusakan: 1 byte rusak hanya merusak ~5 byte sekitarnya
+partial = cipher.decrypt_bytes(corrupted, verify=False)
+```
+
+Salah kunci atau ciphertext yang diubah → `NevaError`
+(`integrity check failed`).
+
+## CLI
+
+```bash
+neva256 keygen
+neva256 enc "rahasia" --key <64-hex>
+neva256 dec "<nonceHex>:<base64>" --key <64-hex>
+echo "teks dari pipe" | neva256 enc - --key <64-hex>
+```
+
+## Test
+
+```bash
+cd python
+python -m unittest discover -s tests -v
+```
+
+Test mencakup known-answer vectors dari implementasi TypeScript, round-trip
+(a–4 KB), deteksi tamper, validasi ukuran key/nonce, dan sifat
+self-synchronizing.
+
+## Catatan keamanan
+
+Lihat `src/neva/README.md` untuk matriks serangan lengkap: differential per
+round, kurva sensitivitas rotasi, hill-climbing, SMT/Z3, dan temuan
+equivalent-key pada versi 1-swirl. Ringkasnya: implementasi ini memakai
+**4 swirl** dengan margin satu round di atas ambang kebersihan statistik
+terukur — tapi statusnya tetap eksperimental.
+
+## Performa (terukur di aarch64)
+
+| Backend | Encrypt 1 MB | Throughput |
+| --- | --- | --- |
+| Pure Python | 31.3 s | 0.03 MB/s |
+| **Native (Rust/PyO3)** | **87 ms** | **11.5 MB/s** |
+
+Native ~360× lebih cepat dan melepas GIL: 4 thread paralel = 2.5× speedup pada
+mesin uji. Implementasi TypeScript ~3 MB/s (native Rust ~4× lebih cepat dari itu).
+Untuk teks/payload kecil, pure Python sudah cukup.

neva256-0.1.0/README.md

@@ -0,0 +1,92 @@
+# neva256 — NEVA-256 for Python
+
+Port bit-exact dari implementasi TypeScript di `src/neva/neva.ts`.
+Ciphertext yang dihasilkan **kompatibel lintas bahasa** (diverifikasi lewat
+known-answer test + uji silang Python ↔ Node).
+
+> ⚠️ **EKSPERIMENTAL.** NEVA belum pernah dianalisis kriptografer. Jangan pakai
+> untuk melindungi data rahasia sungguhan — gunakan AES-256-GCM, libsodium,
+> atau `cryptography` untuk produksi. Cocok untuk: belajar, CTF, obfuscation,
+> watermark, dan eksperimen.
+
+## Instalasi
+
+```bash
+pip install neva256                 # pure Python (jalan di mana saja)
+pip install "neva256[fast]"        # + akselerator Rust/PyO3 (~360x lebih cepat)
+```
+
+Dari repo ini:
+
+```bash
+cd python && pip install -e .              # pure Python
+cd python/rust && pip install maturin && maturin develop --release   # + native
+```
+
+Backend native dipakai otomatis bila tersedia, dan jatuh kembali ke pure Python
+kalau tidak. Eksplisit: `NevaCipher(key, nonce, use_native=True/False)`; cek
+`cipher.backend` (`"native"` atau `"python"`) dan konstanta `NATIVE_AVAILABLE`.
+
+## Pemakaian
+
+```python
+from neva256 import NevaCipher, generate_key, generate_nonce
+
+key = generate_key()            # simpan ini (32 byte)
+nonce = generate_nonce()        # acak per pesan (16 byte)
+
+cipher = NevaCipher(key, nonce)
+
+blob = cipher.encrypt_text("halo dunia 🌪️")   # string base64 (ct || tag)
+print(cipher.decrypt_text(blob))             # 'halo dunia 🌪️'
+
+# bytes
+data = b"\x00\x01\x02"
+sealed = cipher.encrypt_bytes(data)
+assert cipher.decrypt_bytes(sealed) == data
+
+# mode toleran kerusakan: 1 byte rusak hanya merusak ~5 byte sekitarnya
+partial = cipher.decrypt_bytes(corrupted, verify=False)
+```
+
+Salah kunci atau ciphertext yang diubah → `NevaError`
+(`integrity check failed`).
+
+## CLI
+
+```bash
+neva256 keygen
+neva256 enc "rahasia" --key <64-hex>
+neva256 dec "<nonceHex>:<base64>" --key <64-hex>
+echo "teks dari pipe" | neva256 enc - --key <64-hex>
+```
+
+## Test
+
+```bash
+cd python
+python -m unittest discover -s tests -v
+```
+
+Test mencakup known-answer vectors dari implementasi TypeScript, round-trip
+(a–4 KB), deteksi tamper, validasi ukuran key/nonce, dan sifat
+self-synchronizing.
+
+## Catatan keamanan
+
+Lihat `src/neva/README.md` untuk matriks serangan lengkap: differential per
+round, kurva sensitivitas rotasi, hill-climbing, SMT/Z3, dan temuan
+equivalent-key pada versi 1-swirl. Ringkasnya: implementasi ini memakai
+**4 swirl** dengan margin satu round di atas ambang kebersihan statistik
+terukur — tapi statusnya tetap eksperimental.
+
+## Performa (terukur di aarch64)
+
+| Backend | Encrypt 1 MB | Throughput |
+| --- | --- | --- |
+| Pure Python | 31.3 s | 0.03 MB/s |
+| **Native (Rust/PyO3)** | **87 ms** | **11.5 MB/s** |
+
+Native ~360× lebih cepat dan melepas GIL: 4 thread paralel = 2.5× speedup pada
+mesin uji. Implementasi TypeScript ~3 MB/s (native Rust ~4× lebih cepat dari itu).
+Untuk teks/payload kecil, pure Python sudah cukup.

neva256-0.1.0/neva256/__init__.py

@@ -0,0 +1,315 @@
+"""NEVA-256 — Non-Equilibrium Vortex Algorithm (Python port).
+
+A bit-exact Python port of the TypeScript implementation in
+``src/neva/neva.ts``. Ciphertexts are interoperable between both
+implementations (verified by known-answer tests and round-trip tests).
+
+EXPERIMENTAL / EDUCATIONAL — NEVA has not been analyzed by cryptographers.
+Do not use it to protect real secrets; use AES-256-GCM / libsodium instead.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Optional, Union
+
+try:  # optional Rust accelerator (neva256-native)
+    import neva256_native as _native
+except ImportError:  # pragma: no cover - pure Python fallback
+    _native = None
+
+NATIVE_AVAILABLE = _native is not None
+
+__all__ = [
+    "KEY_BYTES",
+    "NONCE_BYTES",
+    "TAG_BYTES",
+    "VERSION",
+    "NATIVE_AVAILABLE",
+    "NevaError",
+    "NevaCipher",
+    "generate_key",
+    "generate_nonce",
+]
+
+__version__ = "0.1.0"
+VERSION = "NEVA-256/0.1.0"
+
+KEY_BYTES = 32
+NONCE_BYTES = 16
+TAG_BYTES = 16
+
+_GOLDEN = 0x9E3779B9
+_SEED_SECOND = 0x85EBCA6B
+
+_SALT_VORTEX = 0x1
+_SALT_COMET = 0x7E3
+_SALT_TAG = 0xC0FFEE
+
+_M32 = 0xFFFFFFFF
+
+
+class NevaError(Exception):
+    """Raised for invalid keys, tampered ciphertext, or malformed input."""
+
+
+def _m32(x: int) -> int:
+    return x & _M32
+
+
+def _rotl(x: int, r: int) -> int:
+    r &= 31
+    return _m32((x << r) | (x >> (32 - r)))
+
+
+def _swirl(w: list, rnd: int) -> None:
+    """One ARX swirl over an 8-lane state (in place)."""
+    for i in range(8):
+        a = w[i]
+        b = w[(i + 1) & 7]
+        c = w[(i + 3) & 7]
+        r = 1 + ((a >> ((rnd + i) & 7)) % 31)
+        w[i] = _m32(_rotl(_m32(a ^ b), r) + c + _m32((rnd + i) * _GOLDEN))
+
+
+def _seed_words(salt: int) -> list:
+    return [
+        _m32(0x6E657661 ^ salt),
+        _m32(0x2D766F72 ^ _m32(salt * _GOLDEN)),
+        0x74657820,
+        0x636F7265,
+        _m32(0x0E3D25C1 ^ salt),
+        0x656C6961,
+        _m32(0x24BD08E5 ^ _m32(salt * 0x27D4EB2F)),
+        0x1A2B3C4D,
+    ]
+
+
+def _absorb_bytes(v: list, data: bytes) -> None:
+    acc = 0
+    count = 0
+    for byte in data:
+        acc = _m32(acc | (byte << (8 * (count & 3))))
+        count += 1
+        if (count & 3) == 0:
+            lane = (count >> 2) & 7
+            v[lane] = _m32(v[lane] ^ acc ^ _m32(count * _GOLDEN))
+            _swirl(v, lane & 7)
+            acc = 0
+    if count & 3:
+        lane = count & 7
+        v[lane] = _m32(v[lane] ^ acc ^ _m32((count + 1) * _GOLDEN))
+        _swirl(v, lane & 7)
+
+
+def _schedule(key: bytes, nonce: bytes, salt: int) -> list:
+    v = _seed_words(salt)
+    _swirl(v, salt & 7)
+    v[0] = _m32(v[0] ^ _m32((salt + 1) * _GOLDEN))
+    _absorb_bytes(v, key)
+    _swirl(v, 1)
+    _swirl(v, 2)
+    _absorb_bytes(v, nonce)
+    for i in range(8):
+        _swirl(v, 3 + (i & 7))
+    return v
+
+
+def _stream_byte(core: list, reg: int, pos: int) -> int:
+    w = core.copy()
+    w[0] = _m32(w[0] ^ reg ^ _m32((pos + 1) * _GOLDEN))
+    w[1] = _m32(w[1] ^ (reg >> 16) ^ _m32((pos + 1) * _SEED_SECOND))
+    w[2] = _m32(w[2] + pos)
+    w[7] = _m32(w[7] ^ reg ^ _m32(reg << 13))
+    _swirl(w, 0)
+    _swirl(w, 3)
+    _swirl(w, 6)
+    _swirl(w, 9)
+    return (w[(pos * 5) & 7] >> ((pos & 3) * 8)) & 0xFF
+
+
+def _vortex_layer(data: bytes, core: list, decoding: bool = False) -> bytes:
+    out = bytearray(len(data))
+    reg = 0
+    for i in range(len(data)):
+        sb = _stream_byte(core, reg, i)
+        c = (data[i] ^ sb) & 0xFF
+        out[i] = c
+        feed = data[i] if decoding else c
+        reg = _m32((reg >> 8) | (feed << 24))
+    return bytes(out)
+
+
+def _make_permutation(n: int, seeds: list) -> list:
+    rng = list(seeds)
+    if (rng[0] | rng[1] | rng[2] | rng[3]) == 0:
+        rng[0] = _GOLDEN
+
+    def nxt() -> int:
+        t = rng[3]
+        w = rng[0]
+        rng[3] = rng[2]
+        rng[2] = rng[1]
+        rng[1] = w
+        t = _m32(t ^ _m32(t << 11))
+        t = _m32(t ^ (t >> 8))
+        rng[0] = _m32(t ^ w ^ (w >> 19))
+        return rng[0]
+
+    p = list(range(n))
+    for i in range(n - 1, 0, -1):
+        j = nxt() % (i + 1)
+        p[i], p[j] = p[j], p[i]
+    return p
+
+
+def _compute_tag(tag_state: list, data: bytes, length: int) -> bytes:
+    v = list(tag_state)
+    _absorb_bytes(v, data)
+    len_digest = bytes(
+        [length & 0xFF, (length >> 8) & 0xFF, (length >> 16) & 0xFF, (length >> 24) & 0xFF, 0x5A]
+    )
+    _absorb_bytes(v, len_digest)
+    for i in range(8):
+        _swirl(v, (i + 1) & 7)
+    out = bytearray(16)
+    for i in range(4):
+        out[i * 4] = v[i] & 0xFF
+        out[i * 4 + 1] = (v[i] >> 8) & 0xFF
+        out[i * 4 + 2] = (v[i] >> 16) & 0xFF
+        out[i * 4 + 3] = (v[i] >> 24) & 0xFF
+    return bytes(out)
+
+
+def _as_bytes(value: Union[bytes, bytearray, str], what: str) -> bytes:
+    if isinstance(value, str):
+        value = value.encode()
+    if not isinstance(value, (bytes, bytearray)):
+        raise NevaError(f"{what} must be bytes or str")
+    return bytes(value)
+
+
+class NevaCipher:
+    """NEVA-256 text/binary cipher.
+
+    >>> import os
+    >>> c = NevaCipher(os.urandom(32), os.urandom(16))
+    >>> blob = c.encrypt_text("halo dunia")
+    >>> c.decrypt_text(blob)
+    'halo dunia'
+    """
+
+    def __init__(
+        self,
+        key: Union[bytes, bytearray, str],
+        nonce: Optional[Union[bytes, bytearray, str]] = None,
+        *,
+        use_native: Optional[bool] = None,
+    ) -> None:
+        """Create a cipher.
+
+        ``use_native``: ``None`` (default) uses the native Rust backend when
+        installed and falls back to pure Python; ``True`` requires native;
+        ``False`` forces the pure Python implementation.
+        """
+        key = _as_bytes(key, "key")
+        nonce = bytes(NONCE_BYTES) if nonce is None else _as_bytes(nonce, "nonce")
+        if len(key) != KEY_BYTES:
+            raise NevaError(f"key must be exactly {KEY_BYTES} bytes (got {len(key)})")
+        if len(nonce) != NONCE_BYTES:
+            raise NevaError(f"nonce must be exactly {NONCE_BYTES} bytes (got {len(nonce)})")
+        self.nonce = nonce
+        self._vortex_core = _schedule(key, nonce, _SALT_VORTEX)
+        self._comet_seeds = list(_schedule(key, nonce, _SALT_COMET)[:4])
+        self._tag_state = _schedule(key, nonce, _SALT_TAG)
+
+        self._native = None
+        self.backend = "python"
+        if use_native is True and not NATIVE_AVAILABLE:
+            raise NevaError("native backend requested but neva256-native is not installed")
+        if use_native is not False and NATIVE_AVAILABLE:
+            try:
+                self._native = _native.NativeCipher(key, nonce)
+                self.backend = "native"
+            except Exception:  # pragma: no cover - fall back defensively
+                if use_native is True:
+                    raise
+
+    def encrypt_bytes(self, data: Union[bytes, bytearray, str]) -> bytes:
+        """Encrypt bytes -> ``ciphertext || 16-byte tag``."""
+        data = _as_bytes(data, "data")
+        if self._native is not None:
+            return bytes(self._native.encrypt_bytes(data))
+        n = len(data)
+        masked = _vortex_layer(data, self._vortex_core)
+        if n > 1:
+            p = _make_permutation(n, self._comet_seeds)
+            payload = bytearray(n)
+            for i in range(n):
+                payload[i] = masked[p[i]]
+            payload = bytes(payload)
+        else:
+            payload = masked
+        return payload + _compute_tag(self._tag_state, payload, n)
+
+    def decrypt_bytes(self, blob: Union[bytes, bytearray, str], verify: bool = True) -> bytes:
+        """Decrypt bytes produced by :meth:`encrypt_bytes`.
+
+        With ``verify=False`` the divergence tag is ignored and corruption stays
+        local (~5 bytes per damaged byte) thanks to self-synchronization.
+        """
+        blob = _as_bytes(blob, "blob")
+        if len(blob) < TAG_BYTES:
+            raise NevaError("ciphertext too short: missing divergence tag")
+        if self._native is not None:
+            try:
+                return bytes(self._native.decrypt_bytes(blob, verify))
+            except NevaError:
+                raise
+            except Exception as exc:
+                raise NevaError(str(exc)) from None
+        n = len(blob) - TAG_BYTES
+        payload = blob[:n]
+        tag = blob[n:]
+        if verify and not _constant_eq(_compute_tag(self._tag_state, payload, n), tag):
+            raise NevaError("integrity check failed: ciphertext was modified")
+        if n > 1:
+            p = _make_permutation(n, self._comet_seeds)
+            masked = bytearray(n)
+            for i in range(n):
+                masked[p[i]] = payload[i]
+            masked = bytes(masked)
+        else:
+            masked = payload
+        return _vortex_layer(masked, self._vortex_core, decoding=True)
+
+    def encrypt_text(self, text: str) -> str:
+        """Encrypt UTF-8 text to a standard base64 string."""
+        import base64
+
+        return base64.b64encode(self.encrypt_bytes(text.encode())).decode()
+
+    def decrypt_text(self, blob: str, verify: bool = True) -> str:
+        """Decrypt a base64 string produced by :meth:`encrypt_text`."""
+        import base64
+
+        return self.decrypt_bytes(base64.b64decode(blob), verify=verify).decode()
+
+
+def _constant_eq(a: bytes, b: bytes) -> bool:
+    if len(a) != len(b):
+        return False
+    diff = 0
+    for x, y in zip(a, b):
+        diff |= x ^ y
+    return diff == 0
+
+
+def generate_key() -> bytes:
+    """Return a random 256-bit key."""
+    return os.urandom(KEY_BYTES)
+
+
+def generate_nonce() -> bytes:
+    """Return a random 128-bit nonce."""
+    return os.urandom(NONCE_BYTES)

neva256-0.1.0/neva256/cli.py

@@ -0,0 +1,83 @@
+"""NEVA-256 command line interface (mirrors the TypeScript CLI)."""
+
+from __future__ import annotations
+
+import base64
+import sys
+
+from . import (
+    KEY_BYTES,
+    NONCE_BYTES,
+    NevaCipher,
+    NevaError,
+    generate_key,
+    generate_nonce,
+)
+
+USAGE = """NEVA-256 — text encryption (experimental, not for real secrets)
+
+Usage:
+  neva256 keygen                       generate a random 256-bit key (hex)
+  neva256 enc <text|-> --key <hex>     encrypt text ("-" = stdin)
+  neva256 dec <blob|-> --key <hex>     decrypt a <nonceHex>:<base64> blob
+"""
+
+
+def _hex_to_bytes(value: str, expected: int, what: str) -> bytes:
+    try:
+        raw = bytes.fromhex(value)
+    except ValueError as exc:
+        raise NevaError(f"{what} must be hex") from exc
+    if len(raw) != expected:
+        raise NevaError(f"{what} must be exactly {expected * 2} hex characters")
+    return raw
+
+
+def _read_input(value: str) -> str:
+    return sys.stdin.read() if value == "-" else value
+
+
+def main(argv: list | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if not args or args[0] in ("help", "-h", "--help"):
+        print(USAGE, end="")
+        return 0
+
+    cmd = args[0]
+    try:
+        if cmd == "keygen":
+            print(generate_key().hex())
+            return 0
+
+        if cmd in ("enc", "dec"):
+            if len(args) < 2:
+                raise NevaError(f"missing argument for {cmd} (use '-' for stdin)")
+            if "--key" not in args:
+                raise NevaError("missing --key <64-hex-chars>")
+            key = _hex_to_bytes(args[args.index("--key") + 1], KEY_BYTES, "key")
+            value = _read_input(args[1])
+
+            if cmd == "enc":
+                nonce = generate_nonce()
+                cipher = NevaCipher(key, nonce)
+                blob = cipher.encrypt_bytes(value.encode())
+                print(f"{nonce.hex()}:{base64.b64encode(blob).decode()}")
+                return 0
+
+            if ":" not in value:
+                raise NevaError("bad blob: expected <nonceHex>:<base64>")
+            nonce_hex, b64 = value.strip().split(":", 1)
+            cipher = NevaCipher(key, _hex_to_bytes(nonce_hex, NONCE_BYTES, "nonce"))
+            sys.stdout.write(cipher.decrypt_bytes(base64.b64decode(b64)).decode())
+            if sys.stdout.isatty():
+                sys.stdout.write("\n")
+            return 0
+
+        raise NevaError(f"unknown command: {cmd} (try: help)")
+    except NevaError as exc:
+        print(f"error: NEVA: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

neva256-0.1.0/neva256.egg-info/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: neva256
+Version: 0.1.0
+Summary: NEVA-256: experimental self-synchronizing cipher (NOT for production secrets)
+Author: EWX-AI
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ewxai/ewxai
+Project-URL: Repository, https://github.com/ewxai/ewxai
+Keywords: cipher,experimental,self-synchronizing,educational,ctf
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Education
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: fast
+Requires-Dist: neva256-native<0.2,>=0.1.0; extra == "fast"
+
+# neva256 — NEVA-256 for Python
+
+Port bit-exact dari implementasi TypeScript di `src/neva/neva.ts`.
+Ciphertext yang dihasilkan **kompatibel lintas bahasa** (diverifikasi lewat
+known-answer test + uji silang Python ↔ Node).
+
+> ⚠️ **EKSPERIMENTAL.** NEVA belum pernah dianalisis kriptografer. Jangan pakai
+> untuk melindungi data rahasia sungguhan — gunakan AES-256-GCM, libsodium,
+> atau `cryptography` untuk produksi. Cocok untuk: belajar, CTF, obfuscation,
+> watermark, dan eksperimen.
+
+## Instalasi
+
+```bash
+pip install neva256                 # pure Python (jalan di mana saja)
+pip install "neva256[fast]"        # + akselerator Rust/PyO3 (~360x lebih cepat)
+```
+
+Dari repo ini:
+
+```bash
+cd python && pip install -e .              # pure Python
+cd python/rust && pip install maturin && maturin develop --release   # + native
+```
+
+Backend native dipakai otomatis bila tersedia, dan jatuh kembali ke pure Python
+kalau tidak. Eksplisit: `NevaCipher(key, nonce, use_native=True/False)`; cek
+`cipher.backend` (`"native"` atau `"python"`) dan konstanta `NATIVE_AVAILABLE`.
+
+## Pemakaian
+
+```python
+from neva256 import NevaCipher, generate_key, generate_nonce
+
+key = generate_key()            # simpan ini (32 byte)
+nonce = generate_nonce()        # acak per pesan (16 byte)
+
+cipher = NevaCipher(key, nonce)
+
+blob = cipher.encrypt_text("halo dunia 🌪️")   # string base64 (ct || tag)
+print(cipher.decrypt_text(blob))             # 'halo dunia 🌪️'
+
+# bytes
+data = b"\x00\x01\x02"
+sealed = cipher.encrypt_bytes(data)
+assert cipher.decrypt_bytes(sealed) == data
+
+# mode toleran kerusakan: 1 byte rusak hanya merusak ~5 byte sekitarnya
+partial = cipher.decrypt_bytes(corrupted, verify=False)
+```
+
+Salah kunci atau ciphertext yang diubah → `NevaError`
+(`integrity check failed`).
+
+## CLI
+
+```bash
+neva256 keygen
+neva256 enc "rahasia" --key <64-hex>
+neva256 dec "<nonceHex>:<base64>" --key <64-hex>
+echo "teks dari pipe" | neva256 enc - --key <64-hex>
+```
+
+## Test
+
+```bash
+cd python
+python -m unittest discover -s tests -v
+```
+
+Test mencakup known-answer vectors dari implementasi TypeScript, round-trip
+(a–4 KB), deteksi tamper, validasi ukuran key/nonce, dan sifat
+self-synchronizing.
+
+## Catatan keamanan
+
+Lihat `src/neva/README.md` untuk matriks serangan lengkap: differential per
+round, kurva sensitivitas rotasi, hill-climbing, SMT/Z3, dan temuan
+equivalent-key pada versi 1-swirl. Ringkasnya: implementasi ini memakai
+**4 swirl** dengan margin satu round di atas ambang kebersihan statistik
+terukur — tapi statusnya tetap eksperimental.
+
+## Performa (terukur di aarch64)
+
+| Backend | Encrypt 1 MB | Throughput |
+| --- | --- | --- |
+| Pure Python | 31.3 s | 0.03 MB/s |
+| **Native (Rust/PyO3)** | **87 ms** | **11.5 MB/s** |
+
+Native ~360× lebih cepat dan melepas GIL: 4 thread paralel = 2.5× speedup pada
+mesin uji. Implementasi TypeScript ~3 MB/s (native Rust ~4× lebih cepat dari itu).
+Untuk teks/payload kecil, pure Python sudah cukup.

neva256-0.1.0/neva256.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+neva256/__init__.py
+neva256/cli.py
+neva256/py.typed
+neva256.egg-info/PKG-INFO
+neva256.egg-info/SOURCES.txt
+neva256.egg-info/dependency_links.txt
+neva256.egg-info/entry_points.txt
+neva256.egg-info/requires.txt
+neva256.egg-info/top_level.txt
+tests/test_neva.py

neva256-0.1.0/neva256.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

neva256-0.1.0/neva256.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+neva256 = neva256.cli:main

neva256-0.1.0/neva256.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[fast]
+neva256-native<0.2,>=0.1.0

neva256-0.1.0/neva256.egg-info/top_level.txt

@@ -0,0 +1 @@
+neva256

neva256-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "neva256"
+version = "0.1.0"
+description = "NEVA-256: experimental self-synchronizing cipher (NOT for production secrets)"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+authors = [{ name = "EWX-AI" }]
+keywords = ["cipher", "experimental", "self-synchronizing", "educational", "ctf"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Security :: Cryptography",
+    "Topic :: Education",
+]
+dependencies = []
+
+[project.optional-dependencies]
+fast = ["neva256-native>=0.1.0,<0.2"]
+
+[project.urls]
+Homepage = "https://github.com/ewxai/ewxai"
+Repository = "https://github.com/ewxai/ewxai"
+
+[project.scripts]
+neva256 = "neva256.cli:main"
+
+[tool.setuptools]
+packages = ["neva256"]
+
+[tool.setuptools.package-data]
+neva256 = ["py.typed"]

neva256-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

neva256-0.1.0/tests/test_neva.py

@@ -0,0 +1,160 @@
+"""Tests for the NEVA-256 Python port.
+
+Includes known-answer vectors produced by the TypeScript implementation
+(``src/neva/neva.ts``) to guarantee bit-exact cross-language compatibility.
+"""
+
+import os
+import unittest
+
+from neva256 import (
+    KEY_BYTES,
+    NATIVE_AVAILABLE,
+    NONCE_BYTES,
+    TAG_BYTES,
+    NevaCipher,
+    NevaError,
+    generate_key,
+    generate_nonce,
+)
+
+# Known-answer vectors generated with the TypeScript implementation.
+KAT_KEY = bytes.fromhex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
+KAT_NONCE = bytes.fromhex("f0e1d2c3b4a5968778695a4b3c2d1e0f")
+KAT = [
+    ("", "N4YwZ1bf1M/ydRjWfgXtMA=="),
+    ("a", "FnerAJQGbirLgGg+pxB2JO0="),
+    ("halo dunia", "yLbIIB8GBvVN+R0JO/vueBpPXGpT9Bnigj0="),
+    ("NEVA-256 🌪️ unicode test", "x1Fz4ZaaeaEA/H7hTxePjeO3ObyTGArR9QpBswSUJBnVmmsOcRAy1A4lvyrC"),
+    (
+        "x" * 64,
+        "tkR0wQ9QyBKIEtmBrq3ESLIQs5wvO9vhIILU2RODOg98v2ZvGsXs3/1UuLnEIhRz9dLQAcfhjeF01EOQG8oYfQvxx7cDgzUMKfXrpSTmiAs=",
+    ),
+    ("0123456789abcdef", "3M5USVJYDuNHgNJpm6xQJekFSrvWnSgHbVWP4/jKutc="),
+]
+
+
+class TestKnownAnswers(unittest.TestCase):
+    def test_matches_typescript_vectors(self):
+        for text, expected in KAT:
+            with self.subTest(text=text[:20]):
+                cipher = NevaCipher(KAT_KEY, KAT_NONCE)
+                self.assertEqual(cipher.encrypt_text(text), expected)
+                self.assertEqual(NevaCipher(KAT_KEY, KAT_NONCE).decrypt_text(expected), text)
+
+
+class TestRoundTrip(unittest.TestCase):
+    def test_many_sizes(self):
+        for size in (0, 1, 2, 5, 16, 31, 32, 255, 1000, 4096):
+            with self.subTest(size=size):
+                data = os.urandom(size)
+                cipher = NevaCipher(generate_key(), generate_nonce())
+                self.assertEqual(cipher.decrypt_bytes(cipher.encrypt_bytes(data)), data)
+
+    def test_unicode_text(self):
+        cipher = NevaCipher(generate_key(), generate_nonce())
+        text = "Halo dunia! 🌪️ NEVA-256 — vortex 👾 émojis + ascii"
+        self.assertEqual(cipher.decrypt_text(cipher.encrypt_text(text)), text)
+
+    def test_deterministic(self):
+        key, nonce, data = generate_key(), generate_nonce(), os.urandom(64)
+        a = NevaCipher(key, nonce).encrypt_bytes(data)
+        b = NevaCipher(key, nonce).encrypt_bytes(data)
+        self.assertEqual(a, b)
+
+    def test_nonce_changes_output(self):
+        key, data = generate_key(), os.urandom(64)
+        a = NevaCipher(key, generate_nonce()).encrypt_bytes(data)
+        b = NevaCipher(key, generate_nonce()).encrypt_bytes(data)
+        self.assertNotEqual(a, b)
+
+
+class TestSecurityProperties(unittest.TestCase):
+    def test_wrong_key_rejected(self):
+        cipher = NevaCipher(KAT_KEY, KAT_NONCE)
+        blob = cipher.encrypt_bytes(b"secret")
+        other = NevaCipher(generate_key(), KAT_NONCE)
+        with self.assertRaises(NevaError):
+            other.decrypt_bytes(blob)
+
+    def test_tampering_detected(self):
+        cipher = NevaCipher(KAT_KEY, KAT_NONCE)
+        blob = bytearray(cipher.encrypt_bytes(os.urandom(512)))
+        blob[100] ^= 0xFF
+        with self.assertRaises(NevaError):
+            cipher.decrypt_bytes(bytes(blob))
+
+    def test_resilient_mode_localizes_damage(self):
+        cipher = NevaCipher(KAT_KEY, KAT_NONCE)
+        data = os.urandom(10000)
+        blob = bytearray(cipher.encrypt_bytes(data))
+        blob[5000] ^= 0x40
+        out = cipher.decrypt_bytes(bytes(blob), verify=False)
+        damaged = sum(1 for i in range(len(data)) if out[i] != data[i])
+        self.assertLessEqual(damaged, 6)
+
+    def test_size_validation(self):
+        with self.assertRaises(NevaError):
+            NevaCipher(bytes(KEY_BYTES - 1))
+        with self.assertRaises(NevaError):
+            NevaCipher(generate_key(), bytes(NONCE_BYTES + 1))
+
+    def test_short_ciphertext_rejected(self):
+        cipher = NevaCipher(KAT_KEY, KAT_NONCE)
+        with self.assertRaises(NevaError):
+            cipher.decrypt_bytes(b"too short")
+
+
+class TestBackends(unittest.TestCase):
+    def test_pure_backend_can_be_forced(self):
+        cipher = NevaCipher(KAT_KEY, KAT_NONCE, use_native=False)
+        self.assertEqual(cipher.backend, "python")
+        self.assertEqual(cipher.encrypt_text("abc"), NevaCipher(KAT_KEY, KAT_NONCE, use_native=False).encrypt_text("abc"))
+
+    @unittest.skipUnless(NATIVE_AVAILABLE, "neva256-native not installed")
+    def test_native_backend_selected(self):
+        cipher = NevaCipher(KAT_KEY, KAT_NONCE, use_native=True)
+        self.assertEqual(cipher.backend, "native")
+        for text, expected in KAT:
+            self.assertEqual(cipher.encrypt_text(text), expected)
+
+    @unittest.skipUnless(NATIVE_AVAILABLE, "neva256-native not installed")
+    def test_native_matches_pure_python_exactly(self):
+        key, nonce = generate_key(), generate_nonce()
+        native = NevaCipher(key, nonce, use_native=True)
+        pure = NevaCipher(key, nonce, use_native=False)
+        for size in (0, 1, 2, 31, 255, 1000, 4096):
+            with self.subTest(size=size):
+                data = os.urandom(size)
+                self.assertEqual(native.encrypt_bytes(data), pure.encrypt_bytes(data))
+
+    @unittest.skipUnless(NATIVE_AVAILABLE, "neva256-native not installed")
+    def test_cross_backend_round_trip(self):
+        key, nonce = generate_key(), generate_nonce()
+        native = NevaCipher(key, nonce, use_native=True)
+        pure = NevaCipher(key, nonce, use_native=False)
+        data = os.urandom(500)
+        self.assertEqual(pure.decrypt_bytes(native.encrypt_bytes(data)), data)
+        self.assertEqual(native.decrypt_bytes(pure.encrypt_bytes(data)), data)
+
+    @unittest.skipUnless(NATIVE_AVAILABLE, "neva256-native not installed")
+    def test_native_reports_tampering_as_neva_error(self):
+        cipher = NevaCipher(KAT_KEY, KAT_NONCE, use_native=True)
+        blob = bytearray(cipher.encrypt_bytes(b"secret data"))
+        blob[20] ^= 0x01
+        with self.assertRaises(NevaError):
+            cipher.decrypt_bytes(bytes(blob))
+
+    @unittest.skipUnless(NATIVE_AVAILABLE, "neva256-native not installed")
+    def test_native_resilient_mode(self):
+        cipher = NevaCipher(KAT_KEY, KAT_NONCE, use_native=True)
+        data = os.urandom(4096)
+        blob = bytearray(cipher.encrypt_bytes(data))
+        blob[2048] ^= 0x40
+        out = cipher.decrypt_bytes(bytes(blob), verify=False)
+        damaged = sum(1 for i in range(len(data)) if out[i] != data[i])
+        self.assertLessEqual(damaged, 6)
+
+
+if __name__ == "__main__":
+    unittest.main()