Signature replay attacks — missing nonces, missing chain ID, ecrecover zero address, signature malleability, cross-chain replay.
75%
Does it follow best practices?
Run evals on this skill
Adds up to 20 points to the overall score
Medium
Suggest reviewing before use
Fix and improve this skill with Tessl
tessl review fix ./packages/decepticon/decepticon/skills/standard/contracts/signature-replay/SKILL.mdEIP-712 signatures, permits, meta-transactions, and cross-chain bridges
all use ecrecover (or its variants). Each has well-known bugs.
function execute(uint256 amount, bytes calldata sig) external {
bytes32 h = keccak256(abi.encodePacked(msg.sender, amount));
address signer = ecrecover(h, ...);
require(signer == owner);
// ... withdraw amount
}A valid signature can be replayed forever — anyone who saw it once can re-submit it. Fix: include a per-user / per-message nonce:
mapping(address => uint256) public nonces;
function execute(uint256 amount, uint256 nonce, bytes calldata sig) external {
require(nonce == nonces[msg.sender]);
nonces[msg.sender]++;
bytes32 h = keccak256(abi.encodePacked(msg.sender, amount, nonce));
// ...
}A signature valid on Ethereum mainnet shouldn't work on Optimism, Base,
Arbitrum, etc. If chainid() not in the signed payload, signatures
replay across chains:
// VULNERABLE
bytes32 h = keccak256(abi.encodePacked(amount, deadline, nonce));
// SAFE — EIP-712 domain separator includes chainid
bytes32 h = _hashTypedDataV4(...); // OZ helperThis is especially bad for bridges — a signed message intended for chain A executes on chain B.
ecrecover accepts two valid s values for any signed message
(s and -s mod n). This means each signature has two valid forms.
If your contract uses the signature itself as a uniqueness key
(e.g., usedSigs[sig] = true), an attacker can find the malleable
version and bypass:
// VULNERABLE — uses sig as uniqueness key
mapping(bytes => bool) public used;
function execute(bytes calldata sig) external {
require(!used[sig]);
used[sig] = true;
address signer = ecrecover(...);
// ...
}Fix: use the message hash (not the signature) as uniqueness key.
Modern OZ ECDSA library rejects high-s values, but home-rolled
ecrecover does not.
address signer = ecrecover(h, v, r, s);
if (signer == owner) { /* approve */ }Bug: if (v,r,s) is invalid, ecrecover returns address(0). If
owner is somehow address(0) (uninitialized!) → any malformed
signature works.
Fix: require(signer != address(0)).
EIP-712 domain separator should bind to the chain. If a protocol
caches DOMAIN_SEPARATOR in storage at deployment, hard-forks (which
change chainid) break it. OZ's EIP712 handles this; custom code often
doesn't.
// VULNERABLE — cached at deploy
bytes32 immutable DOMAIN_SEPARATOR = keccak256(abi.encode(
keccak256("EIP712Domain(...)"),
keccak256(bytes("Name")),
keccak256(bytes("1")),
1, // ← hardcoded chainid
address(this)
));
// SAFE — re-derive when chainid changes
function _domainSeparator() internal view returns (bytes32) {
return keccak256(abi.encode(..., block.chainid, ...));
}ERC2612 permit is meta-tx for ERC20 approvals. If permit doesn't
include the EIP-712 domain separator correctly, it can be replayed on:
This is mostly resolved by OZ ERC20Permit, but custom permit impls are often wrong.
A signed payload keccak256(amount, recipient) is the same regardless
of which function it authorizes. If two functions share the same
hash structure but different effects, the signature replays:
function withdraw(uint256 amt, address to, bytes sig) external {
bytes32 h = keccak256(abi.encodePacked(amt, to));
address s = ecrecover(h, ...);
require(s == owner);
payable(to).transfer(amt);
}
function mint(uint256 amt, address to, bytes sig) external {
bytes32 h = keccak256(abi.encodePacked(amt, to)); // SAME HASH
address s = ecrecover(h, ...);
require(s == owner);
_mint(to, amt);
}
// A withdraw signature works for mint, and vice versaFix: include function selector or unique typeID in the signed payload.
grep -rn 'ecrecover\|ECDSA.recover\|recover(' src/block.chainid (or use EIP-712 domain separator)address(this) (so signature is bound to THIS contract)address(0) return from ecrecovers malleable signaturesblock.chainid if cached# Custom ecrecover w/o OZ — often missing s-malleability check
grep -rn 'ecrecover' src/ | grep -v 'ECDSA.sol'
# Signature as uniqueness key
grep -rE 'mapping\(bytes' src/ | grep -i 'used\|nonce'
# Domain separator cached at deploy
grep -rn 'DOMAIN_SEPARATOR.*=.*keccak256' src/ | grep -v 'view\|pure'function test_cross_chain_replay() public {
// 1. Sign payload on chain A (chainid 1)
bytes32 hash = target.getSignableHash(amount, deadline);
bytes memory sig = sign(privKey, hash);
target.execute(amount, deadline, sig); // works on chain A
// 2. Switch to chain B (chainid 10)
vm.chainId(10);
// 3. Deploy same contract bytecode to chain B
Target targetB = new Target(...);
// 4. Same signature should be rejected if chainid is in the hash
vm.expectRevert("invalid sig");
targetB.execute(amount, deadline, sig);
// If it DOES NOT revert → cross-chain replay bug
}function test_malleability() public {
bytes32 hash = ...;
(uint8 v, bytes32 r, bytes32 s) = sign(privKey, hash);
target.execute(amount, abi.encodePacked(r, s, v));
// Compute the malleable counterpart
bytes32 sPrime = bytes32(uint256(SECP256K1_N) - uint256(s));
uint8 vPrime = v == 27 ? 28 : 27;
// If target doesn't reject high-s, this also works
target.execute(amount, abi.encodePacked(r, sPrime, vPrime));
}function test_replay() public {
target.execute(amount, sig); // first call succeeds
target.execute(amount, sig); // if no nonce check, succeeds again
// Attacker can drain by replaying N times
}CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H = 9.8import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract Safe is EIP712 {
using ECDSA for bytes32;
mapping(address => uint256) public nonces;
bytes32 constant TYPEHASH = keccak256(
"Execute(address user,uint256 amount,uint256 nonce,uint256 deadline)"
);
constructor() EIP712("MyApp", "1") {}
function execute(uint256 amount, uint256 deadline, bytes calldata sig) external {
require(block.timestamp <= deadline, "expired");
bytes32 structHash = keccak256(abi.encode(
TYPEHASH, msg.sender, amount, nonces[msg.sender]++, deadline
));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = hash.recover(sig);
require(signer == owner, "bad sig");
// OZ ECDSA already rejects address(0) and malleable s
}
}PurpleAILAB/Decepticon
98e51d3
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.