nxd 0.1.0__tar.gz

nxd-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nexplora Labs
+
+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:
+
+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 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.

nxd-0.1.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: nxd
+Version: 0.1.0
+Summary: Encrypted compute layer for AI agents
+Author: Nexplora Labs
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Nexploraai/nxd
+Project-URL: Repository, https://github.com/Nexploraai/nxd
+Project-URL: Issues, https://github.com/Nexploraai/nxd/issues
+Keywords: fhe,encryption,ai-agents,privacy,homomorphic-encryption
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: <3.12,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: concrete-ml==1.9.0
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: scikit-learn>=1.5.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# NXD
+
+NXD is an encrypted compute layer for AI agents. It wraps fully homomorphic encryption, credential vaulting, and privacy primitives behind a single Python import — so developers can run agents on sensitive data without exposing client records, credentials, or proprietary code to models, clouds, or MCP servers.
+
+## Three guarantees
+
+1. **The agent works fully** — capability unchanged; scores, matches, charges, and aggregates complete normally.
+2. **The agent sees nothing** — sensitive values stay encrypted; agents handle opaque tokens and references only.
+3. **The operator holds the keys** — keys stay local, auditable, and revocable.
+
+## Install
+
+```bash
+pip install nxd
+```
+
+Requires Python 3.10 or 3.11 (Concrete ML FHE dependency).
+
+## Quick start
+
+```python
+import nxd
+
+# FHE compute on encrypted data
+results = nxd.score(model, clients)
+matched  = nxd.match(model, record_a, record_b)
+average  = nxd.aggregate(model, records)
+
+# Credentials — agent never sees plaintext keys
+vault = nxd.Vault(agent_id="billing-agent")
+vault.store("stripe_key", "sk_live_xxxx")
+result = vault.use("stripe_key", stripe_charge_fn)
+vault.audit_log()
+
+# Agent-to-agent encrypted context
+handoff = nxd.Handoff()
+token = handoff.pack(clients)
+scores = nxd.receive(model, token, handoff)
+
+# Code and text privacy before any AI call
+protected = nxd.shield(source_code)
+original = nxd.unshield(protected)
+
+# Encrypted search, identity, tokenization, PII redaction
+index = nxd.build_index(records)
+token, hits = nxd.search(index, "diabetes")
+nxd.register("user_123", "credential")
+nxd.verify("user_123", candidate)
+safe = nxd.redact("Patient John Smith, SSN 432-12-6789")
+token = nxd.tokenize("4532-1234-5678-9010")
+
+# Documents, channels, state, signatures
+nxd.seal("contract.pdf")
+ch = nxd.channel("agent-a", "agent-b")
+nxd.checkpoint.save("agent-123", state)
+nxd.sign("agent-a", "approve payment")
+
+# Privacy analytics, key control, audit
+nxd.blur(47230.0, sensitivity=1000, epsilon=1.0)
+shares = nxd.split("master_key", n=5, m=3)
+locked = nxd.bind(data, recipient="agent-compliance-7")
+nxd.audit.verify()
+```
+
+## Benchmarks (MacBook Air, Python 3.11, Concrete ML 1.9.0)
+
+| Operation | Latency | Notes |
+|-----------|---------|-------|
+| FHE score (1 record) | ~183 ms | First-call cold start |
+| FHE score (1k records, parallel) | **1.6 s** | 8 cores, ~1.6 ms/record |
+| FHE match (single pair) | **352 ms** | Cross-system comparison |
+| FHE aggregate (1k records, parallel) | **1.8 s** | ~0.009% quantization error |
+| Credential vault use | <1 ms | Decrypt in memory only |
+| Proof suite | **85/85 passed** | `python3 prove.py` |
+
+## Development
+
+```bash
+git clone https://github.com/Nexploraai/nxd
+cd nxd
+pip install -e ".[dev]"
+python3 prove.py
+python3 agent.py
+python3 demo.py
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

nxd-0.1.0/README.md

@@ -0,0 +1,89 @@
+# NXD
+
+NXD is an encrypted compute layer for AI agents. It wraps fully homomorphic encryption, credential vaulting, and privacy primitives behind a single Python import — so developers can run agents on sensitive data without exposing client records, credentials, or proprietary code to models, clouds, or MCP servers.
+
+## Three guarantees
+
+1. **The agent works fully** — capability unchanged; scores, matches, charges, and aggregates complete normally.
+2. **The agent sees nothing** — sensitive values stay encrypted; agents handle opaque tokens and references only.
+3. **The operator holds the keys** — keys stay local, auditable, and revocable.
+
+## Install
+
+```bash
+pip install nxd
+```
+
+Requires Python 3.10 or 3.11 (Concrete ML FHE dependency).
+
+## Quick start
+
+```python
+import nxd
+
+# FHE compute on encrypted data
+results = nxd.score(model, clients)
+matched  = nxd.match(model, record_a, record_b)
+average  = nxd.aggregate(model, records)
+
+# Credentials — agent never sees plaintext keys
+vault = nxd.Vault(agent_id="billing-agent")
+vault.store("stripe_key", "sk_live_xxxx")
+result = vault.use("stripe_key", stripe_charge_fn)
+vault.audit_log()
+
+# Agent-to-agent encrypted context
+handoff = nxd.Handoff()
+token = handoff.pack(clients)
+scores = nxd.receive(model, token, handoff)
+
+# Code and text privacy before any AI call
+protected = nxd.shield(source_code)
+original = nxd.unshield(protected)
+
+# Encrypted search, identity, tokenization, PII redaction
+index = nxd.build_index(records)
+token, hits = nxd.search(index, "diabetes")
+nxd.register("user_123", "credential")
+nxd.verify("user_123", candidate)
+safe = nxd.redact("Patient John Smith, SSN 432-12-6789")
+token = nxd.tokenize("4532-1234-5678-9010")
+
+# Documents, channels, state, signatures
+nxd.seal("contract.pdf")
+ch = nxd.channel("agent-a", "agent-b")
+nxd.checkpoint.save("agent-123", state)
+nxd.sign("agent-a", "approve payment")
+
+# Privacy analytics, key control, audit
+nxd.blur(47230.0, sensitivity=1000, epsilon=1.0)
+shares = nxd.split("master_key", n=5, m=3)
+locked = nxd.bind(data, recipient="agent-compliance-7")
+nxd.audit.verify()
+```
+
+## Benchmarks (MacBook Air, Python 3.11, Concrete ML 1.9.0)
+
+| Operation | Latency | Notes |
+|-----------|---------|-------|
+| FHE score (1 record) | ~183 ms | First-call cold start |
+| FHE score (1k records, parallel) | **1.6 s** | 8 cores, ~1.6 ms/record |
+| FHE match (single pair) | **352 ms** | Cross-system comparison |
+| FHE aggregate (1k records, parallel) | **1.8 s** | ~0.009% quantization error |
+| Credential vault use | <1 ms | Decrypt in memory only |
+| Proof suite | **85/85 passed** | `python3 prove.py` |
+
+## Development
+
+```bash
+git clone https://github.com/Nexploraai/nxd
+cd nxd
+pip install -e ".[dev]"
+python3 prove.py
+python3 agent.py
+python3 demo.py
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

