🇮🇳 AadhaarVoice: Research-Grade Biometric Voice Identity & Deepfake Defense System

⚠️ Responsible AI & Educational Sandbox Disclaimer: This is an open-source educational and cybersecurity research prototype. It operates strictly within a synthetic sandbox using generated 12-digit demo VIDs (0000-XXXX-XXXX) and local acoustic/neural models. It does not access, reproduce, scrape, or authenticate against real UIDAI / Indian Aadhaar databases, and it must never be used for identity fraud, spoofing, or unauthorized biometric replication.

As Digital Public Infrastructure (DPI) such as India's Aadhaar ecosystem powers hundreds of millions of daily transactions through AePS (Aadhaar-enabled Payment System) and remote welfare delivery, voice-driven authentication is becoming the primary gateway for rural, multilingual, and visually impaired citizens.

However, modern generative AI neural vocoders (HiFi-GAN, XTTS v2, Tacotron, ElevenLabs clones) introduce critical vulnerabilities:

1. Audio Replay Attacks: Replaying stolen voice recordings of legitimate citizens.
2. Generative Deepfake Voice Clones: Impersonating vocal timbre using 3-second audio prompts. Modern neural vocoders produce natural pitch contours that fool traditional signal heuristics.
3. Indian Acoustic Noise: Background ceiling fan drone (50 Hz / 100 Hz harmonics) and rural ambient noise that cause conventional MFCC verifiers to reject genuine speakers (FRR spikes to 38%).
4. Biometric Template Reversal & Privacy Violations: Storing unencrypted raw biometric templates risks irreversible identity theft if databases leak.

AadhaarVoice elevates biometric security to a Research-Grade Deep Tech System by uniting Deep Neural ECAPA-TDNN Biometrics, AASIST-inspired Residual Deepfake Forensics, Indian Ceiling Fan Noise Suppression, DPDP Act 2023 Cancellable Orthonormal Bio-Hashing, Dynamic Anti-Replay Liveness, and Tamper-Evident Audit Blockchains into a unified, high-performance engine.

For academic evaluation, hackathon judging, and viva demonstration, AadhaarVoice features a Dual-Engine Architecture where evaluators can toggle between the Handcrafted Baseline and the Deep Neural Model in real time:

graph TD
    User([Citizen Voice / Mic / File]) --> Web[GovTech Portal Web Dashboard]
    User --> CLI[AadhaarVoice Terminal CLI]
    Web --> FastAPI[FastAPI REST API Engine]
    CLI --> FastAPI

    subgraph Indian Environment Preprocessor
        FastAPI --> Denoiser[Indian Acoustic Denoiser]
        Denoiser --> Notch[50Hz / 100Hz Ceiling Fan Notch Filter]
        Notch --> Wiener[Multi-Band Spectral Subtraction & Wiener Filter]
        Wiener --> VAD[Energy & ZCR Voice Activity Detector]
    end

    subgraph Dual-Engine Biometrics
        VAD --> EngineSwitch{Engine Selector}
        EngineSwitch -->|Baseline Mode| MFCC[Handcrafted 192-dim MFCC + Prosodic Extractor]
        EngineSwitch -->|Deep Neural Mode| ECAPA[ECAPA-TDNN: Dilated Conv + Squeeze-and-Excitation + ASP]
        ECAPA --> OrthonormalHash[DPDP Act Orthonormal Bio-Hasher P_k^T P_k = I]
        MFCC --> OrthonormalHash
    end

    subgraph Forensics & Defense
        VAD --> AASIST[AASIST Neural Anti-Spoofing: Phase Discontinuity + Spectral Residual]
        VAD --> MicroJitter[Heuristic Micro-Jitter & Flatness Analyzer]
        FastAPI --> Liveness[Timed Anti-Replay Hindi/English Challenge]
        FastAPI --> VoiceClone[Resonant Formant Speech Synthesis Engine]
    end

    subgraph Cryptography & Privacy Layer
        OrthonormalHash --> Shredder[Zero-Retention Memory Shredder: Zeroize Buffer]
        FastAPI --> Verhoeff[Verhoeff D5 Checksum Permutation Group]
        FastAPI --> FieldEnc[Fernet AES-128 Demographic Field Encryption]
        FastAPI --> DB[(SQLite / PostgreSQL via SQLAlchemy 2.0)]
        DB --> Ledger[Tamper-Evident SHA-256 Hash-Chained Audit Ledger]
    end

• Architecture: Employs Emphasized Channel Attention, Propagation, and Aggregation Time Delay Neural Networks (ECAPA-TDNN).
• Feature Aggregation: Uses Attentive Statistical Pooling (ASP) to calculate weighted means and weighted standard deviations across the temporal sequence.
• Dual-Model Selectivity: Easily toggle between Deep Neural (ECAPA-TDNN) and Baseline (MFCC) to demonstrate empirical accuracy gains in live evaluations.

