Common Smart Contract Vulnerabilities: Delegatecall Exploits

The delegatecall function in Solidity is a powerful feature that, if misused, can turn into a significant vulnerability. While it’s designed to allow a contract to execute code in the context of another contract—preserving the caller’s storage, caller, and value—it requires careful handling to avoid security pitfalls. This article focuses on the vulnerabilities associated with incorrect delegatecall usage, illustrated through examples, and offers solutions for security researchers to identify and mitigate these risks.

Understanding Delegatecall

delegatecall is often used to interact with library contracts or to enable upgradeable smart contracts. It executes another contract’s code in the context of the calling contract’s storage. This means any modifications made by the called contract directly affect the caller’s state. While this feature enables modular and flexible contract design, it also opens a door to vulnerabilities if the storage layout is not carefully managed or if untrusted contracts are called.

Vulnerable Storage: The Delegatecall Context Issue

Consider a contract that uses an external library to manage ownership but fails to account for how delegatecall preserves the calling contract’s context. An attacker can exploit this by directing the contract to execute a function, like takeOwnership(), in the context of the vulnerable contract, effectively changing its owner state variable instead of the library’s. This type of vulnerability emerges from misunderstanding how delegatecall applies the called contract’s logic to the caller’s storage.

Exploiting Misaligned Storage Variables

Another critical issue arises when the storage layout between the calling contract and the called contract (or library) does not match. Since delegatecall executes code in the context of the caller’s storage, any misalignment can lead to unintended state modifications. For example, if a library function intended to modify a specific state variable inadvertently changes a critical control variable like the contract’s owner, it could allow attackers to seize control.

Mitigation Strategies

  1. Stateless Libraries: To prevent vulnerabilities related to the delegatecall context, use libraries that do not maintain state. Functions should be purely functional where possible, avoiding modifications to storage variables.

  2. Careful Storage Layout Management: Ensure that contracts interacting through delegatecall have matching storage layouts. This alignment prevents accidental overwriting of critical state variables due to layout discrepancies.

  3. Explicit Control Checks: Implement checks that validate the integrity of critical operations, especially when changing ownership or sensitive state variables. Use modifiers or require statements to enforce these controls.

For Security Researchers

Security researchers looking to identify vulnerabilities related to delegatecall should:

  • Review Contract Architecture: Understand the contract’s architecture, especially how delegatecall is used within the ecosystem. This includes reviewing linked libraries and any contracts that might be called.

  • Analyze Storage Layouts: Compare the storage layouts of contracts interacting through delegatecall to identify potential mismatches that could lead to vulnerabilities.

  • Test for Unexpected Behaviors: Employ dynamic analysis techniques to test how contracts behave when interacting through delegatecall, focusing on critical operations like ownership transfer or fund movements.


The delegatecall function’s ability to preserve the caller’s context is a double-edged sword in Solidity, offering both advanced functionality and potential security risks. By understanding the vulnerabilities it introduces and employing rigorous auditing practices, security researchers can help ensure that smart contracts remain secure and resilient against attacks exploiting delegatecall-related weaknesses.