nxd-0.1.0/nxd/__init__.py

@@ -0,0 +1,65 @@
+"""
+NXD — encrypted agent operating system.
+
+Three guarantees:
+  1. The agent works fully
+  2. The agent sees nothing
+  3. The operator holds the keys
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from nxd.audit import export as audit_export
+from nxd.audit import log as audit_log
+from nxd.audit import verify as audit_verify
+from nxd.bind import BindingError, bind, open
+from nxd.blur import blur, blur_dataset, blur_guide, blur_report
+from nxd.channel import Channel, ChannelClosedError, channel
+from nxd.checkpoint import checkpoint
+from nxd.fhe import aggregate, match, score
+from nxd.handoff import Handoff
+from nxd.redact import deredact, redact
+from nxd.search import SearchIndex, build_index, retrieve, search
+from nxd.seal import seal, seal_text, unseal, unseal_text
+from nxd.shield import send_to_model, shield, unshield
+from nxd.sign import sign, sign_record, verify_record, verify_signature
+from nxd.split import InsufficientSharesError, distribute, reconstruct_strict, split
+from nxd.tokenize import detokenize, tokenize, tokenize_record
+from nxd.vault import Vault
+from nxd.verify import LockedError, register, unlock, verify
+
+Mode = Literal["auto", "fast", "secure"]
+
+__all__ = [
+    "score", "match", "aggregate", "receive",
+    "Vault", "Handoff",
+    "shield", "unshield", "send_to_model",
+    "build_index", "search", "retrieve", "SearchIndex",
+    "register", "verify", "unlock", "LockedError",
+    "tokenize", "detokenize", "tokenize_record",
+    "redact", "deredact",
+    "seal", "unseal", "seal_text", "unseal_text",
+    "channel", "Channel", "ChannelClosedError",
+    "checkpoint",
+    "sign", "verify_signature", "sign_record", "verify_record",
+    "blur", "blur_dataset", "blur_report", "blur_guide",
+    "split", "reconstruct_strict", "distribute", "InsufficientSharesError",
+    "bind", "open", "BindingError",
+    "audit_log", "audit_verify", "audit_export",
+    "Mode",
+]
+
+
+def receive(model: Any, token: str, handoff: Handoff, mode: Mode = "auto") -> list[int]:
+    """Agent B scores encrypted handoff context."""
+    context = handoff.unpack(token)
+    clients = context if isinstance(context, list) else [context]
+    return score(model, clients, mode=mode)
+
+
+class audit:
+    log = staticmethod(audit_log)
+    verify = staticmethod(audit_verify)
+    export = staticmethod(audit_export)

nxd-0.1.0/nxd/_crypto.py

@@ -0,0 +1,46 @@
+"""Shared cryptography utilities for NXD."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+from pathlib import Path
+
+from cryptography.fernet import Fernet
+
+DEFAULT_DATA_DIR = Path.home() / ".nxd"
+MASTER_KEY_FILE = "master.key"
+
+
+def data_dir() -> Path:
+    import os
+    path = Path(os.environ.get("NXD_DATA_DIR", DEFAULT_DATA_DIR))
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def master_key_path() -> Path:
+    return data_dir() / MASTER_KEY_FILE
+
+
+def load_fernet(key_path: Path | None = None) -> Fernet:
+    path = key_path or master_key_path()
+    if path.exists():
+        key = path.read_bytes()
+    else:
+        key = Fernet.generate_key()
+        path.write_bytes(key)
+        os.chmod(path, 0o600)
+    return Fernet(key)
+
+
+def load_hmac_key() -> bytes:
+    return hashlib.sha256(master_key_path().read_bytes()).digest()
+
+
+def encrypt_bytes(data: bytes, fernet: Fernet | None = None) -> bytes:
+    return (fernet or load_fernet()).encrypt(data)
+
+
+def decrypt_bytes(token: bytes, fernet: Fernet | None = None) -> bytes:
+    return (fernet or load_fernet()).decrypt(token)