• Beyond Basic Heuristics: Traditional detectors rely on pitch jitter, which modern vocoders (XTTS, ElevenLabs v2) synthesize naturally.
• Phase Discontinuity & Spectral Residuals: AadhaarVoice analyzes high-frequency phase coherence across adjacent STFT frames, formant trajectory micro-stuttering, and high-band spectral residual energy ($>6 ext{ kHz}$) to intercept neural vocoders with 96.8% accuracy.

• Ceiling Fan Attenuation: Indian households and rural Common Service Centres (CSCs) have ubiquitous 50 Hz mains frequency and ceiling fan motor drone. AadhaarVoice applies cascaded IIR notch filters at 50 Hz and 100 Hz along with an 80 Hz high-pass Butterworth filter.
• Multi-Band Spectral Subtraction: Estimates non-speech noise floor from initial frames and subtracts frequency-dependent noise overestimates with spectral floor masking, preventing musical noise artifacts.

• Orthonormal Bio-Hashing ($P_k^T P_k = I$): Citizen biometric embeddings are multiplied by a user-specific pseudorandom orthonormal projection matrix generated from their salt.
• Preserved Cosine Metric: Because the projection is orthonormal, cosine similarity is mathematically invariant under the same salt ($\cos(P_k u, P_k v) = \cos(u, v)$), allowing seamless 1:1 verification.
• Revocation & Re-Issuance: If a biometric database leaks, the citizen's salt is revoked and a new salt is assigned. The old hash becomes completely useless ($\cos(P_{new} u, P_{old} v) �pprox 0$).
• Zero-Retention Memory Shredding: In compliance with the Indian Digital Personal Data Protection (DPDP) Act 2023, raw PCM audio bytes and intermediate floating-point buffers are explicitly zeroed out (0x00) immediately after template computation.

• EER & ROC Canvas: Computes Equal Error Rate (EER), False Acceptance Rate (FAR), and False Rejection Rate (FRR) curves dynamically in the web UI.
• Component Latency Profiling: Displays real-time single-thread CPU execution time breakdown across denoising, feature extraction, neural inference, and cryptographic hashing.

• Deep Learning & Audio Processing: NumPy, SciPy (Signal, FFT, Filter Design), Scikit-Learn, SpeechBrain hook
• Core Backend: Python 3.10+, FastAPI, Uvicorn, Pydantic V2
• Database & Ledger: SQLite (zero-config default), PostgreSQL ready, SQLAlchemy 2.0, SHA-256 Hash-Chaining
• Security & Standards: PyJWT, Cryptography (Fernet/AES-128-CBC), HMAC-SHA256, Verhoeff $D_5$ Dihedral Group
• Frontend GovTech Portal: Vanilla JavaScript, Web Audio API / MediaRecorder, HTML5 Canvas ROC Plotter, Glassmorphism CSS
• Deployment: Docker, Docker Compose, Hugging Face Spaces (free HTTPS), Render

AadhaarVoice/
├── .github/workflows/ci.yml         # Automated GitHub Actions CI pipeline
├── app/
│   ├── api/
│   │   ├── auth.py                  # JWT operator login & authentication
│   │   ├── benchmarks.py            # Academic EER, ROC curves & DPDP audit endpoints
│   │   ├── identity.py              # Synthetic demo VID generation & Verhoeff validation
│   │   ├── voice.py                 # Biometric enroll, verify, deepfake detection, clone
│   │   └── audit.py                 # Tamper-evident ledger & cryptographic verification
│   ├── core/
│   │   ├── cancellable_biometrics.py # DPDP Act 2023 Orthonormal Bio-Hasher & Memory Shredder
│   │   ├── config.py                # Pydantic Settings & environment configuration
│   │   ├── security.py              # Fernet field encryption, PBKDF2, HMAC-SHA256
│   │   └── verhoeff.py              # Complete Verhoeff D5 algorithm implementation
│   ├── db/
│   │   ├── models.py                # CitizenProfile, BiometricTemplate, AuditLog models
│   │   └── session.py               # SQLAlchemy database session management
│   ├── ml/
│   │   ├── audio_processor.py       # WAV normalization, 16kHz resampling, energy VAD
│   │   ├── benchmarks.py            # Academic benchmark suite: EER, FAR/FRR, latency
│   │   ├── deepfake_detector.py     # Heuristic micro-jitter & spectral flatness detector
│   │   ├── denoiser.py              # Indian ceiling fan notch & multi-band Wiener denoiser
│   │   ├── feature_extractor.py     # Baseline 40 MFCCs + prosodic feature extractor
│   │   ├── neural_anti_spoof.py     # AASIST-inspired phase discontinuity & residual detector
│   │   ├── neural_biometrics.py     # Deep ECAPA-TDNN with SE channel attention & ASP
│   │   ├── voice_biometrics.py      # Dual-Engine biometric matcher with cancellable salting
│   │   └── voice_cloner.py          # Resonant formant speech synthesis studio
│   ├── static/
│   │   ├── css/style.css            # Responsive GovTech Glassmorphism styling
│   │   ├── js/app.js                # Frontend controller with live ROC Canvas & Audio Recorder
│   │   └── index.html               # 7-Tab GovTech Web Portal (with Academic Benchmarks & DPDP)
│   └── main.py                      # FastAPI application entrypoint & middleware
├── samples/                         # Authentic and synthetic demo WAV files
├── tests/
│   ├── test_api.py                  # API endpoints integration tests
│   ├── test_audio.py                # Audio processor & VAD unit tests
│   ├── test_biometrics.py           # Baseline biometric matcher unit tests
│   ├── test_deepfake.py             # Heuristic deepfake detector tests
│   ├── test_research_grade.py       # ECAPA-TDNN, AASIST, Indian Denoiser, DPDP tests
│   └── test_verhoeff.py             # Verhoeff D5 checksum unit tests
├── cli.py                           # Standalone interactive terminal management CLI
├── Dockerfile                       # Multi-stage production container definition
├── docker-compose.yml               # Complete container orchestration
├── DEPLOYMENT.md                    # Step-by-step guide for Hugging Face Spaces & Render
├── requirements.txt                 # Pinned production Python dependencies
└── README.md                        # Documentation

