Yippee-Ki-Yay, Blockchain: Exploiting Decentralized Systems One Die Hard at a Time

Sofia Bobadilla (PhD Student · KTH Royal Institute of Technology)

SEC-T 2026 · Day 1 · Main hall

Overview

In her SEC-T talk, "Yippee-Ki-Yay, Blockchain: Exploiting Decentralized Systems One Die Hard at a Time," Sofia Bobadilla, a PhD student at KTH Royal Institute of Technology, delivers an insightful and engaging presentation on the evolving landscape of blockchain security. Drawing parallels to the iconic Die Hard movie series, Bobadilla dissects three landmark exploits that have collectively resulted in billions of dollars in losses across various decentralized protocols. Her talk transcends mere technical explanation, framing complex vulnerabilities within relatable narratives of deception and unexpected attack vectors.

Watch on YouTube

Visual summary for Yippee-Ki-Yay, Blockchain: Exploiting Decentralized Systems One Die Hard at a Time by Sofia Bobadilla
Visual summary for Yippee-Ki-Yay, Blockchain: Exploiting Decentralized Systems One Die Hard at a Time by Sofia Bobadilla

Key moments

  1. 0:00 Introduction and Die Hard analogy for exploits
  2. 5:40 The DAO attack: Reentrancy vulnerability explained
  3. 11:50 Blind signing and multi-sig wallet vulnerabilities
  4. 14:00 Bybit's 1.5B loss: A supply chain attack
  5. 20:10 Proxy pattern: A dangerous way to upgrade contracts
  6. 23:30 Coordinated rescue of protocols from CPIM attack
  7. 30:00 Summary of three attacks and lessons learned
  8. 34:00 Audience Q&A: Ecosystem maturity and favorite attack

Yippee-Ki-Yay, Blockchain: Exploiting Decentralized Systems One Die Hard at a Time

Speakers: Sofia Bobadilla, PhD Student, KTH Royal Institute of Technology

Conference: SEC-T

YouTube: https://www.youtube.com/watch?v=OjRS2NN-W-g

Overview

In her SEC-T talk, "Yippee-Ki-Yay, Blockchain: Exploiting Decentralized Systems One Die Hard at a Time," Sofia Bobadilla, a PhD student at KTH Royal Institute of Technology, delivers an insightful and engaging presentation on the evolving landscape of blockchain security. Drawing parallels to the iconic Die Hard movie series, Bobadilla dissects three landmark exploits that have collectively resulted in billions of dollars in losses across various decentralized protocols. Her talk transcends mere technical explanation, framing complex vulnerabilities within relatable narratives of deception and unexpected attack vectors.

The presentation highlights that while the underlying blockchain technology offers unprecedented transparency and immutability, the applications built upon it are far from impervious to attack. Bobadilla emphasizes that vulnerabilities often arise not just from flaws in smart contract code, but from broader issues spanning software supply chains, human interaction with cryptographic interfaces, and the intricate dependencies within decentralized ecosystems. This talk is crucial for anyone involved in Web3 development, security, or investment, as it demystifies the mechanisms behind major exploits and underscores the critical need for robust, multi-layered security strategies that extend beyond the smart contract itself.

Bobadilla's research focuses on automated repair for smart contract vulnerabilities, making her uniquely positioned to discuss both the genesis of these problems and potential avenues for mitigation. By categorizing the exploits as "misplaced assumptions," she provides a clear framework for understanding how seemingly minor oversights or design choices can lead to catastrophic financial losses in the immutable world of blockchain. The talk serves as a stark reminder that while the technology is novel, many of the underlying security principles and attack methodologies echo challenges faced in traditional software systems.

Background

▶ Watch: Introduction and Die Hard analogy for exploits (0:00)

The advent of smart contracts extended the utility of blockchains far beyond simple financial transactions, enabling complex logic and decentralized applications (dApps). Unlike traditional web applications with front-end, back-end, and database components, dApps typically feature a front-end (often hosted on IPFS for immutability) interacting directly with smart contract logic residing on the blockchain. This shift introduces a unique and expanded attack surface that requires a re-evaluation of security paradigms.

