Cryptographic Protocol Analysis for the Rest of Us
Nadim Kobeissi
Swiss Cyber Storm 2026 · Day 1 · Scenario
Overview
In this insightful talk at Swiss Cyber Storm, Nadim Kobeissi introduces Verifpal, a novel cryptographic protocol analysis and verification tool designed to democratize formal methods for a broader audience beyond academic specialists. The presentation highlights the critical need for accessible tools to analyze the security of cryptographic protocols, which underpin virtually all modern digital communication—from HTTPS and TLS to secure messaging apps like WhatsApp and Signal. Kobeissi argues that traditional formal verification tools, while powerful, are often hampered by complex languages, opaque results, and an academic focus that alienates industry practitioners, students, and general security engineers.

Key moments
- 2:10 The problem with academic protocol analysis tools
- 4:30 Introducing Verifpal: democratizing protocol analysis
- 6:00 Verifpal's simple language and readable attack results
- 10:30 Modeling forward secrecy, post-quantum, and nonce reuse
- 14:30 Real-world bug found in WalletConnect using Verifpal
- 18:00 Verifpal's tradeoffs: attack finding vs. unbounded proofs
- 24:00 The need for readable models in the age of AI
- 29:00 How Verifpal fits into organizational security teams (Q&A)
Cryptographic Protocol Analysis for the Rest of Us
Speakers: Nadim Kobeissi
Conference: Swiss Cyber Storm
YouTube: https://www.youtube.com/watch?v=8ShWCn4fjW4
Overview
In this insightful talk at Swiss Cyber Storm, Nadim Kobeissi introduces Verifpal, a novel cryptographic protocol analysis and verification tool designed to democratize formal methods for a broader audience beyond academic specialists. The presentation highlights the critical need for accessible tools to analyze the security of cryptographic protocols, which underpin virtually all modern digital communication—from HTTPS and TLS to secure messaging apps like WhatsApp and Signal. Kobeissi argues that traditional formal verification tools, while powerful, are often hampered by complex languages, opaque results, and an academic focus that alienates industry practitioners, students, and general security engineers.
Verifpal aims to bridge this gap by offering an intuitive language, human-readable attack traces, and a built-in understanding of cryptographic primitives, making it easier for non-experts to reason about protocol security. The tool prioritizes an iterative discovery process, empowering users to quickly identify vulnerabilities and refine their protocol designs. By making advanced cryptographic analysis more approachable, Verifpal seeks to enhance the security posture of real-world systems, allowing developers and security teams to proactively identify and mitigate protocol flaws without requiring deep formal methods expertise.
Kobeissi emphasizes that Verifpal is not intended to replace the rigorous, unbounded proofs offered by tools like Tamarin or ProVerif, but rather to serve as a practical, attack-finding instrument that terminates reliably and provides clear, actionable insights. Its utility extends to modeling complex scenarios such as forward secrecy, post-compromise security, nonce reuse, and even post-quantum cryptographic transitions, demonstrating its relevance to cutting-edge security challenges. The talk culminates in a compelling real-world example of Verifpal uncovering a critical vulnerability in the WalletConnect protocol, underscoring the tool's immediate practical value.
Background
▶ Watch: The problem with academic protocol analysis tools (2:10)
The landscape of cryptographic protocols is vast and complex, forming the backbone of secure digital interactions. Protocols like TLS (used in HTTPS) and the Signal Protocol (used by WhatsApp and Signal) are ubiquitous, yet their security is paramount and often subtle. A common challenge is determining whether a protocol, even a seemingly simple one like a challenge-response authentication protocol, is truly secure against various adversaries, including passive attackers (who merely observe messages) and active attackers (who can intercept, modify, and inject messages).
Historically, researchers and academics have developed sophisticated formal methods and tools to analyze and prove the security of these protocols. Tools such as Tamarin, ProVerif, and CryptoVerif represent the state-of-the-art in this domain. Tamarin, for instance, has been under development since 2012 and is highly capable of producing rigorous proofs. However, Kobeissi critically points out that these tools are primarily designed "by academics for academics." Their languages are often arcane, requiring specialized knowledge of formal logic and cryptographic theory to even model a protocol. The example shown from Tamarin illustrates a dense, symbolic representation of a simple challenge-response protocol, which is largely inaccessible to industry practitioners.
Furthermore, the output from these academic tools, particularly attack traces, can be equally inscrutable. They often present complex, symbolic sequences that are difficult to decipher without significant training, hindering an iterative discovery and reasoning process. This steep learning curve and lack of user-friendliness create a significant barrier to entry, leaving many engineers and students unable to leverage these powerful analysis capabilities. Kobeissi also highlights practical limitations, noting that even tools like Tamarin, while theoretically sound and complete on paper, have recently been found to contain "bug after bug after bug" in their implementations, casting doubt on their real-world guarantees. Moreover, symbolic protocol analyzers often lack the granularity to differentiate between subtle but crucial cryptographic primitive details, such as the bit length of hash functions (e.g., 64-bit vs. 128-bit) or block ciphers, thereby losing important nuances that affect real-world security. This combination of complexity, opaque results, and practical shortcomings underscores the pressing need for a more accessible and empowering approach to cryptographic protocol analysis.
Key Findings
▶ Watch: Verifpal's simple language and readable attack results (6:00)
Verifpal distinguishes itself through several key findings and design principles aimed at democratizing cryptographic protocol analysis. Its core contribution is an accessible, intuitive language that allows users to model protocols in a natural, whiteboard-like manner. Instead of abstract symbols, Verifpal uses explicit concepts like principals (e.g., Alice, Bob) and built-in definitions for cryptographic primitives such as private keys (SK), public keys (PK), signing functions (sign), and verification functions (verif). This approach eliminates the need for users to define these primitives themselves, reducing potential for error and simplifying the modeling process.
A significant finding is Verifpal's ability to provide human-readable attack traces. Unlike the "incomprehensible and difficult to decipher" outputs of other tools, Verifpal presents attack scenarios in natural English, using the user's defined variable names. This feature, which was a "major engineering challenge," allows users to quickly understand how a protocol might be attacked (e.g., a man-in-the-middle attack where an attacker observes, forges, and replaces a challenge), fostering an iterative design and learning process.
Verifpal also introduces powerful mechanisms to model complex security properties and temporal aspects:
- Guarding Values: The concept of a "guarded value" (e.g.,
[PK]) allows users to simulate out-of-band authentication or secure communication channels, preventing an active attacker from modifying specific values without detection. This is crucial for modeling scenarios like QR code scanning in apps like WhatsApp. - Temporal Logic (Phases): Verifpal employs "phases" to model temporal logic, enabling the analysis of security properties over time. This is vital for assessing forward secrecy (compromise of long-term keys doesn't compromise past messages) and post-compromise security (recovery after a key leak). Users can define different phases (e.g.,
phase 0for "today,"phase 1for "tomorrow") and model events like key leaks occurring after initial protocol execution. - Nonce Reuse Modeling: The tool can explicitly model scenarios where a party reuses a nonce with the same key, a common vulnerability in many authenticated encryption and signature schemes.
- Post-Quantum Transition Modeling: Verifpal incorporates "weakening parameters" to simulate the impact of future cryptographic advancements, such as the advent of quantum computers. Users can define primitives (e.g.,
E_later) that become "weak from phase two," allowing for analysis of post-quantum security and migration strategies. This weakening can apply to both symmetric and asymmetric primitives, modeling them as "forgeable" or "malleable" in later phases. - Parallel Session Analysis and Compromised Peers: Verifpal allows modeling of multiple parallel protocol instantiations, including scenarios where one of the peers is compromised (e.g.,
Mallorywith a leaked private key). This capability is critical for uncovering complex attacks like Lowe's 1995 attack on Needham-Schroeder, which relies on interactions between honest and dishonest parties in concurrent sessions.
Finally, a key finding is Verifpal's deliberate trade-off: it prioritizes reliable termination and clear attack traces over providing unbounded proofs of attack absence. While it cannot offer the same strong mathematical guarantees as Tamarin or ProVerif regarding the absence of attacks, it excels as an "attack-finding tool," consistently providing precise, understandable explanations when vulnerabilities are detected. This pragmatic approach makes it highly valuable for practical security engineering and education.
Technical Deep Dive
▶ Watch: Real-world bug found in WalletConnect using Verifpal (14:30)
Verifpal's technical foundation rests on a symbolic protocol analysis engine wrapped in a user-centric design. At its core, the tool interprets a high-level, human-readable language into a formal model suitable for analysis. The language itself is a direct response to the complexity of existing formal verification tools. Instead of requiring users to define fundamental cryptographic concepts, Verifpal provides built-in definitions for common primitives like public-key cryptography (gen_pk, sign, verif), symmetric encryption (enc, dec), and hashing. This not only simplifies the modeling process but also removes a significant source of user error where incorrect or incomplete primitive definitions could lead to flawed analyses.
The language syntax emphasizes clarity:
principal Alice, Bobdeclares the parties involved.Alice knows sk_Adefines Alice's knowledge of a private key.Alice sends {challenge} to Bobdescribes message flow.assert is_confidential(sk_A)queries for confidentiality properties.assert is_authenticated(proof)queries for authentication properties.
A critical feature is the explicit modeling of an active attacker, denoted by active_attacker. This instructs Verifpal to assume the attacker can intercept, modify, and inject messages on the network, a realistic threat model for many real-world protocols.
Verifpal's error handling is inspired by the Rust programming language, known for its highly informative and actionable compiler messages. If a user makes a mistake, such as forgetting to define a nonce for authenticated encryption, Verifpal provides detailed error messages that explain the primitive's requirements and guide the user towards correction. This is possible due to the built-in, comprehensive understanding of cryptographic primitive semantics.
The implementation of temporal logic via "phases" is a sophisticated technical achievement. By declaring phase 0, phase 1, etc., Verifpal partitions the execution timeline. This allows for modeling scenarios where cryptographic properties change over time or where key compromises occur at specific points. For example, Alice's long_term_keys are leaked from phase 1 explicitly tells the analyzer that after the initial protocol execution (phase 0), the attacker gains access to Alice's long-term secrets, enabling the assessment of forward secrecy and post-compromise security.
Similarly, the "weakening parameter" for primitives enables advanced post-quantum analysis. A primitive defined as enc_later(key, msg, nonce) weak from phase 2 tells Verifpal that enc_later provides security only until phase 2, after which it becomes breakable. This allows security engineers to model the impact of quantum computer availability on existing cryptographic schemes and test the resilience of protocols designed for post-quantum migration. The weakening definitions (forgeable, malleable) provide fine-grained control over how primitives behave under compromise.
Modeling parallel sessions and compromised peers is achieved through intuitive syntax like Alice runs protocol P with Bob and Alice runs protocol P with Mallory. By declaring Mallory's long_term_private_key is leaked, Verifpal can simulate complex multi-party interactions where an honest party communicates simultaneously with both honest and malicious entities, enabling the discovery of subtle attacks like those affecting the Needham-Schroeder protocol.
Crucially, Verifpal implements a mechanism for protocol termination based on verification outcomes. Adding a question mark (?) after a function like sign_verif(PK, msg, signature)? signifies that if the signature verification fails, the principal stops its execution. This simple yet powerful construct allows users to accurately model real-world protocol behavior where checks are meant to halt further processing upon failure, preventing vulnerabilities like the one discovered in WalletConnect. The entire system is built on an underlying symbolic model that can effectively explore the state space of protocol executions to find attack traces, but crucially, it focuses on providing these traces in an understandable format rather than abstract proof trees.
Demo / Proof of Concept
▶ Watch: Verifpal's tradeoffs: attack finding vs. unbounded proofs (18:00)
A compelling demonstration of Verifpal's real-world utility was its role in uncovering a critical bug in WalletConnect, a leading infrastructure provider for connecting Web3 wallets to decentralized applications (dApps). WalletConnect facilitates interactions where users sign into dApps or cryptocurrency exchanges using their mobile wallets, such as MetaMask.
The vulnerability stemmed from WalletConnect's previous implementation of a signature check. The code snippet shown illustrated a common pattern:
The critical flaw lay in the rejectFunction(). While it indicated an error or rejection, it did not actually return or stop the protocol execution. This meant that even if a signature was invalid, the protocol would simply display an error message but then proceed to execute the subsequent code, deriving a session key and continuing the session as if the signature was valid. This effectively bypassed the signature verification, allowing an attacker to potentially impersonate users or inject malicious transactions.
Verifpal was used to model this scenario. In Verifpal's language, a signature verification that must stop execution upon failure is denoted by a question mark (?) after the verification function, e.g., sign_verif(PK, msg, signature)?. In the WalletConnect model, this crucial ? was missing, accurately reflecting the real-world code's behavior. Verifpal's analysis quickly identified that the protocol would continue even with a failed signature check, demonstrating the vulnerability.
This bug, present since "2024" (likely referring to an internal version or continuous deployment, as the talk was given in 2023), was found using Verifpal and subsequently reported to WalletConnect maintainers, who acknowledged and began fixing it. This incident powerfully illustrates how Verifpal, with its intuitive modeling language and clear attack traces, can effectively capture real-world implementation nuances and uncover critical security flaws that might be missed by manual inspection or less accessible formal methods. It validated Verifpal's design philosophy of empowering users to reason about protocols in a way that directly translates to practical security improvements.
Defensive Implications
▶ Watch: How Verifpal fits into organizational security teams (Q&A) (29:00)
Verifpal offers significant defensive implications for security engineers, developers, and organizations working with cryptographic protocols. Its primary value lies in fostering an iterative design process for protocols. By providing an easy-to-learn language and clear attack traces, Verifpal enables teams to:
- Proactively Identify Flaws: Instead of waiting for security audits or real-world attacks, engineers can model their protocols in Verifpal during the design phase. This allows for early detection of vulnerabilities like man-in-the-middle attacks, nonce reuse issues, or logical flaws in authentication flows, significantly reducing the cost and effort of fixing them later.
- Enhance Protocol Understanding: Verifpal acts as an "interactive notebook" where protocol definitions serve as living documentation. The ability to query properties like confidentiality, authentication, unlinkability, and freshness provides a deeper understanding of the protocol's security guarantees and potential weaknesses.
- Bridge the Formal Methods Gap: As highlighted by Kobeissi, Verifpal can serve as a "bridge between the formal methods experts and the rest of the team." While formal methods specialists might use more rigorous tools like Tamarin or ProVerif for unbounded proofs, Verifpal provides a common, accessible language for the broader engineering team to understand the protocol's security model and analysis results. This localizes deep expertise while democratizing basic understanding.
- Guard Against Implementation Errors: The WalletConnect example demonstrates how Verifpal can expose critical implementation-level bugs stemming from a mismatch between intended protocol logic and actual code behavior (e.g., a
rejectFunctionthat doesn't halt execution). Defenders should use Verifpal to verify that critical checks, like signature verifications, are correctly modeled to stop protocol execution upon failure, using the?operator. - Model Advanced Security Properties: The inclusion of "phases" for temporal logic empowers defenders to analyze crucial properties like forward secrecy and post-compromise security, which are vital for modern secure communication systems. Similarly, the ability to model nonce reuse helps prevent catastrophic failures in authenticated encryption and signature schemes.
- Prepare for Post-Quantum Transitions: Verifpal's "weakening parameters" allow organizations to model the impact of future cryptographic compromises (e.g., quantum computers) on their protocols. This enables proactive design choices and migration strategies to ensure long-term security.
- Educate and Onboard New Engineers: Verifpal's user-friendly nature makes it an "unmatched" educational tool. It can effectively onboard new cryptography engineers, allowing them to quickly grasp protocol mechanics and security analysis principles without needing extensive formal methods training.
However, Kobeissi also stresses crucial caveats for defenders:
- Verifpal is an attack-finding tool, not a proof tool: It excels at finding vulnerabilities but cannot provide the same strong, unbounded mathematical proofs of attack absence as more complex academic tools. Defenders should use it for iterative improvement and attack discovery, complementing it with deeper formal analysis by experts where absolute proof of absence is required.
- Deployment Context is Critical: No formal analysis tool, including Verifpal, can guarantee security against poor deployment practices or software engineering flaws (e.g., leaking private keys on Twitter). Defenders must combine formal analysis with robust software engineering, secure development lifecycle practices, and thorough implementation audits.
- Nuance in Cryptographic Primitives: The talk highlights that real-world primitives have nuanced behaviors (e.g., AES-GCM vs. AES-GCM-SIV for nonce reuse resistance, Ed25519 vs. ECDSA, MD5 vs. Blake3). While Verifpal offers some modeling of this nuance, defenders must remain aware of the specific properties and failure modes of the primitives they employ, as formal tools may abstract some of these details.
In essence, Verifpal equips defenders with an accessible, powerful tool to reason about, test, and improve the security of their cryptographic protocols, fostering a more proactive and informed approach to security engineering.
Key Takeaways
- Democratizing Protocol Analysis: Verifpal makes cryptographic protocol analysis accessible to a broader audience, including industry practitioners and students, by offering an intuitive language and human-readable attack traces, unlike complex academic tools.
- Attack-Finding Focus: Verifpal is designed primarily as an "attack-finding tool" that reliably terminates and provides precise, understandable attack explanations, rather than focusing on unbounded proofs of attack absence.
- Iterative Design Empowerment: The tool facilitates an iterative design process, allowing users to quickly model, query, and refine protocols, aiding in early vulnerability detection and continuous security improvement.
- Advanced Modeling Capabilities: Verifpal supports modeling sophisticated security properties like forward secrecy, post-compromise security, nonce reuse, and even post-quantum cryptographic transitions through features like "phases" and "weakening parameters."
- Real-World Impact: Verifpal has proven its practical value by uncovering critical vulnerabilities in real-world protocols, such as the WalletConnect bug where a signature check failed to halt protocol execution.
- Bridge to Formal Methods: The tool serves as an effective bridge between specialized formal methods experts and general engineering teams, promoting a common understanding of protocol security models and analysis results.
About the Speaker(s)
Nadim Kobeissi is the developer of Verifpal, a cryptographic protocol analysis and verifier tool that he has been developing for the past seven years. He describes Verifpal as a "fully open source, fun, happy, yay project" that he works on out of passion. Kobeissi emphasizes that Verifpal is not a commercial endeavor. His work on Verifpal is recognized, with the tool being used by a variety of companies and universities, and he highlights its particular strength as an educational tool, stating there is "no better way to learn about cryptographic protocols and modeling cryptographic protocols in the world than Verifpal." He is also working on an upcoming Verifpal textbook, further cementing his commitment to making formal verification more accessible.
Reviews
Dr. Zero (Offensive Security Researcher) — STRONG ACCEPT
Kobeissi tackles the UX nightmare of formal cryptographic verification. Verifpal trades unbounded mathematical proofs for readable attack traces and guaranteed termination, making it something product engineers can actually use to find implementation bugs.
Heather Calloway (CISO) — SOLID
Kobeissi pitches a formal verification tool for the rest of us, and for once, it is not academic vaporware. Verifpal trades unbounded mathematical proofs for readable attack traces that engineering teams can actually use. Worth handing to your product security leads to see if they can bake it into early protocol design.