💻 computer science

A Formal Verification Framework for Biometric Authentication Protocols

This paper presents a formal verification framework that rigorously analyzes biometric authentication protocols, revealing critical vulnerabilities in the L0 protocol and identifying a persistent architectural session-synchronisation gap in the L1 protocol that requires future specification amendments.

Original authors: H Ranjini, H Kavitha, R Pradeep

Published 2026-09-30

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: H Ranjini, H Kavitha, R Pradeep

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the digital age, proving who you are has shifted from carrying a physical card to presenting a part of yourself. Systems like Aadhaar, which serves over a billion people in India, rely on biometric data—fingerprints, faces, or irises—to verify identity. This method offers a distinct advantage over passwords: you cannot lose your fingerprint, and you cannot share it with a stranger. However, this convenience comes with a profound responsibility. Because these biological traits are permanent and unique, their digital protection must be absolute. If a password is stolen, it can be changed; if a digital fingerprint is stolen, the owner's identity is compromised forever. To ensure these systems work as intended, security experts do not just test them against known hackers; they use formal verification. This is a rigorous mathematical approach that treats a security protocol like a logical puzzle, checking every possible path a message could take to ensure no hidden flaws exist that could allow an intruder to slip through.

Researchers Ranjini H, Kavitha H, and Pradeep R applied this exacting standard to the Aadhaar system, specifically comparing two different versions of its authentication process. The first version, known as L0, is the older, simpler method where a device captures a fingerprint and sends it to a central server for checking. The second, L1, is a more advanced architecture designed to be much harder to breach. In the L1 system, the device itself contains a secure hardware chip that encrypts the data before it ever leaves the sensor, creating a "root of trust" that software alone cannot easily mimic. The team built a detailed digital model of both systems and ran them through a specialized tool called Scyther. This tool acts as a relentless simulator, assuming an attacker has total control over the network and can intercept, change, or replay any message sent between the device and the server. The goal was to see if the mathematical logic of the protocols held up under this extreme pressure.

The results painted a clear picture of where the older system stood and where the newer one still had work to do. The analysis confirmed that the L0 protocol was fundamentally flawed. In the simulation, an attacker could easily trick the system by replaying old messages, intercepting communications to steal secrets, or even cloning a device to gain unauthorized access. The older system simply lacked the necessary safeguards to protect the user's identity in a hostile environment. In contrast, the L1 protocol proved to be a significant leap forward. The formal verification showed that the L1 system successfully protected the secrecy of the data. The fingerprint image, the user's unique ID number, and the device's own identity remained hidden from the simulated attacker, even when the attacker could see every message traveling across the network. The hardware-based encryption in the L1 device effectively prevented an intruder from stealing the keys needed to impersonate a legitimate device.

However, the study did not declare the L1 system perfect. While the data itself remained secret, the researchers discovered a subtle but critical gap in how the two parties agreed on the timing of their conversation. In a secure exchange, the device and the server must not only keep secrets but also agree that they are talking to each other at the exact same moment in a specific sequence. The simulation revealed that while the L1 system kept the data safe, it was still possible for an attacker to perform a "session-splicing" attack. In this scenario, the attacker could take a piece of a conversation from one attempt and paste it into another, confusing the system about which session was which. The attacker could not steal the fingerprint or the ID number, but they could trick the device into accepting a response meant for a different interaction. This meant that while the L1 system was far superior to the L0 version, it still had a structural weakness that prevented it from achieving full, unbreakable synchronization.

The researchers concluded that the L1 architecture is a vast improvement over its predecessor, successfully closing the door on many major theft and cloning attacks. Yet, the remaining synchronization gap indicates that the current design relies too heavily on the messages themselves to prove identity, rather than having the server generate a unique, un-replayable token that binds the entire session together. The authors suggest that future revisions of the L1 specification must include a mechanism where the server creates a fresh, internal value that cannot be forged or forwarded by an attacker. Until this architectural adjustment is made, the system will remain vulnerable to this specific type of confusion, even though the biometric data itself remains secure. The work serves as a vital roadmap, showing that even in highly secure systems, the difference between "mostly safe" and "completely secure" often lies in the fine details of how two computers agree to talk to each other.

Technical Summary: A Formal Verification Framework for Biometric Authentication Protocols

Problem Statement
Biometric authentication systems, particularly large-scale national identity programs like India's Aadhaar, rely on complex security protocols to verify user identity. While biometric data offers advantages over traditional credentials (e.g., non-reusability), these systems are vulnerable to sophisticated threats including replay attacks, man-in-the-middle (MITM) attacks, device cloning, and session hijacking. The paper highlights a critical distinction between two levels of biometric assurance:

Level-0 (L0): A primitive architecture relying on software processing with minimal hardware security. It is susceptible to data exposure, tampering, and impersonation due to a lack of secure hardware boundaries.
Level-1 (L1): An advanced architecture utilizing hardware-based security components (Secure Elements, Trusted Platform Modules) and certified encryption modules to isolate keys and encrypt data at the point of capture.

Despite the adoption of L1, traditional validation methods (simulation, penetration testing) are limited in scope and cannot exhaustively verify correctness against all possible execution paths. The authors identify a need for a rigorous, mathematical approach to verify that L1 protocols not only protect data secrecy but also ensure correct session synchronization and agreement between the device and the server.

Methodology
The authors employ Formal Verification using the Scyther model checker under the Dolev-Yao adversary model. This model assumes an active adversary with full control over the communication channel but who cannot break cryptographic primitives.

Protocol Modeling:
- L0 Baseline: The existing Aadhaar L0 protocol was formally modeled based on prior work to serve as a vulnerability baseline.
- L1 Specification: The L1 protocol was modeled based on the official UIDAI standard specification. The model captures the interaction between the L1-Device (biometric sensor with secure element) and the UIDAI-SERVER (Central Identities Data Repository).
- Cryptographic Primitives: The model incorporates asymmetric encryption, digital signatures, SHA-256 hashing, and a specific "Pre-Certified Hardware Key" ( $K_{CIk}$ ) embedded in the device's secure element for hardware-bound attestation.
Iterative Refinement:
- The authors initially modeled the L1 protocol and analyzed it against secrecy and agreement claims.
- Upon discovering synchronization failures, they iteratively strengthened the model by introducing a device-generated session nonce ( $N_0$ ) that is echoed back by the server and threaded through all subsequent messages to bind the session.
Verification Claims:
- Secrecy: Verification of confidentiality for biometric data (FIR), device identifiers, Aadhaar numbers, and session nonces.
- Agreement/Synchronization: Verification of Weakagree, Nisynch (Non-injective synchronization), and Niagree (Non-injective agreement) to ensure the device and server agree on the session history and participants.

Key Results
The formal analysis yielded distinct outcomes for the L0 and L1 protocols:

L0 Protocol: The verification confirmed that the L0 protocol is fundamentally insecure. It failed all secrecy and agreement claims, demonstrating susceptibility to replay, MITM, device cloning, and session hijacking. The adversary could recover session keys and provider identifiers, enabling full impersonation.
L1 Protocol (Secrecy): The L1 protocol successfully preserved all declared secrecy properties. The formal verification confirmed that:
- Biometric data (FIR) and Aadhaar numbers remain confidential.
- Device identifiers (Serial Number, Device Code) are protected, even if the host software is compromised, due to hardware-bound encryption ( $K_{CIk}$ ).
- Authentication results and server nonces are secure.
- No attack traces were found for secrecy claims across an unbounded number of concurrent sessions.
L1 Protocol (Synchronization Gap): Despite securing secrecy, the L1 protocol failed the Nisynch and Niagree claims.
- The Attack: Scyther identified a session-splicing attack. An adversary can intercept the device's initial challenge, relay it to the server under a different identity, and then splice the server's valid response (signed for a different session) back to the device.
- Persistence: Even after the authors iteratively strengthened the model by threading a session nonce ( $N_0$ ) through all messages, the synchronization gap persisted. The attack trace revealed that because the server's response is not bound to a value generated by the server that is unique to that specific session instance (and not observable/forwardable by the adversary), the adversary can open a parallel session and combine ciphertext blocks from distinct sessions.

Significance and Claims
The paper claims to be the first formal verification of the Aadhaar L1 protocol specifically, distinct from general biometric protocol analysis or L0 verification. Its significance lies in:

Validation of Hardware Security: It formally demonstrates that the L1 hardware-rooted architecture effectively closes the secrecy vulnerabilities present in L0, specifically protecting against device cloning and credential leakage even in compromised software environments.
Revealing Architectural Limitations: The study highlights that secrecy analysis alone is insufficient. A protocol can be "secret" (no data leakage) yet fail to achieve full session synchronization. The authors identify a residual architectural limitation in the L1 specification: the server's response lacks a binding to a non-forwardable, server-side session-local value.
Concrete Recommendation: The authors propose a specific direction for future revisions of the L1 specification: the introduction of a server-side, session-local binding value that cannot be derived or replayed from any message content observable by the adversary. This is presented as a necessary amendment to achieve full injective agreement.

Limitations
The authors acknowledge several constraints:

Verification was performed using a single tool (Scyther) and has not been cross-validated with Tamarin or ProVerif.
The L0 baseline relies on a model from prior work rather than being re-derived.
The study addresses the protocol specification, not the concrete implementation; it cannot rule out implementation-level vulnerabilities like side-channel leakage.
The synchronization gap was identified as a structural limitation of the message-binding approach, and the authors did not implement a full redesign to resolve it, but rather identified the necessary architectural change.

More like this