Bobadilla delineates four primary layers susceptible to attack in a blockchain application:

  1. Off-chain Application Layer: This includes decentralized exchanges (DEXs) and other web interfaces that users interact with to initiate transactions (e.g., swapping cryptocurrencies).
  2. Smart Contract Layer: The core logic written in languages like Solidity, which executes on the blockchain. Bugs here are unforgiving, as the blockchain executes code precisely as written.
  3. Infrastructure Layer: The network of nodes that validate transactions and maintain the blockchain's state.
  4. Development Layer: Encompasses the human element – developers creating smart contracts, wallets, and front-ends, and managing critical keys controlling smart contracts.

When a user interacts with a dApp, they send a transaction request signed with their private key. This transaction, if successful, modifies the blockchain's state. The immutability of deployed smart contracts, while a core feature, also means that once a vulnerability is discovered and exploited, it's often irreversible. This context sets the stage for understanding the three "milestone" exploits discussed, each representing a significant learning experience for the nascent blockchain community and illustrating how a single pattern of vulnerability, once discovered, can be widely replicated across other protocols.

Key Findings

▶ Watch: Blind signing and multi-sig wallet vulnerabilities (11:50)

Sofia Bobadilla’s talk meticulously unpacks three pivotal blockchain exploits, each illustrating a distinct class of vulnerability that has profoundly shaped the understanding of decentralized system security. These attacks, while varied in their technical specifics, share a common thread: a "misplaced assumption" about the system's behavior or security perimeter.

The DAO attack (circa 2016) exposed the critical reentrancy vulnerability. This attack demonstrated that flawed sequencing in smart contract code, specifically when interacting with external contracts, could allow an attacker to repeatedly withdraw funds before the internal state was updated. It highlighted a fundamental design flaw where the system inadvertently helped the attacker open the vault, leading to a $60 million loss. The key finding here was the necessity of updating internal state before yielding control to external calls, a lesson that led to the development of tools like Slither and established reentrancy as a canonical vulnerability.

The Bybit attack (which resulted in a $1.5 billion theft, though the speaker refers to the general pattern as Bybit, it's more widely known as the Ronin Bridge hack, demonstrating the speaker's analogy connecting to a broader pattern rather than a single specific event) unveiled the immense risks associated with software supply chain attacks and blind signing. This exploit targeted not the smart contract's core logic, but an external dependency—a multi-sig wallet interface (the Safe wallet, as mentioned by the speaker). Attackers compromised a developer key to inject malicious code into the wallet's front-end, specifically targeting routine transactions of a high-value protocol. The core finding was that even highly secure, audited smart contracts are vulnerable if the tools and interfaces used to interact with them are compromised, especially when users are forced to "blindly sign" transactions without clear human-readable context. This emphasized that security extends beyond the contract code to the entire operational stack and the human-computer interface.

Finally, the CPIM (Clandestine Proxy in the Middle) attack showcased a sophisticated, hidden implant within the blockchain itself, exploiting the proxy pattern used for upgradable smart contracts. This attack leveraged a race condition during proxy initialization, allowing an attacker to insert a malicious proxy that would lie dormant, acting normally for small transactions, but waiting for "whales" (users with significant funds) to exploit. The key finding was the subtle nature of on-chain deception, where malicious code could mimic legitimate behavior while waiting for the opportune moment. This exploit underscored the importance of atomic initialization for proxies, rigorous monitoring of transaction traces for unusual delegation patterns, and the power of coordinated defensive efforts within the security community to mitigate systemic risks before widespread loss.

In aggregate, these findings illustrate that blockchain security is a multifaceted challenge, encompassing not only cryptographic integrity and smart contract correctness but also the integrity of development tools, the usability of security interfaces, and the vigilance of the operational teams and the broader security community.

Technical Deep Dive

▶ Watch: Proxy pattern: A dangerous way to upgrade contracts (20:10)

Act One: The DAO Attack – Reentrancy

