Patent-pending AI security architecture. See how we protect sensitive data before it reaches any AI model.
A 7-minute walkthrough of the dual-gate architecture that keeps your data safe from AI exposure.
Paste any text containing personal information. Watch SCRS detect and redact PII in real time.
Type a message containing sensitive data. See two layers: what YOU typed vs what the AI receives.
We've pseudonymised this text. Can you figure out the original names, emails, or account numbers? Spoiler: you can't.
When an employee leaves or data must be destroyed, SCRS permanently revokes the encryption key. Watch what happens.
Three personas with different access scopes. The same search behaves differently depending on who is asking.
Supports PDF, DOCX, TXT. Automatically detects PII.
This demonstrates why SCRS is different from "filter later" systems: Bob cannot retrieve what he is not allowed to know exists.
Bob is an external consultant with:
Try searching for the same document Alice uploaded.
Can only see Healthcare documents. Compliance enforced.
The vector index stores no plaintext. Here's exactly what Gate 1 searches over — and what it doesn't.
Gate 1 finds candidates. The re-ranker scores them using metadata only — no decryption happens yet. Only the best candidates reach Gate 2.
Run a query in Section 05 to see re-ranking in action. The response will show Gate 1 candidates, re-ranked finalists, and Gate 2 decrypted results.
Before Gate 2 decrypts anything, it demands a time-limited cryptographic token — like a visitor pass that expires in 30 seconds.
Don't trust marketing claims -- verify the implementation yourself. Here's the actual encryption code running this demo.
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os
def encrypt(plaintext: bytes, key: bytes) -> bytes:
"""AES-256-GCM authenticated encryption.
Returns: nonce (12 bytes) + ciphertext + tag (16 bytes)"""
nonce = os.urandom(12)
aesgcm = AESGCM(key)
return nonce + aesgcm.encrypt(nonce, plaintext, None)
def decrypt(data: bytes, key: bytes) -> bytes:
"""AES-256-GCM authenticated decryption.
Raises InvalidTag if tampered."""
nonce, ciphertext = data[:12], data[12:]
aesgcm = AESGCM(key)
return aesgcm.decrypt(nonce, ciphertext, None)import hashlib, json, datetime
def append_event(action, data, conn):
"""Append to hash-chained audit log.
Each entry's hash = SHA-256(previous_hash + action + data)"""
prev = get_last_hash(conn) or "GENESIS"
payload = json.dumps({"action": action, "data": data,
"timestamp": datetime.datetime.utcnow().isoformat()})
new_hash = hashlib.sha256(
(prev + payload).encode()
).hexdigest()
insert_event(conn, action, payload, new_hash, prev)
return new_hashclass KeyManagementService:
"""In-memory KMS for demo. Production uses AWS KMS / Azure Key Vault."""
def generate_document_key(self, tenant_id, doc_id):
"""Generate a unique 256-bit key per document."""
key = os.urandom(32) # 256 bits
self._keys[(tenant_id, doc_id)] = key
return key
def revoke_document_key(self, tenant_id, doc_id):
"""Permanently destroy a document's encryption key.
After this, the document's ciphertext is unrecoverable."""
self._keys.pop((tenant_id, doc_id), None)
# Key is gone. Data is dead. No backdoor.Every action during this demo has been logged with a tamper-evident hash chain. Click any entry to verify integrity.
Both gates must pass before ANY plaintext is revealed. Fail-closed by design.
Vector index contains only sanitised embeddings. No PII exposed in search.
Revoke access immediately. Key deletion blocks decryption — no re-indexing needed.
SQL-level tenant filtering prevents cross-company data leaks.
SHA-256 hash-chained trail. Tamper-evident. Exportable for compliance.
| Metric | Without SCRS | With SCRS |
|---|---|---|
| Data breach risk | HIGH (plaintext exposed) | LOW (encrypted + gated) |
| Revocation speed | Hours/Days (re-index) | Instant (key delete) |
| Compliance cost | HIGH (manual controls) | LOW (automated) |
| Tenant isolation | Application-level | Database-level |
| Employee offboarding | Manual revocation | One-click kill switch |
Based on your demo session, here's how SCRS would protect your organisation.
Whether you're a parent, a business owner, or an enterprise CISO — your data deserves a firewall.
Parental controls, engagement tracking, weekly brain health reports, content filtering, and child-safe AI.
Learn moreAdmin dashboard, team RBAC, audit trails, employee offboarding with key revocation, and usage metering.
Learn moreSCRS API, BYOK encryption, compliance frameworks, webhooks, IP allowlisting, and dedicated support.
Talk to salesFill in the form below and we'll send you a detailed report + get back to you about how SCRS can protect your organisation.
AES-256-GCM provides authenticated encryption — the ciphertext is both confidential AND tamper-proof.
plaintext = "Client: Sarah Johnson"key = generate_key(256 bits)ciphertext = AES_GCM_encrypt(plaintext, key)result = AES_GCM_decrypt(ciphertext, key)→ result == plaintext ✓
wrong_key = generate_key(256 bits)result = AES_GCM_decrypt(ciphertext, wrong_key)→ AUTHENTICATION FAILED→ InvalidTag exception raised→ Zero plaintext revealed
Gate 1 enforces tenant and collection isolation at the database query level — not application level.
scope = {tenant: "T1", collections: ALL}query("earnings report")→ 3 results from finance, legal
scope = {tenant: "T1", collections: ["legal"]}query("earnings report")→ 0 results (finance excluded from scope)
WHERE tenant_id = ? AND collection_id IN (?). Out-of-scope documents never enter the candidate set — they're not "filtered out," they're never found.
The audit trail uses SHA-256 hash chaining. Modifying any record breaks the chain — making tampering instantly detectable.
data = "user:alice action:ingest doc:d1"hash_1 = SHA256("GENESIS" + data)→ hash_1 = a3f2b8c1...
data = "user:bob action:query doc:d1"hash_2 = SHA256(hash_1 + data)→ hash_2 = 7e4d9f2a...
verify(hash_2) → validSHA256(hash_1 + record_2) == hash_2 ✓
modify record_1 → hash_1 changesSHA256(new_hash_1 + record_2) ≠ hash_2 ✗→ CHAIN BROKEN — tampering detected
When an encryption key is revoked, the data becomes permanently unrecoverable — by design.
key_store = {doc_d1: key_abc123}decrypt(ciphertext, key_abc123) → "Client: Sarah Johnson"key_store = {doc_d1: DELETED}decrypt(ciphertext, ???) → IMPOSSIBLENo key exists. No admin override. No recovery.
SELECT ciphertext FROM documents→ Has ciphertext bytes ✓→ Has NO key to decrypt ✗→ Data is permanently dead
Key was in memory onlyMemory wiped on revocation→ Even the admin cannot recover→ Provable GDPR Art 17 compliance