h33 0.1.0__tar.gz

h33-0.1.0/LICENSE

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

h33-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include h33 *.py

h33-0.1.0/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: h33
+Version: 0.1.0
+Summary: H33 Post-Quantum Encryption SDK — Kyber + AES-256-GCM hybrid encryption, FHE biometrics, and more
+Home-page: https://h33.ai
+Author: H33.ai
+Author-email: sdk@h33.ai
+License: MIT
+Project-URL: Homepage, https://h33.ai
+Project-URL: Documentation, https://h33.ai/docs
+Project-URL: API Reference, https://h33.ai/apis
+Project-URL: Benchmarks, https://h33.ai/benchmarks
+Project-URL: White Paper, https://h33.ai/white-paper
+Project-URL: Source, https://github.com/h33-ai/h33-python-sdk
+Project-URL: Issues, https://github.com/h33-ai/h33-python-sdk/issues
+Keywords: post-quantum,encryption,cryptography,fhe,homomorphic-encryption,kyber,dilithium,biometrics,zero-knowledge,pqc,ml-kem,ml-dsa
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Provides-Extra: fhe
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# h33 — Post-Quantum Encryption SDK for Python
+
+The official Python SDK for [H33](https://h33.ai), the post-quantum encryption platform delivering 1.6M authentications/sec with lattice-based cryptography.
+
+## Install
+
+```bash
+pip install h33
+```
+
+## Quick Start
+
+```python
+from h33 import H33Client
+
+client = H33Client(api_key="h33_live_...", base_url="https://api.h33.ai")
+
+# Post-quantum storage encryption (Kyber + AES-256-GCM)
+result = client.encrypt_blob(b"sensitive data")
+ciphertext = result["ciphertext_b64"]
+key_id = result["key_id"]
+
+# Decrypt
+plaintext = client.decrypt_blob(ciphertext, key_id)
+assert plaintext == b"sensitive data"
+```
+
+## Storage Encryption
+
+Encrypt data at rest with hybrid post-quantum encryption (ML-KEM/Kyber + AES-256-GCM):
+
+```python
+from h33 import StorageClient
+
+storage = StorageClient(api_key="h33_live_...")
+
+# Encrypt with optional authenticated data
+result = storage.encrypt(b"patient record", aad=b"user:12345")
+print(result["key_id"])  # Kyber key ID for decryption
+
+# Decrypt
+plaintext = storage.decrypt(result["ciphertext_b64"], result["key_id"], aad=b"user:12345")
+
+# Field-level encryption with automatic sensitivity classification
+fields = storage.encrypt_fields([
+    {"name": "ssn", "value": "123-45-6789"},
+    {"name": "name", "value": "Jane Doe"},
+    {"name": "email", "value": "jane@example.com"},
+])
+# Each field gets a sensitivity level (Confidential, Internal, etc.)
+
+# Key rotation — re-encrypt under the current active key
+rotated = storage.rotate(result["ciphertext_b64"], result["key_id"])
+```
+
+## Client-Side FHE (Homomorphic Encryption)
+
+Encrypt biometric embeddings on the client so the server never sees plaintext:
+
+```python
+from h33 import FheEncryptor
+
+# Load public key from H33 API
+enc = FheEncryptor.from_public_key("public_key.json", embedding_dim=128)
+
+# Encrypt a 128-dimensional face embedding
+embedding = [0.1, 0.2, 0.03, ...]  # from your ML model
+ciphertext_json = enc.encrypt_embedding(embedding)
+
+# Send ciphertext to H33 for matching — server operates on encrypted data
+```
+
+Requires the `h33-fhe-client` native library. Build from source:
+
+```bash
+cd h33-fhe-client && cargo build --release
+```
+
+## API Reference
+
+### H33Client
+
+| Method | Description |
+|--------|-------------|
+| `health()` | Check API status |
+| `send_code(phone)` | Send SMS OTP for authentication |
+| `verify_code(phone, code)` | Verify OTP and get session |
+| `create_key(label)` | Create a new API key |
+| `list_keys()` | List all API keys |
+| `revoke_key(key_id)` | Revoke an API key |
+| `encrypt_blob(plaintext, aad)` | PQ-encrypt arbitrary data |
+| `decrypt_blob(ciphertext_b64, key_id, aad)` | Decrypt PQ-encrypted data |
+| `encrypt_fields(fields)` | Field-level PQ encryption |
+| `rotate_encryption(ciphertext_b64, old_key_id, aad)` | Re-encrypt under current key |
+| `fhe_schemes()` | List available FHE schemes |
+| `noise_estimate(n, t, q_bits, operations)` | Estimate FHE noise budget |
+
+### StorageClient
+
+Convenience wrapper for encryption-only workflows:
+
+| Method | Description |
+|--------|-------------|
+| `encrypt(plaintext, aad)` | Encrypt bytes |
+| `decrypt(ciphertext_b64, key_id, aad)` | Decrypt bytes |
+| `encrypt_fields(fields)` | Field-level encryption |
+| `rotate(ciphertext_b64, old_key_id, aad)` | Key rotation |
+
+## Platform
+
+H33 is the world's fastest post-quantum authentication platform:
+
+- **1.6M auth/sec** on AWS Graviton4 (96 vCPUs)
+- **~42 microseconds** per authentication
+- **Kyber + AES-256-GCM** hybrid encryption for data at rest
+- **BFV Fully Homomorphic Encryption** for biometric matching on encrypted data
+- **Dilithium digital signatures** for attestation
+- **Zero-knowledge proofs** for privacy-preserving verification
+
+Learn more at [h33.ai](https://h33.ai)
+
+## Documentation
+
+- [H33 Platform](https://h33.ai)
+- [API Documentation](https://h33.ai/docs)
+- [FHE Overview](https://h33.ai/fhe)
+- [Post-Quantum Cryptography](https://h33.ai/pqc)
+- [White Paper](https://h33.ai/white-paper)
+- [Benchmarks](https://h33.ai/benchmarks)
+
+## License
+
+MIT — see [LICENSE](LICENSE)

h33-0.1.0/README.md

@@ -0,0 +1,133 @@
+# h33 — Post-Quantum Encryption SDK for Python
+
+The official Python SDK for [H33](https://h33.ai), the post-quantum encryption platform delivering 1.6M authentications/sec with lattice-based cryptography.
+
+## Install
+
+```bash
+pip install h33
+```
+
+## Quick Start
+
+```python
+from h33 import H33Client
+
+client = H33Client(api_key="h33_live_...", base_url="https://api.h33.ai")
+
+# Post-quantum storage encryption (Kyber + AES-256-GCM)
+result = client.encrypt_blob(b"sensitive data")
+ciphertext = result["ciphertext_b64"]
+key_id = result["key_id"]
+
+# Decrypt
+plaintext = client.decrypt_blob(ciphertext, key_id)
+assert plaintext == b"sensitive data"
+```
+
+## Storage Encryption
+
+Encrypt data at rest with hybrid post-quantum encryption (ML-KEM/Kyber + AES-256-GCM):
+
+```python
+from h33 import StorageClient
+
+storage = StorageClient(api_key="h33_live_...")
+
+# Encrypt with optional authenticated data
+result = storage.encrypt(b"patient record", aad=b"user:12345")
+print(result["key_id"])  # Kyber key ID for decryption
+
+# Decrypt
+plaintext = storage.decrypt(result["ciphertext_b64"], result["key_id"], aad=b"user:12345")
+
+# Field-level encryption with automatic sensitivity classification
+fields = storage.encrypt_fields([
+    {"name": "ssn", "value": "123-45-6789"},
+    {"name": "name", "value": "Jane Doe"},
+    {"name": "email", "value": "jane@example.com"},
+])
+# Each field gets a sensitivity level (Confidential, Internal, etc.)
+
+# Key rotation — re-encrypt under the current active key
+rotated = storage.rotate(result["ciphertext_b64"], result["key_id"])
+```
+
+## Client-Side FHE (Homomorphic Encryption)
+
+Encrypt biometric embeddings on the client so the server never sees plaintext:
+
+```python
+from h33 import FheEncryptor
+
+# Load public key from H33 API
+enc = FheEncryptor.from_public_key("public_key.json", embedding_dim=128)
+
+# Encrypt a 128-dimensional face embedding
+embedding = [0.1, 0.2, 0.03, ...]  # from your ML model
+ciphertext_json = enc.encrypt_embedding(embedding)
+
+# Send ciphertext to H33 for matching — server operates on encrypted data
+```
+
+Requires the `h33-fhe-client` native library. Build from source:
+
+```bash
+cd h33-fhe-client && cargo build --release
+```
+
+## API Reference
+
+### H33Client
+
+| Method | Description |
+|--------|-------------|
+| `health()` | Check API status |
+| `send_code(phone)` | Send SMS OTP for authentication |
+| `verify_code(phone, code)` | Verify OTP and get session |
+| `create_key(label)` | Create a new API key |
+| `list_keys()` | List all API keys |
+| `revoke_key(key_id)` | Revoke an API key |
+| `encrypt_blob(plaintext, aad)` | PQ-encrypt arbitrary data |
+| `decrypt_blob(ciphertext_b64, key_id, aad)` | Decrypt PQ-encrypted data |
+| `encrypt_fields(fields)` | Field-level PQ encryption |
+| `rotate_encryption(ciphertext_b64, old_key_id, aad)` | Re-encrypt under current key |
+| `fhe_schemes()` | List available FHE schemes |
+| `noise_estimate(n, t, q_bits, operations)` | Estimate FHE noise budget |
+
+### StorageClient
+
+Convenience wrapper for encryption-only workflows:
+
+| Method | Description |
+|--------|-------------|
+| `encrypt(plaintext, aad)` | Encrypt bytes |
+| `decrypt(ciphertext_b64, key_id, aad)` | Decrypt bytes |
+| `encrypt_fields(fields)` | Field-level encryption |
+| `rotate(ciphertext_b64, old_key_id, aad)` | Key rotation |
+
+## Platform
+
+H33 is the world's fastest post-quantum authentication platform:
+
+- **1.6M auth/sec** on AWS Graviton4 (96 vCPUs)
+- **~42 microseconds** per authentication
+- **Kyber + AES-256-GCM** hybrid encryption for data at rest
+- **BFV Fully Homomorphic Encryption** for biometric matching on encrypted data
+- **Dilithium digital signatures** for attestation
+- **Zero-knowledge proofs** for privacy-preserving verification
+
+Learn more at [h33.ai](https://h33.ai)
+
+## Documentation
+
+- [H33 Platform](https://h33.ai)
+- [API Documentation](https://h33.ai/docs)
+- [FHE Overview](https://h33.ai/fhe)
+- [Post-Quantum Cryptography](https://h33.ai/pqc)
+- [White Paper](https://h33.ai/white-paper)
+- [Benchmarks](https://h33.ai/benchmarks)
+
+## License
+
+MIT — see [LICENSE](LICENSE)

h33-0.1.0/h33/__init__.py

@@ -0,0 +1,7 @@
+"""H33 Post-Quantum Encryption SDK for Python."""
+
+from .client import H33Client
+from .storage import StorageClient
+
+__all__ = ["H33Client", "StorageClient"]
+__version__ = "0.1.0"

h33-0.1.0/h33/client.py

@@ -0,0 +1,183 @@
+"""H33 API Client — HTTP client for the H33 post-quantum platform."""
+
+import requests
+from typing import Optional, Dict, Any
+
+
+class H33Client:
+    """Main client for the H33 API.
+
+    Usage::
+
+        from h33 import H33Client
+
+        client = H33Client(api_key="h33_live_...", base_url="https://api.h33.ai")
+        result = client.health()
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.h33.ai",
+        timeout: int = 30,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+        self.session = requests.Session()
+        self.session.headers.update({
+            "Content-Type": "application/json",
+            "X-API-Key": api_key,
+        })
+
+    def _request(self, method: str, path: str, **kwargs) -> Dict[str, Any]:
+        url = f"{self.base_url}{path}"
+        kwargs.setdefault("timeout", self.timeout)
+        resp = self.session.request(method, url, **kwargs)
+        resp.raise_for_status()
+        return resp.json()
+
+    def health(self) -> Dict[str, Any]:
+        """Check API health."""
+        return self._request("GET", "/health")
+
+    # ── Auth (Onboarding) ─────────────────────────────────────────────────
+
+    def send_code(self, phone: str, country_code: str = "+1") -> Dict[str, Any]:
+        """Send SMS OTP verification code."""
+        return self._request("POST", "/api/auth/send-code", json={
+            "phone": phone,
+            "country_code": country_code,
+        })
+
+    def verify_code(self, phone: str, code: str) -> Dict[str, Any]:
+        """Verify OTP code and get auth cookies."""
+        return self._request("POST", "/api/auth/verify-code", json={
+            "phone": phone,
+            "code": code,
+        })
+
+    # ── Keys ──────────────────────────────────────────────────────────────
+
+    def create_key(self, label: str = "default") -> Dict[str, Any]:
+        """Create a new API key."""
+        return self._request("POST", "/api/keys/create", json={"label": label})
+
+    def list_keys(self) -> Dict[str, Any]:
+        """List all API keys."""
+        return self._request("GET", "/api/keys/list")
+
+    def revoke_key(self, key_id: str) -> Dict[str, Any]:
+        """Revoke an API key."""
+        return self._request("POST", "/api/keys/revoke", json={"key_id": key_id})
+
+    # ── Customer ──────────────────────────────────────────────────────────
+
+    def get_me(self) -> Dict[str, Any]:
+        """Get current customer profile."""
+        return self._request("GET", "/api/customer/me")
+
+    def get_usage(self) -> Dict[str, Any]:
+        """Get usage statistics."""
+        return self._request("GET", "/api/customer/usage")
+
+    # ── FHE ───────────────────────────────────────────────────────────────
+
+    def fhe_schemes(self) -> Dict[str, Any]:
+        """List available FHE schemes and parameters."""
+        return self._request("GET", "/api/fhe/schemes")
+
+    def noise_estimate(
+        self,
+        n: int,
+        t: int,
+        q_bits: list,
+        operations: list,
+    ) -> Dict[str, Any]:
+        """Estimate noise budget for a circuit.
+
+        Args:
+            n: Polynomial degree (e.g., 2048, 4096)
+            t: Plaintext modulus (e.g., 65537)
+            q_bits: Coefficient modulus bit sizes (e.g., [40, 40])
+            operations: List of operation names ("add", "multiply", "relinearize", etc.)
+        """
+        return self._request("POST", "/api/fhe/noise-estimate", json={
+            "n": n,
+            "t": t,
+            "q_bits": q_bits,
+            "operations": operations,
+        })
+
+    # ── Storage Encryption ────────────────────────────────────────────────
+
+    def encrypt_blob(
+        self,
+        plaintext: bytes,
+        aad: Optional[bytes] = None,
+    ) -> Dict[str, Any]:
+        """Encrypt data with post-quantum hybrid encryption (Kyber+AES-256-GCM).
+
+        Args:
+            plaintext: Raw bytes to encrypt
+            aad: Optional additional authenticated data
+
+        Returns:
+            {"ciphertext_b64": "...", "key_id": "..."}
+        """
+        import base64
+        body = {"plaintext_b64": base64.b64encode(plaintext).decode()}
+        if aad is not None:
+            body["aad"] = base64.b64encode(aad).decode()
+        return self._request("POST", "/api/storage/encrypt", json=body)
+
+    def decrypt_blob(
+        self,
+        ciphertext_b64: str,
+        key_id: str,
+        aad: Optional[bytes] = None,
+    ) -> bytes:
+        """Decrypt a PQ-encrypted blob.
+
+        Returns:
+            Decrypted plaintext bytes
+        """
+        import base64
+        body = {"ciphertext_b64": ciphertext_b64, "key_id": key_id}
+        if aad is not None:
+            body["aad"] = base64.b64encode(aad).decode()
+        result = self._request("POST", "/api/storage/decrypt", json=body)
+        return base64.b64decode(result["plaintext_b64"])
+
+    def encrypt_fields(
+        self,
+        fields: list,
+    ) -> Dict[str, Any]:
+        """Encrypt fields with automatic sensitivity classification.
+
+        Args:
+            fields: List of {"name": "ssn", "value": "123-45-6789"}
+
+        Returns:
+            {"fields": [{"name", "sensitivity", "ciphertext_b64"}], "key_id": "..."}
+        """
+        return self._request("POST", "/api/storage/encrypt-fields", json={
+            "fields": fields,
+        })
+
+    def rotate_encryption(
+        self,
+        ciphertext_b64: str,
+        old_key_id: str,
+        aad: Optional[bytes] = None,
+    ) -> Dict[str, Any]:
+        """Re-encrypt data under the current active key.
+
+        Returns:
+            {"ciphertext_b64": "...", "new_key_id": "..."}
+        """
+        import base64
+        body = {"ciphertext_b64": ciphertext_b64, "old_key_id": old_key_id}
+        if aad is not None:
+            body["aad"] = base64.b64encode(aad).decode()
+        return self._request("POST", "/api/storage/rotate", json=body)

h33-0.1.0/h33/fhe.py

@@ -0,0 +1,140 @@
+"""FHE Client — ctypes FFI to h33-fhe-client Rust cdylib.
+
+Provides client-side BFV encryption for biometric embeddings and
+other FHE operations without exposing plaintext to the server.
+
+Requires the compiled cdylib (libh33_fhe_client.so / .dylib / .dll).
+Build with: cd h33-fhe-client && cargo build --release
+
+Usage::
+
+    from h33.fhe import FheEncryptor
+
+    enc = FheEncryptor.from_public_key("path/to/public_key.json")
+    ciphertext_json = enc.encrypt_embedding([0.1, 0.2, ...])  # 128-dim float vector
+"""
+
+import ctypes
+import json
+import os
+import sys
+from typing import List, Optional
+
+
+def _find_lib() -> Optional[str]:
+    """Search for the h33-fhe-client cdylib."""
+    names = {
+        "linux": "libh33_fhe_client.so",
+        "darwin": "libh33_fhe_client.dylib",
+        "win32": "h33_fhe_client.dll",
+    }
+    libname = names.get(sys.platform, "libh33_fhe_client.so")
+
+    # Check common locations
+    search_paths = [
+        os.path.join(os.path.dirname(__file__), "..", "..", "h33-fhe-client", "target", "release"),
+        os.path.join(os.path.dirname(__file__), ".."),
+        "/usr/local/lib",
+        "/usr/lib",
+    ]
+
+    for path in search_paths:
+        full = os.path.join(path, libname)
+        if os.path.exists(full):
+            return full
+    return None
+
+
+class FheEncryptor:
+    """Client-side FHE encryptor using h33-fhe-client Rust cdylib via ctypes.
+
+    This encrypts data locally so the server never sees plaintext.
+    The server operates on encrypted data using homomorphic operations.
+    """
+
+    def __init__(self, handle, lib):
+        self._handle = handle
+        self._lib = lib
+
+    @classmethod
+    def from_public_key(cls, pk_json_path: str, embedding_dim: int = 128) -> "FheEncryptor":
+        """Load from a public key JSON file.
+
+        Args:
+            pk_json_path: Path to public key JSON (from /api/fhe/init)
+            embedding_dim: Embedding dimension (default 128)
+        """
+        lib_path = _find_lib()
+        if lib_path is None:
+            raise FileNotFoundError(
+                "h33-fhe-client cdylib not found. "
+                "Build it with: cd h33-fhe-client && cargo build --release"
+            )
+
+        lib = ctypes.CDLL(lib_path)
+
+        # Set up function signatures
+        lib.h33_encryptor_new.argtypes = [
+            ctypes.c_char_p,  # public_key_json
+            ctypes.c_size_t,  # json_len
+            ctypes.c_size_t,  # embedding_dim
+            ctypes.POINTER(ctypes.c_void_p),  # out_handle
+        ]
+        lib.h33_encryptor_new.restype = ctypes.c_int
+
+        lib.h33_encrypt_embedding.argtypes = [
+            ctypes.c_void_p,  # handle
+            ctypes.POINTER(ctypes.c_float),  # embedding
+            ctypes.c_size_t,  # dim
+            ctypes.POINTER(ctypes.c_char_p),  # out_json
+            ctypes.POINTER(ctypes.c_size_t),  # out_len
+        ]
+        lib.h33_encrypt_embedding.restype = ctypes.c_int
+
+        lib.h33_encryptor_free.argtypes = [ctypes.c_void_p]
+        lib.h33_encryptor_free.restype = None
+
+        lib.h33_free_bytes.argtypes = [ctypes.c_char_p, ctypes.c_size_t]
+        lib.h33_free_bytes.restype = None
+
+        with open(pk_json_path, "rb") as f:
+            pk_json = f.read()
+
+        handle = ctypes.c_void_p()
+        rc = lib.h33_encryptor_new(pk_json, len(pk_json), embedding_dim, ctypes.byref(handle))
+        if rc != 0:
+            raise RuntimeError(f"h33_encryptor_new failed with code {rc}")
+
+        return cls(handle, lib)
+
+    def encrypt_embedding(self, embedding: List[float]) -> str:
+        """Encrypt a float embedding vector.
+
+        Args:
+            embedding: List of floats (must match embedding_dim)
+
+        Returns:
+            JSON string containing the encrypted ciphertext
+        """
+        arr = (ctypes.c_float * len(embedding))(*embedding)
+        out_json = ctypes.c_char_p()
+        out_len = ctypes.c_size_t()
+
+        rc = self._lib.h33_encrypt_embedding(
+            self._handle, arr, len(embedding),
+            ctypes.byref(out_json), ctypes.byref(out_len),
+        )
+        if rc != 0:
+            raise RuntimeError(f"h33_encrypt_embedding failed with code {rc}")
+
+        result = out_json.value[:out_len.value].decode("utf-8")
+
+        # Free the Rust-allocated buffer
+        self._lib.h33_free_bytes(out_json, out_len)
+
+        return result
+
+    def __del__(self):
+        if hasattr(self, "_handle") and self._handle:
+            self._lib.h33_encryptor_free(self._handle)
+            self._handle = None

h33-0.1.0/h33/storage.py

@@ -0,0 +1,51 @@
+"""Standalone Storage Encryption Client.
+
+Thin wrapper around H33Client's storage methods for users who only need
+data-at-rest encryption without the full SDK.
+"""
+
+from .client import H33Client
+from typing import Optional, Dict, Any, List
+
+
+class StorageClient:
+    """Post-quantum storage encryption client.
+
+    Usage::
+
+        from h33 import StorageClient
+
+        storage = StorageClient(api_key="h33_live_...")
+
+        # Encrypt
+        result = storage.encrypt(b"sensitive data")
+        ciphertext = result["ciphertext_b64"]
+        key_id = result["key_id"]
+
+        # Decrypt
+        plaintext = storage.decrypt(ciphertext, key_id)
+        assert plaintext == b"sensitive data"
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.h33.ai",
+    ):
+        self._client = H33Client(api_key=api_key, base_url=base_url)
+
+    def encrypt(self, plaintext: bytes, aad: Optional[bytes] = None) -> Dict[str, Any]:
+        """Encrypt data with Kyber+AES-256-GCM."""
+        return self._client.encrypt_blob(plaintext, aad)
+
+    def decrypt(self, ciphertext_b64: str, key_id: str, aad: Optional[bytes] = None) -> bytes:
+        """Decrypt PQ-encrypted data."""
+        return self._client.decrypt_blob(ciphertext_b64, key_id, aad)
+
+    def encrypt_fields(self, fields: List[Dict[str, str]]) -> Dict[str, Any]:
+        """Encrypt fields with sensitivity classification."""
+        return self._client.encrypt_fields(fields)
+
+    def rotate(self, ciphertext_b64: str, old_key_id: str, aad: Optional[bytes] = None) -> Dict[str, Any]:
+        """Re-encrypt under current active key."""
+        return self._client.rotate_encryption(ciphertext_b64, old_key_id, aad)

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

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: h33
+Version: 0.1.0
+Summary: H33 Post-Quantum Encryption SDK — Kyber + AES-256-GCM hybrid encryption, FHE biometrics, and more
+Home-page: https://h33.ai
+Author: H33.ai
+Author-email: sdk@h33.ai
+License: MIT
+Project-URL: Homepage, https://h33.ai
+Project-URL: Documentation, https://h33.ai/docs
+Project-URL: API Reference, https://h33.ai/apis
+Project-URL: Benchmarks, https://h33.ai/benchmarks
+Project-URL: White Paper, https://h33.ai/white-paper
+Project-URL: Source, https://github.com/h33-ai/h33-python-sdk
+Project-URL: Issues, https://github.com/h33-ai/h33-python-sdk/issues
+Keywords: post-quantum,encryption,cryptography,fhe,homomorphic-encryption,kyber,dilithium,biometrics,zero-knowledge,pqc,ml-kem,ml-dsa
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Provides-Extra: fhe
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# h33 — Post-Quantum Encryption SDK for Python
+
+The official Python SDK for [H33](https://h33.ai), the post-quantum encryption platform delivering 1.6M authentications/sec with lattice-based cryptography.
+
+## Install
+
+```bash
+pip install h33
+```
+
+## Quick Start
+
+```python
+from h33 import H33Client
+
+client = H33Client(api_key="h33_live_...", base_url="https://api.h33.ai")
+
+# Post-quantum storage encryption (Kyber + AES-256-GCM)
+result = client.encrypt_blob(b"sensitive data")
+ciphertext = result["ciphertext_b64"]
+key_id = result["key_id"]
+
+# Decrypt
+plaintext = client.decrypt_blob(ciphertext, key_id)
+assert plaintext == b"sensitive data"
+```
+
+## Storage Encryption
+
+Encrypt data at rest with hybrid post-quantum encryption (ML-KEM/Kyber + AES-256-GCM):
+
+```python
+from h33 import StorageClient
+
+storage = StorageClient(api_key="h33_live_...")
+
+# Encrypt with optional authenticated data
+result = storage.encrypt(b"patient record", aad=b"user:12345")
+print(result["key_id"])  # Kyber key ID for decryption
+
+# Decrypt
+plaintext = storage.decrypt(result["ciphertext_b64"], result["key_id"], aad=b"user:12345")
+
+# Field-level encryption with automatic sensitivity classification
+fields = storage.encrypt_fields([
+    {"name": "ssn", "value": "123-45-6789"},
+    {"name": "name", "value": "Jane Doe"},
+    {"name": "email", "value": "jane@example.com"},
+])
+# Each field gets a sensitivity level (Confidential, Internal, etc.)
+
+# Key rotation — re-encrypt under the current active key
+rotated = storage.rotate(result["ciphertext_b64"], result["key_id"])
+```
+
+## Client-Side FHE (Homomorphic Encryption)
+
+Encrypt biometric embeddings on the client so the server never sees plaintext:
+
+```python
+from h33 import FheEncryptor
+
+# Load public key from H33 API
+enc = FheEncryptor.from_public_key("public_key.json", embedding_dim=128)
+
+# Encrypt a 128-dimensional face embedding
+embedding = [0.1, 0.2, 0.03, ...]  # from your ML model
+ciphertext_json = enc.encrypt_embedding(embedding)
+
+# Send ciphertext to H33 for matching — server operates on encrypted data
+```
+
+Requires the `h33-fhe-client` native library. Build from source:
+
+```bash
+cd h33-fhe-client && cargo build --release
+```
+
+## API Reference
+
+### H33Client
+
+| Method | Description |
+|--------|-------------|
+| `health()` | Check API status |
+| `send_code(phone)` | Send SMS OTP for authentication |
+| `verify_code(phone, code)` | Verify OTP and get session |
+| `create_key(label)` | Create a new API key |
+| `list_keys()` | List all API keys |
+| `revoke_key(key_id)` | Revoke an API key |
+| `encrypt_blob(plaintext, aad)` | PQ-encrypt arbitrary data |
+| `decrypt_blob(ciphertext_b64, key_id, aad)` | Decrypt PQ-encrypted data |
+| `encrypt_fields(fields)` | Field-level PQ encryption |
+| `rotate_encryption(ciphertext_b64, old_key_id, aad)` | Re-encrypt under current key |
+| `fhe_schemes()` | List available FHE schemes |
+| `noise_estimate(n, t, q_bits, operations)` | Estimate FHE noise budget |
+
+### StorageClient
+
+Convenience wrapper for encryption-only workflows:
+
+| Method | Description |
+|--------|-------------|
+| `encrypt(plaintext, aad)` | Encrypt bytes |
+| `decrypt(ciphertext_b64, key_id, aad)` | Decrypt bytes |
+| `encrypt_fields(fields)` | Field-level encryption |
+| `rotate(ciphertext_b64, old_key_id, aad)` | Key rotation |
+
+## Platform
+
+H33 is the world's fastest post-quantum authentication platform:
+
+- **1.6M auth/sec** on AWS Graviton4 (96 vCPUs)
+- **~42 microseconds** per authentication
+- **Kyber + AES-256-GCM** hybrid encryption for data at rest
+- **BFV Fully Homomorphic Encryption** for biometric matching on encrypted data
+- **Dilithium digital signatures** for attestation
+- **Zero-knowledge proofs** for privacy-preserving verification
+
+Learn more at [h33.ai](https://h33.ai)
+
+## Documentation
+
+- [H33 Platform](https://h33.ai)
+- [API Documentation](https://h33.ai/docs)
+- [FHE Overview](https://h33.ai/fhe)
+- [Post-Quantum Cryptography](https://h33.ai/pqc)
+- [White Paper](https://h33.ai/white-paper)
+- [Benchmarks](https://h33.ai/benchmarks)
+
+## License
+
+MIT — see [LICENSE](LICENSE)

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

@@ -0,0 +1,13 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+h33/__init__.py
+h33/client.py
+h33/fhe.py
+h33/storage.py
+h33.egg-info/PKG-INFO
+h33.egg-info/SOURCES.txt
+h33.egg-info/dependency_links.txt
+h33.egg-info/requires.txt
+h33.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,3 @@
+requests>=2.25.0
+
+[fhe]

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

@@ -0,0 +1 @@
+h33

h33-0.1.0/setup.cfg

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

h33-0.1.0/setup.py

@@ -0,0 +1,55 @@
+from setuptools import setup, find_packages
+import os
+
+here = os.path.abspath(os.path.dirname(__file__))
+with open(os.path.join(here, "README.md"), encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="h33",
+    version="0.1.0",
+    description="H33 Post-Quantum Encryption SDK — Kyber + AES-256-GCM hybrid encryption, FHE biometrics, and more",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="H33.ai",
+    author_email="sdk@h33.ai",
+    url="https://h33.ai",
+    license="MIT",
+    packages=find_packages(),
+    include_package_data=True,
+    python_requires=">=3.8",
+    install_requires=[
+        "requests>=2.25.0",
+    ],
+    extras_require={
+        "fhe": [],  # ctypes FFI to h33-fhe-client cdylib (no extra pip deps)
+    },
+    keywords=[
+        "post-quantum", "encryption", "cryptography", "fhe",
+        "homomorphic-encryption", "kyber", "dilithium", "biometrics",
+        "zero-knowledge", "pqc", "ml-kem", "ml-dsa",
+    ],
+    project_urls={
+        "Homepage": "https://h33.ai",
+        "Documentation": "https://h33.ai/docs",
+        "API Reference": "https://h33.ai/apis",
+        "Benchmarks": "https://h33.ai/benchmarks",
+        "White Paper": "https://h33.ai/white-paper",
+        "Source": "https://github.com/h33-ai/h33-python-sdk",
+        "Issues": "https://github.com/h33-ai/h33-python-sdk/issues",
+    },
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: MIT License",
+        "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",
+        "Topic :: Security :: Cryptography",
+        "Topic :: Scientific/Engineering",
+    ],
+)