The DAO (Decentralized Autonomous Organization) was an early, ambitious experiment in decentralized governance and fund management. Its smart contract, acting as executable code, allowed members to deposit and withdraw funds based on predefined rules. The critical vulnerability resided in its withdraw function. In the Solidity programming language (used for Ethereum smart contracts), message.sender.call is a low-level function that allows a contract to send Ether to another address and, crucially, to execute code on the recipient contract if it's also a contract.

The DAO's withdraw function followed this sequence:

  1. Retrieve the amount to transfer (balanceOf[msg.sender]).
  2. Send the Ether to msg.sender (msg.sender.call.value(amount)()).
  3. Update the sender's balance to zero (balanceOf[msg.sender] = 0).

The flaw was in the order of operations. An attacker's malicious contract, upon receiving Ether in step 2, could immediately call the withdraw function again. Because balanceOf[msg.sender] had not yet been updated to zero (step 3), the attacker's contract could repeatedly withdraw the same amount, draining the DAO's funds until the contract was empty. This recursive call back into the original function is known as a reentrancy attack.

The safe order of operations, now a standard practice, is:

  1. Retrieve the amount.
  2. Update the sender's balance to zero.
  3. Send the Ether.

This ensures that even if the recipient calls back, their balance has already been zeroed out, preventing further withdrawals. Bobadilla emphasizes that this attack highlighted the critical need to update internal state before yielding control to external calls. The pattern is now a well-understood and largely "solved problem" in the security community, with tools like Slither (developed by Jocelyn Pyce) designed to automatically detect reentrancy vulnerabilities.

Act Two: The Bybit Attack – Software Supply Chain and Blind Signing

The Bybit attack (or rather, the pattern it represents, exemplified by the Ronin Bridge hack) exposed vulnerabilities in the broader software supply chain and the human element of blind signing. Transactions on a blockchain require a user to sign a message with their private key, proving ownership and authorizing the action. However, these messages are often presented to users as raw hexadecimal bytes, making it nearly impossible for a human to verify what they are actually approving. This is blind signing.

To mitigate single points of failure, many high-value protocols implement multi-signature (multi-sig) wallets. A multi-sig wallet requires a predefined number of approvals (e.g., 3 out of 5 designated signers) to execute a transaction. This increases the security threshold, as an attacker would need to compromise multiple private keys or deceive multiple individuals.

In the Bybit/Ronin case, the smart contracts were robust and audited, and a multi-sig mechanism was in place. The weakest link was not the blockchain itself, but an external software dependency: the Safe wallet interface. Attackers compromised a developer key within the Safe wallet team, enabling them to inject malicious code into the wallet's front-end via Amazon Web Services (AWS). This injected code was specifically designed to target routine transfers from the Bybit protocol (or the targeted protocol in the Ronin case).

When the designated signers for Bybit attempted to perform a routine transfer, the compromised Safe wallet interface presented them with a hash that appeared normal. Unbeknownst to them, the injected code silently altered the transaction to redirect 1.5 billion USD to the hackers' accounts. The signers, unable to decipher the raw bytes of the transaction hash, "blindly signed" the malicious transfer, assuming it was a legitimate, routine operation.

This attack underscored that security is only as strong as its weakest link, which can often be an external, trusted third-party service or a compromised front-end. Defenders must protect front-end releases and verify transactions using simulation tools like Tenderly or malicious transaction detectors like mab.xyz before signing, always questioning what bytes are being approved.

Act Three: The CPIM Attack – Clandestine Proxy in the Middle

The CPIM (Clandestine Proxy in the Middle) attack targeted the proxy pattern, a common design choice in smart contract development. While smart contracts are generally immutable, the proxy pattern allows for upgradability. A proxy contract acts as a fixed entry point, holding the contract's state (data), but delegates its logic execution to a separate implementation contract whose address can be changed. This means a dApp can be upgraded by simply pointing the proxy to a new implementation contract (e.g., version one, version two, version three). Stablecoins like USDC utilize this pattern.

