cinchdb 0.1.11__tar.gz → 0.1.13__tar.gz

{cinchdb-0.1.11 → cinchdb-0.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinchdb
-Version: 0.1.11
+Version: 0.1.13
 Summary: A Git-like SQLite database management system with branching and multi-tenancy
 Project-URL: Homepage, https://github.com/russellromney/cinchdb
 Project-URL: Documentation, https://russellromney.github.io/cinchdb
@@ -23,6 +23,8 @@ Requires-Dist: requests>=2.28.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: toml>=0.10.0
 Requires-Dist: typer>=0.9.0
+Provides-Extra: encryption
+Requires-Dist: pysqlcipher3>=1.2.0; extra == 'encryption'
 Description-Content-Type: text/markdown
 
 # CinchDB
@@ -39,7 +41,11 @@ Because it's so lightweight and its only dependencies are pydantic, requests, an
 
 
 ```bash
-uv pip install cinchdb
+# Recommended: Install with uv (faster, better dependency resolution)
+uv add cinchdb
+
+# Or with pip
+pip install cinchdb
 
 # Initialize project
 cinch init 
@@ -150,6 +156,25 @@ db.update("posts", post_id, {"content": "Updated content"})
 - **Python SDK**: Core functionality for local development
 - **CLI**: Full-featured command-line interface
 
+## Security & Encryption
+
+Optional transparent encryption for tenant databases:
+
+```bash
+# Enable encryption
+export CINCH_ENCRYPT_DATA=true
+export CINCH_ENCRYPTION_KEY="$(python -c 'import secrets; print(secrets.token_urlsafe(32))')"
+
+# Install encryption library
+pip install pysqlcipher3
+```
+
+- **Tenant databases**: Encrypted with ChaCha20-Poly1305 (~2-5% overhead)
+- **Metadata**: Unencrypted for operational simplicity
+- **Integration**: Transparent - no code changes needed
+
+Works without encryption libraries - gracefully falls back to standard SQLite.
+
 ## Development
 
 ```bash

{cinchdb-0.1.11 → cinchdb-0.1.13}/README.md

@@ -12,7 +12,11 @@ Because it's so lightweight and its only dependencies are pydantic, requests, an
 
 
 ```bash
-uv pip install cinchdb
+# Recommended: Install with uv (faster, better dependency resolution)
+uv add cinchdb
+
+# Or with pip
+pip install cinchdb
 
 # Initialize project
 cinch init 
@@ -123,6 +127,25 @@ db.update("posts", post_id, {"content": "Updated content"})
 - **Python SDK**: Core functionality for local development
 - **CLI**: Full-featured command-line interface
 
+## Security & Encryption
+
+Optional transparent encryption for tenant databases:
+
+```bash
+# Enable encryption
+export CINCH_ENCRYPT_DATA=true
+export CINCH_ENCRYPTION_KEY="$(python -c 'import secrets; print(secrets.token_urlsafe(32))')"
+
+# Install encryption library
+pip install pysqlcipher3
+```
+
+- **Tenant databases**: Encrypted with ChaCha20-Poly1305 (~2-5% overhead)
+- **Metadata**: Unencrypted for operational simplicity
+- **Integration**: Transparent - no code changes needed
+
+Works without encryption libraries - gracefully falls back to standard SQLite.
+
 ## Development
 
 ```bash

{cinchdb-0.1.11 → cinchdb-0.1.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cinchdb"
-version = "0.1.11"
+version = "0.1.13"
 description = "A Git-like SQLite database management system with branching and multi-tenancy"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -26,6 +26,11 @@ dependencies = [
     "requests>=2.28.0",
 ]
 
+[project.optional-dependencies]
+encryption = [
+    "pysqlcipher3>=1.2.0",
+]
+
 [project.urls]
 Homepage = "https://github.com/russellromney/cinchdb"
 Documentation = "https://russellromney.github.io/cinchdb"

{cinchdb-0.1.11 → cinchdb-0.1.13}/src/cinchdb/cli/main.py

@@ -18,7 +18,7 @@ from cinchdb.cli.commands import (
 
 app = typer.Typer(
     name="cinch",
-    help="CinchDB - A Git-like SQLite database management system",
+    help="CinchDB - A Git-like SQLite database management system\n\nENCRYPTION: Set CINCH_ENCRYPT_DATA=true to enable tenant database encryption.",
     add_completion=False,
     invoke_without_command=True,
 )
@@ -28,6 +28,11 @@ app = typer.Typer(
 def main(ctx: typer.Context):
     """
     CinchDB - A Git-like SQLite database management system
+    
+    ENCRYPTION:
+      Set CINCH_ENCRYPT_DATA=true to enable tenant database encryption.
+      Set CINCH_ENCRYPTION_KEY=your-key to provide encryption key.
+      Requires SQLite3MultipleCiphers for encryption support.
     """
     if ctx.invoked_subcommand is None:
         # No subcommand was invoked, show help

{cinchdb-0.1.11 → cinchdb-0.1.13}/src/cinchdb/core/connection.py

@@ -6,6 +6,8 @@ from typing import Optional, Dict, List
 from contextlib import contextmanager
 from datetime import datetime
 
+from cinchdb.security.encryption import encryption
+
 
 # Custom datetime adapter and converter for SQLite
 def adapt_datetime(dt):
@@ -42,18 +44,24 @@ class DatabaseConnection:
         # Ensure directory exists
         self.path.parent.mkdir(parents=True, exist_ok=True)
 
-        # Connect with row factory for dict-like access
-        # detect_types=PARSE_DECLTYPES tells SQLite to use our registered converters
-        self._conn = sqlite3.connect(
-            str(self.path),
-            detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES,
-        )
+        # Use encryption if enabled, otherwise standard connection
+        if encryption.enabled:
+            self._conn = encryption.get_connection(self.path)
+        else:
+            # Connect with row factory for dict-like access
+            # detect_types=PARSE_DECLTYPES tells SQLite to use our registered converters
+            self._conn = sqlite3.connect(
+                str(self.path),
+                detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES,
+            )
+            
+            # Configure WAL mode and settings (encryption module handles this if enabled)
+            self._conn.execute("PRAGMA journal_mode = WAL")
+            self._conn.execute("PRAGMA synchronous = NORMAL")
+            self._conn.execute("PRAGMA wal_autocheckpoint = 0")
+        
+        # Always set row factory and foreign keys
         self._conn.row_factory = sqlite3.Row
-
-        # Configure WAL mode and settings
-        self._conn.execute("PRAGMA journal_mode = WAL")
-        self._conn.execute("PRAGMA synchronous = NORMAL")
-        self._conn.execute("PRAGMA wal_autocheckpoint = 0")
         self._conn.execute("PRAGMA foreign_keys = ON")
         self._conn.commit()
 

cinchdb-0.1.13/src/cinchdb/security/__init__.py

@@ -0,0 +1 @@
+"""Security module for CinchDB encryption."""

cinchdb-0.1.13/src/cinchdb/security/encryption.py

@@ -0,0 +1,108 @@
+"""Simple SQLite encryption using environment variables with KMS upgrade path."""
+
+import os
+import sqlite3
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class SQLiteEncryption:
+    """Simple SQLite encryption with static keys and KMS upgrade path."""
+    
+    def __init__(self):
+        # Encryption is optional for open source users
+        self.enabled = os.getenv("CINCH_ENCRYPT_DATA", "false").lower() == "true"
+        self._encryption_key = None
+        
+        if self.enabled:
+            self._encryption_key = self._get_encryption_key()
+    
+    def _get_encryption_key(self) -> str:
+        """Get encryption key with future KMS support."""
+        
+        # Future KMS support - check for KMS configuration first
+        kms_provider = os.getenv("CINCH_KMS_PROVIDER")
+        if kms_provider:
+            # TODO: Implement KMS key retrieval
+            # return self._get_key_from_kms(kms_provider)
+            logger.warning("KMS provider configured but not implemented yet")
+        
+        # Require explicit key
+        static_key = os.getenv("CINCH_ENCRYPTION_KEY")
+        if static_key:
+            return static_key
+        
+        # Fail fast if no key provided
+        raise ValueError(
+            "CINCH_ENCRYPTION_KEY environment variable is required when CINCH_ENCRYPT_DATA=true. "
+            "Generate a key with: python -c \"import secrets; print(secrets.token_urlsafe(32))\""
+        )
+    
+    def get_connection(self, db_path: Path) -> sqlite3.Connection:
+        """Get SQLite connection with optional encryption."""
+        # Connect with datetime parsing support
+        conn = sqlite3.connect(
+            str(db_path),
+            detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES,
+        )
+        
+        if self.enabled and self._encryption_key:
+            try:
+                # Apply encryption key
+                conn.execute(f"PRAGMA key = '{self._encryption_key}'")
+                
+                # Configure recommended cipher (ChaCha20-Poly1305) if supported
+                try:
+                    conn.execute("PRAGMA cipher = 'chacha20'")
+                except sqlite3.OperationalError:
+                    # Fallback to default cipher if ChaCha20 not available
+                    logger.debug("ChaCha20 cipher not available, using default")
+                
+                # Security hardening
+                conn.execute("PRAGMA temp_store = MEMORY")  # Encrypt temp data
+                conn.execute("PRAGMA secure_delete = ON")   # Overwrite deleted data
+                
+            except sqlite3.OperationalError as e:
+                logger.error(f"Failed to apply encryption to {db_path}: {e}")
+                # Close connection and re-raise with helpful message
+                conn.close()
+                raise sqlite3.OperationalError(
+                    f"Failed to apply encryption. Make sure SQLite3MultipleCiphers is installed. Error: {e}"
+                ) from e
+        
+        # Standard SQLite optimizations
+        conn.execute("PRAGMA journal_mode = WAL")
+        conn.execute("PRAGMA synchronous = NORMAL")
+        conn.execute("PRAGMA cache_size = -2000")
+        
+        return conn
+    
+    def is_encrypted(self, db_path: Path) -> bool:
+        """Check if database file is encrypted."""
+        if not db_path.exists():
+            return False
+        
+        try:
+            # Try to open without key
+            test_conn = sqlite3.connect(str(db_path))
+            test_conn.execute("SELECT name FROM sqlite_master LIMIT 1")
+            test_conn.close()
+            return False  # Successfully opened = not encrypted
+        except sqlite3.DatabaseError:
+            return True   # Failed to open = likely encrypted
+    
+    def test_encryption_support(self) -> bool:
+        """Test if SQLite encryption is available."""
+        try:
+            conn = sqlite3.connect(':memory:')
+            conn.execute("PRAGMA key = 'test'")
+            conn.close()
+            return True
+        except sqlite3.OperationalError:
+            return False
+
+
+# Global instance for easy access
+encryption = SQLiteEncryption()