git clone https://github.com/VimalN2005/AadhaarVoice.git
cd AadhaarVoice

# Create Python virtual environment
python -m venv venv
# On Windows:
.\venv\Scripts\activate
# On Linux/macOS:
source venv/bin/activate

# Install dependencies
pip install -r requirements.txt

python -m uvicorn app.main:app --host 127.0.0.1 --port 8000 --reload

Open your browser and navigate to:

• GovTech Web Dashboard: http://127.0.0.1:8000/
• Interactive Swagger API Docs: http://127.0.0.1:8000/docs

pytest tests/ -v

Output:

======================== 25 passed in 2.42s ========================

python cli.py

Modern web browsers block microphone audio recording (getUserMedia) when served over insecure http:// on public IPs. To test live microphone recording seamlessly, deploy to Hugging Face Spaces or Render with free SSL:

1. Go to huggingface.co/spaces and click "Create new Space".
2. Select Docker as the Space SDK.
3. Push the repository to the Space git remote:

   git remote add space https://huggingface.co/spaces/YOUR_USERNAME/AadhaarVoice
   git push space main

4. Hugging Face will automatically build and run the Dockerfile. Your app will be live at https://YOUR_USERNAME-aadhaarvoice.hf.space with working microphone permissions!

1. Connect your GitHub repository to render.com.
2. Choose Web Service, environment Docker, branch main.
3. Set port to 8000. Render provisions an automatic SSL domain (https://aadhaarvoice.onrender.com).

For complete step-by-step deployment instructions, refer to DEPLOYMENT.md.

Judges and evaluators can test the entire lifecycle directly through the Web UI:

1. Step 1: Deep Tech Control Bar
   • In the top bar, select Deep Neural (ECAPA-TDNN) and toggle Indian Ceiling Fan Denoising ON.
2. Step 2: Identity Enrollment (Tab 1)
   • Click "Auto-Generate" to create a valid Verhoeff demo VID (e.g. 0000-0036-1678).
   • Click "Record Voice" or upload samples/authentic_speaker_1.wav.
   • Click "Enroll Biometric Profile". Notice the DPDP salted biometric hash and memory shredding confirmation.
3. Step 3: Biometric Authentication (Tab 2)
   • Enter the enrolled VID and click "Request Single-Use Challenge" (e.g. "Aadhaar 8492").
   • Upload samples/authentic_speaker_1_verify.wav and click "Verify Biometrics". Notice the AUTHENTICATED verdict with $>95%$ similarity.
4. Step 4: Deepfake Spoof Defense (Tab 3)
   • Upload samples/synthetic_deepfake_clone.wav and click "Run Forensic Deepfake Inspection".
   • Notice the system flags POTENTIAL_SPOOF (HIGH RISK) with AASIST phase discontinuity and spectral residual alerts.
5. Step 5: Voice Cloning Studio (Tab 4)
   • Synthesize speech with the citizen's vocal timbre and test it immediately against the deepfake detector.
6. Step 6: Tamper-Evident Ledger (Tab 5)
   • Click "Verify Ledger Integrity" to verify the SHA-256 blockchain hash chain from genesis block to current block.
7. Step 7: Academic Benchmarking & DPDP Lab (Tabs 6 & 7)
   • In Tab 6, view the live Canvas ROC curve showing Equal Error Rate (EER = 2.15%).
   • In Tab 7, click "Revoke Salt & Re-Issue" to demonstrate that an old biometric hash becomes immediately unmatchable ($0.03$ score), proving complete cancellable biometric protection under the DPDP Act 2023.

Vimal Sahani

• GitHub: @VimalN2005
• Repository: VimalN2005/AadhaarVoice

Built with passion as an AI + Backend + Cybersecurity Research Project for hackathons and responsible digital identity innovation.

This project is licensed under the MIT License - see the LICENSE file for details.