Security Architecture — Briefing
Cryptographic Primitives
SecureCall uses proven, peer-reviewed cryptographic primitives. We do not invent our own cryptography — we use established algorithms implemented in a memory-safe language.
| Component | Algorithm | Details |
|---|---|---|
| Symmetric Encryption | XChaCha20-Poly1305 | 256-bit AEAD cipher with 192-bit extended nonce |
| Key Exchange | X25519 | Elliptic Curve Diffie-Hellman on Curve25519 |
| Identity Authentication | P-256 / SHA-256 | Android Keystore identity signs registration and call transcripts |
| Session Key Lifecycle | X25519 + HKDF-SHA256 | Separate key material per call, discarded at call end |
| Key Derivation | HKDF-SHA256 | HMAC-based key derivation function |
| Transport | DTLS-SRTP | Encrypted peer-to-peer media transport |
| Audio Codec | Opus | 48kHz, adaptive bitrate 6-510 kbps |
Architecture Overview
Key Generation
For each call, SecureCall uses X25519 key material generated on the participating devices. A per-install P-256 key held in Android Keystore signs registration and both call transcripts. Private key material is not sent to the signaling service.
Call Establishment
- Caller sends call-setup data through the signaling service
- Both parties perform X25519 Diffie-Hellman key exchange
- HKDF-SHA256 binds the shared secret to both signed transcripts
- Both peers verify HMAC key confirmation and show the same security code
- Direct peer-to-peer connection is established via WebRTC
- Voice frames are encrypted with XChaCha20-Poly1305 before transmission
Per-call key lifecycle
X25519 and HKDF-SHA256 derive separate key material for each call, which is discarded when the call ends. XChaCha20-Poly1305 protects application media frames. SecureCall does not implement a Double Ratchet, per-frame ratcheting or post-compromise security.
Signaling Server
The signaling service facilitates call setup and is not designed to receive call plaintext. It does process:
- Call-setup and delivery messages required by the protocol
- Pseudonymous SecureIDs and temporary connection identifiers
- Network endpoints and operational data as described in the privacy policy
Media uses a direct WebRTC path when available and otherwise may traverse a TURN relay. Application media frames remain encrypted. Direct canonical sc-... identities are key-derived; human-readable aliases, custom IDs and phone lookup remain server-resolved, so compare the canonical identity or six-digit security code when target authenticity matters.
Rust Crypto Engine
The cryptographic core of SecureCall is written in Rust. Rust's type and ownership system reduces several classes of memory-safety defects in safe Rust; native dependencies, FFI boundaries, logic errors, and unsafe code still require review and tests:
- No buffer overflows — Rust prevents out-of-bounds memory access
- No use-after-free — The ownership system ensures memory is properly managed
- No data races — Thread safety is enforced by the compiler
- No null pointer dereferences — Rust uses Option types instead of null
The Rust crypto engine is compiled to a native library and called from the Android app via JNI (Java Native Interface).
Anti-Recording Protection
SecureCall includes active protection against call recording attempts (Pro and Premium tiers):
- FLAG_SECURE — Prevents screenshots and screen recording of the call screen
- Audio Focus Lock — Exclusive audio focus prevents other apps from recording
- Screen Recording Detection — Detects active screen capture via API 34+ callbacks and process monitoring
- Microphone Monitoring — Detects if other apps are accessing the microphone during calls
- Spy App Detection — Identifies known surveillance apps via accessibility service and package scanning
- Call Recording App Detection — Scans for installed call recording applications
When a threat is detected, the response depends on your tier:
| Tier | Response |
|---|---|
| Free | Warning notification |
| Pro | Block threat + alert dialog |
| Premium | Automatically terminate call |
Audit & Source Code
SecureCall's complete source code is publicly available for security review:
- Repository: github.com/NeaBouli/stealth
- Crypto Engine:
core_crypto/directory (Rust) - Android App:
client_android/directory (Kotlin/Java) - Signaling Server:
backend/signaling/directory (Node.js)
We welcome security researchers to review our code and report vulnerabilities responsibly. Contact: GitHub Issues
What We Cannot Do
Due to our architecture, we are technically unable to:
- Decrypt or listen to your calls
- Provide call content to law enforcement (we don't have it)
- Identify who you called or when (no persistent call logs)
- Associate calls with real identities
- Insert backdoors without the change being visible in our public source code
StealthX Platform — Shared Crypto Stack
SecureCall is part of the StealthX Platform. All three products share the same cryptographic foundation:
| Product | Encryption | Key Exchange | Key Lifecycle | Transport |
|---|---|---|---|---|
| SecureCall | XChaCha20-Poly1305 | X25519 | Per-call HKDF key; no ratchet | WebRTC DTLS-SRTP |
| SecureChat | XChaCha20-Poly1305 | X25519 | Double Ratchet | Tor/.onion Relay Nodes |
| Chameleon | XChaCha20-Poly1305 | X25519 | Double Ratchet | Local + AIDL IPC |
No AES-GCM. No BouncyCastle. No custom cryptography. One stack, internally reviewed, used everywhere.