nxd-0.1.0/nxd/audit.py

@@ -0,0 +1,86 @@
+"""Tamper-proof audit chain for all NXD operations."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+from nxd._crypto import data_dir
+
+AUDIT_FILE = "audit_chain.jsonl"
+
+
+class AuditChain:
+    def __init__(self, path: Path | None = None):
+        self.path = path or (data_dir() / AUDIT_FILE)
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        if not self.path.exists():
+            self.path.write_text("")
+
+    def _last_hash(self) -> str:
+        lines = [l for l in self.path.read_text().splitlines() if l.strip()]
+        if not lines:
+            return "genesis"
+        return json.loads(lines[-1])["hash"]
+
+    def log(self, operation: str, **meta: Any) -> dict:
+        prev = self._last_hash()
+        entry = {
+            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            "operation": operation,
+            "meta": meta,
+            "prev_hash": prev,
+        }
+        payload = json.dumps(entry, sort_keys=True)
+        entry["hash"] = hashlib.sha256((prev + payload).encode()).hexdigest()
+        with self.path.open("a") as f:
+            f.write(json.dumps(entry) + "\n")
+        return entry
+
+    def entries(self) -> list[dict]:
+        return [json.loads(l) for l in self.path.read_text().splitlines() if l.strip()]
+
+    def verify(self) -> tuple[bool, int | None]:
+        lines = self.entries()
+        prev = "genesis"
+        for i, entry in enumerate(lines):
+            stored = entry.pop("hash")
+            payload = json.dumps(entry, sort_keys=True)
+            expected = hashlib.sha256((prev + payload).encode()).hexdigest()
+            if stored != expected:
+                entry["hash"] = stored
+                return False, i
+            prev = stored
+            entry["hash"] = stored
+        return True, None
+
+    def export(self, out_path: str | Path) -> Path:
+        out = Path(out_path)
+        report = {"chain_valid": self.verify()[0], "entries": self.entries()}
+        out.write_text(json.dumps(report, indent=2))
+        return out
+
+
+_audit = AuditChain()
+
+
+def log(operation: str, **meta: Any) -> dict:
+    return _audit.log(operation, **meta)
+
+
+def verify() -> tuple[bool, int | None]:
+    return _audit.verify()
+
+
+def export(out_path: str | Path) -> Path:
+    return _audit.export(out_path)
+
+
+def reset_for_tests(path: Path) -> None:
+    global _audit
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("")
+    _audit = AuditChain(path)

nxd-0.1.0/nxd/bind.py

@@ -0,0 +1,50 @@
+"""Data binding — encrypt locked to specific recipient and purpose."""
+
+from __future__ import annotations
+
+import base64
+import json
+
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+
+from nxd._crypto import master_key_path
+
+
+class BindingError(Exception):
+    pass
+
+
+def _derive_key(recipient: str, purpose: str = "") -> Fernet:
+    seed = master_key_path().read_bytes()
+    derived = HKDF(
+        algorithm=hashes.SHA256(),
+        length=32,
+        salt=b"nxd-bind",
+        info=f"{recipient}:{purpose}".encode(),
+    ).derive(seed)
+    key = base64.urlsafe_b64encode(derived)
+    return Fernet(key)
+
+
+def bind(data: str, recipient: str, purpose: str = "") -> str:
+    from nxd import audit
+    payload = json.dumps({"data": data, "recipient": recipient, "purpose": purpose})
+    token = _derive_key(recipient, purpose).encrypt(payload.encode()).decode()
+    audit.log("bind", recipient=recipient, purpose=purpose)
+    return token
+
+
+def open(locked: str, caller: str, purpose: str = "") -> str:
+    from nxd import audit
+    try:
+        payload = json.loads(_derive_key(caller, purpose).decrypt(locked.encode()).decode())
+    except Exception as e:
+        raise BindingError(f"Access denied for {caller}") from e
+    if payload["recipient"] != caller:
+        raise BindingError(f"Bound to {payload['recipient']}, not {caller}")
+    if purpose and payload.get("purpose") and payload["purpose"] != purpose:
+        raise BindingError(f"Bound to purpose '{payload['purpose']}', not '{purpose}'")
+    audit.log("open", caller=caller, purpose=purpose)
+    return payload["data"]

nxd-0.1.0/nxd/blur.py

@@ -0,0 +1,41 @@
+"""Differential privacy — blur aggregates for safe sharing."""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def blur(value: float, sensitivity: float = 1.0, epsilon: float = 1.0) -> float:
+    from nxd import audit
+    scale = sensitivity / epsilon
+    noise = np.random.laplace(0, scale)
+    result = float(value + noise)
+    audit.log("blur", epsilon=epsilon)
+    return result
+
+
+def blur_dataset(values: list[float], sensitivity: float = 1.0, epsilon: float = 1.0) -> list[float]:
+    from nxd import audit
+    result = [blur(v, sensitivity, epsilon) for v in values]
+    audit.log("blur_dataset", count=len(values))
+    return result
+
+
+def blur_report(records: list[dict], fields: list[str], epsilon: float = 1.0) -> dict:
+    from nxd import audit
+    report = {}
+    for field in fields:
+        vals = [float(r[field]) for r in records if field in r]
+        if vals:
+            noisy = blur_dataset(vals, sensitivity=max(vals) * 0.1, epsilon=epsilon)
+            report[field] = {"mean": float(np.mean(noisy)), "std": float(np.std(noisy))}
+    audit.log("blur_report", fields=fields)
+    return report
+
+
+def blur_guide() -> str:
+    return (
+        "epsilon=0.1: very strong privacy, less accuracy\n"
+        "epsilon=1.0: balanced\n"
+        "epsilon=10.0: weak privacy, high accuracy"
+    )

nxd-0.1.0/nxd/channel.py

@@ -0,0 +1,63 @@
+"""Encrypted channels — E2E messaging between agents."""
+
+from __future__ import annotations
+
+import base64
+import json
+import time
+
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+
+from nxd._crypto import master_key_path
+
+
+class ChannelClosedError(Exception):
+    pass
+
+
+def _session_fernet(sender: str, receiver: str) -> Fernet:
+    seed = master_key_path().read_bytes()
+    derived = HKDF(
+        algorithm=hashes.SHA256(),
+        length=32,
+        salt=b"nxd-channel",
+        info=f"{sender}:{receiver}".encode(),
+    ).derive(seed)
+    key = base64.urlsafe_b64encode(derived)
+    return Fernet(key)
+
+
+class Channel:
+    def __init__(self, sender: str, receiver: str):
+        self.sender = sender
+        self.receiver = receiver
+        self._closed = False
+        self._fernet = _session_fernet(sender, receiver)
+
+    def send(self, message: str) -> str:
+        from nxd import audit
+        if self._closed:
+            raise ChannelClosedError("Channel is closed")
+        packet = json.dumps({"ts": time.time(), "msg": message}).encode()
+        token = self._fernet.encrypt(packet).decode()
+        audit.log("channel_send", sender=self.sender, receiver=self.receiver)
+        return token
+
+    def receive(self, packet: str) -> str:
+        from nxd import audit
+        if self._closed:
+            raise ChannelClosedError("Channel is closed")
+        payload = json.loads(self._fernet.decrypt(packet.encode()).decode())
+        audit.log("channel_receive", receiver=self.receiver)
+        return payload["msg"]
+
+    def close(self) -> None:
+        from nxd import audit
+        self._closed = True
+        audit.log("channel_close", sender=self.sender, receiver=self.receiver)
+
+
+def channel(sender: str, receiver: str) -> Channel:
+    return Channel(sender, receiver)

nxd-0.1.0/nxd/checkpoint.py

@@ -0,0 +1,75 @@
+"""Agent state persistence — encrypted checkpoints."""
+
+from __future__ import annotations
+
+import gzip
+import json
+import time
+from pathlib import Path
+
+from nxd._crypto import data_dir, load_fernet
+
+
+class CheckpointStore:
+    def __init__(self, path: Path | None = None):
+        self.dir = path or (data_dir() / "checkpoints")
+        self.dir.mkdir(parents=True, exist_ok=True)
+
+    def _file(self, agent_id: str) -> Path:
+        return self.dir / f"{agent_id}.nxd"
+
+    def save(self, agent_id: str, state: dict) -> Path:
+        from nxd import audit
+        f = load_fernet()
+        meta = {"agent_id": agent_id, "timestamp": time.time(), "keys": list(state.keys())}
+        payload = gzip.compress(json.dumps({"meta": meta, "state": state}).encode())
+        out = self._file(agent_id)
+        out.write_bytes(f.encrypt(payload))
+        audit.log("checkpoint_save", agent_id=agent_id)
+        return out
+
+    def load(self, agent_id: str) -> dict:
+        from nxd import audit
+        out = self._file(agent_id)
+        if not out.exists():
+            raise FileNotFoundError(f"No checkpoint for {agent_id}")
+        f = load_fernet()
+        payload = gzip.decompress(f.decrypt(out.read_bytes()))
+        data = json.loads(payload.decode())
+        audit.log("checkpoint_load", agent_id=agent_id)
+        return data["state"]
+
+    def list_checkpoints(self) -> list[str]:
+        entries = []
+        for p in self.dir.glob("*.nxd"):
+            try:
+                f = load_fernet()
+                payload = gzip.decompress(f.decrypt(p.read_bytes()))
+                meta = json.loads(payload.decode())["meta"]
+                ts = time.strftime("%Y-%m-%d %H:%M", time.localtime(meta["timestamp"]))
+                entries.append(f"{meta['agent_id']} | {ts} | {len(meta['keys'])} keys")
+            except Exception:
+                entries.append(p.stem)
+        return entries
+
+    def purge(self, agent_id: str) -> None:
+        from nxd import audit
+        out = self._file(agent_id)
+        if out.exists():
+            out.unlink()
+        audit.log("checkpoint_purge", agent_id=agent_id)
+
+
+_store = CheckpointStore()
+
+
+class checkpoint:
+    save = staticmethod(lambda agent_id, state: _store.save(agent_id, state))
+    load = staticmethod(lambda agent_id: _store.load(agent_id))
+    list = staticmethod(lambda: _store.list_checkpoints())
+    purge = staticmethod(lambda agent_id: _store.purge(agent_id))
+
+
+def reset_for_tests(path: Path) -> None:
+    global _store
+    _store = CheckpointStore(path)