The danger lies in the delegatecall function, which executes the code of the implementation contract in the context of the proxy contract. If the implementation address is maliciously controlled, the proxy's funds and state can be manipulated. The CPIM vulnerability exploited a race condition during the proxy's initialization. Typically, a proxy is deployed, and then a separate transaction initializes it, assigning ownership. Attackers observed newly deployed proxies on the public blockchain and, through a "craftsman's activity," quickly sent their own initialization transaction, taking ownership before the legitimate owner could.

The attacker then pointed the compromised proxy to a clandestine proxy they controlled. This clandestine proxy was designed to appear benign, delegating to the real legitimate implementation for small, routine transactions. However, it lay dormant, waiting for a "whale" (a user with significant funds) to interact with the contract. When a large transaction occurred, the clandestine proxy would intercept it, redirecting funds or manipulating logic as desired, while still appearing normal to blockchain explorers due to subtle obfuscation techniques.

The detection of CPIM was a testament to vigilant on-chain monitoring. A security researcher named David noticed anomalous transaction traces with "two times called delegator"—an extra, unexpected delegation call. This led to a coordinated investigation by the Seal Team, a security alliance. They performed public blockchain queries to identify other protocols exhibiting this "proxy calling a proxy calling an implementation" pattern. Through transaction simulations, they discovered the attacker's logic, including a hidden limit (e.g., blocking withdrawals over 85% of funds) designed to prevent detection.

The coordinated rescue involved contacting affected protocols and executing simultaneous withdrawals to prevent the attackers from draining all identified targets once they realized they were discovered. This highlights the importance of atomic initialization (deploying and initializing a proxy in a single transaction), rigorous verification of implementation bytecode, and alerting on extra delegation in transaction traces. The finding that 95% of smart contract transactions touch multiple contracts underscores the pervasive risk of complex dependencies.

Demo / Proof of Concept

▶ Watch: Coordinated rescue of protocols from CPIM attack (23:30)

While the talk did not feature a live demonstration or proof-of-concept by the speaker, it meticulously dissected several high-profile exploits, effectively serving as a detailed post-mortem analysis. Sofia Bobadilla's presentation leveraged visual aids, code snippets (conceptual, not live), and analogies to explain the technical mechanisms of each attack. The focus was on illustrating how these vulnerabilities were exploited in real-world scenarios, providing a conceptual "proof of concept" through historical examples rather than a live hack.

Defensive Implications

▶ Watch: Audience Q&A: Ecosystem maturity and favorite attack (34:00)

The detailed analysis of these landmark exploits by Sofia Bobadilla offers crucial defensive implications for developers, operators, and users within the decentralized ecosystem. The overarching message is that security in Web3 extends far beyond just auditing smart contract code; it encompasses the entire software supply chain, human factors, and continuous monitoring.

  1. Smart Contract Design and Implementation:
  • Reentrancy Prevention: Always update internal state (e.g., balances) before making external calls or yielding control to other contracts. This is the "update internal state before yielding control" principle derived from the DAO attack. Utilize checks-effects-interactions pattern.
  • Invariant Enforcement: Developers must explicitly enforce critical invariants and assumptions within their smart contract code at runtime. If a function should only be called by a specific role, or if a certain state must hold true, these conditions should be programmatically validated.
  • Atomic Proxy Initialization: For upgradable contracts using the proxy pattern, ensure that deployment and initialization occur within a single, atomic transaction. This prevents race conditions where an attacker could seize ownership before the legitimate owner.
  • Code Verification: It is paramount to verify that the bytecode deployed to the blockchain precisely matches the intended source code. Discrepancies can hide malicious implants.
  • Composability Awareness: Given that 95% of blockchain transactions involve multiple contracts, developers must thoroughly understand and account for the risks introduced by interactions with external protocols and dependencies.
  1. Software Supply Chain Security:
  • Vet External Dependencies: Any external tool, library, or service used in the development, deployment, or operation of a dApp (e.g., wallets, front-end frameworks, cloud services like AWS) represents a potential attack vector. These must be rigorously vetted and secured.
  • Front-End Release Protection: The integrity of dApp front-ends is critical. Mechanisms must be in place to prevent code injection or unauthorized modification of user-facing interfaces, as demonstrated by the Bybit/Ronin attack.
  1. Transaction Signing and User Experience:
  • Eliminate Blind Signing: Wallet providers and dApp developers must collaborate to create user interfaces that provide clear, human-readable explanations of what a transaction is doing before it is signed. Users should never be forced to "blindly sign" raw hexadecimal hashes.
  • Transaction Simulation: Users and operators of high-value protocols should leverage tools like Tenderly to simulate the outcome of a transaction before signing it. This can reveal unexpected state changes or malicious redirects.
  • Malicious Transaction Detection: Tools like mab.xyz can help identify suspicious patterns or known hacker accounts associated with proposed transactions.
  1. Monitoring and Incident Response:
  • On-Chain Monitoring: Continuous, vigilant monitoring of transaction traces and on-chain activity is essential. Anomalous patterns, such as "double delegator" calls in proxy interactions, should immediately trigger investigations.
  • Rehearse Response: Protocols should have well-defined incident response plans, including coordinated rescue strategies, as demonstrated by the Seal Team's successful mitigation of the CPIM attack. The ability to communicate and act swiftly and collaboratively across the ecosystem is vital.
  • Community Collaboration: The success of the CPIM mitigation highlights the power of security alliances and open communication within the Web3 community to identify and respond to threats effectively.

Ultimately, defenders must adopt a mindset of "paranoia" and recognize that security is a holistic challenge. Traditional security instincts are highly transferable to Web3, requiring constant vigilance across code, infrastructure, operations, and the human element.

Key Takeaways

  • State Before External Calls: Always update a smart contract's internal state (e.g., balances) before making external calls or yielding control to another contract to prevent reentrancy vulnerabilities like the DAO attack.
  • Supply Chain Vulnerabilities: Security extends beyond smart contract code to the entire development and operational stack, including external tools, wallets, and front-end interfaces. Compromised dependencies, as seen in the Bybit/Ronin attack, can bypass even robust on-chain security.
  • Blind Signing is Dangerous: Users must be able to verify exactly what they are approving in a human-readable format. "Blind signing" raw transaction hashes introduces significant risk and is a major vector for deception.
  • Proxy Pattern Risks: While useful for upgradability, the proxy pattern introduces complexities. Atomic initialization and vigilant monitoring of transaction traces for anomalous delegation calls (like the "double delegator" in CPIM) are crucial to prevent hidden implants.
  • Vigilance and Collaboration are Key: Continuous on-chain monitoring, transaction simulation, and robust community collaboration (e.g., security alliances) are essential for detecting and mitigating sophisticated attacks before widespread damage occurs.
  • Security is Holistic: Effective Web3 security requires a multi-layered approach, addressing vulnerabilities across smart contract logic, software supply chain, user interfaces, and human operational procedures, embodying a "paranoia" that transcends traditional security boundaries.

About the Speaker(s)

Sofia Bobadilla is a PhD Student at KTH Royal Institute of Technology in Sweden. Her research focuses on automated repair for vulnerabilities in smart contract code, an area critical for enhancing the security and resilience of decentralized systems. Throughout her talk, she draws connections to her team's work, including research on smart contract invariants to protect against cybercriminals and studies on the software supply chain security of Web3 applications. Her expertise lies in understanding the intricate technical details of smart contract exploits and developing methodologies to prevent and mitigate them.

Reviews

Dr. Zero (Offensive Security Researcher) — WEAK

It's a competent retrospective of Web3's biggest architectural fuck-ups, but if you're looking for net-new research, you're in the wrong room. Bobadilla breaks down the DAO, Ronin, and proxy race conditions clearly, making this a solid educational primer rather than a bleeding-edge exploit drop.

Heather Calloway (CISO) — SOLID

This is a clear-eyed breakdown of how billion-dollar Web3 losses actually happen, stripping away the blockchain mystique to reveal traditional operational failures. Bobadilla proves that securing a decentralized app requires the same vendor risk management and interface scrutiny as any legacy financial platform. Worth your time if your business touches digital assets.

→ Top-rated talks at SEC-T 2026

All talks from SEC-T 2026