STE security record

Contracts interfacing with ERC20 tokens may implement a feature in the `depositWithPermit()` function where users provide signatures to approve `ERC20(poolInfo[pid].lpToken)` transfers, subsequently invoking the `permit` function to finalize the approval. However, the contract fails to address the possibility of transaction front-running, where an unauthorized party could preemptively execute the `permit` function before the intended transaction is processed. If malicious actors observe this process, they can preemptively execute the `permit` function with the user's signature and nonce. This unauthorized front-running as a griefing attack not only consumes the nonce, rendering the legitimate user's intended transaction invalid but also can lead to a targeted Denial of Service (DOS) for the affected function, as the user's approval process is effectively disrupted.

A reentrancy attack can occur when the contract creates a function that makes an external call to another untrusted contract before resolving any effects. If the attacker can control the untrusted contract, they can make a recursive call back to the original function, repeating interactions that would have otherwise not run after the external call resolved the effects. The `withdraw()` function in the `MasterChef` contract contains a potential reentrancy vulnerability. This function allows users to withdraw ETH (if the pool exists), and subsequently interacts with an external contract via `pool.stake2.onWithdrawn()`. The use of `_transferTokenOut()` for transferring tokens to a user-controlled address before calling `onWithdrawn()` presents a reentrancy risk. This setup could allow an attacker to reenter the `withdraw()` function (or other functions) before the first call finishes, potentially leading to incorrect accounting or other unintended effects. It is important to note that the `pool.stake2` contract is not in the scope of audit. ```solidity=90 // Withdraw LP tokens from MasterChef. function withdraw(uint256 pid, uint256 amount) external { if (amount == 0) revert WITHDRAW_AMOUNT_ZERO(); _updateReward(pid, msg.sender); UserInfo storage user = userInfo[pid][msg.sender]; if (user.amount < amount) revert WITHDRAW_AMOUNT_TOO_LARGE(); PoolInfo storage pool = poolInfo[pid]; unchecked { user.amount -= amount; } _transferTokenOut(pool.lpToken, amount); // call stake2 contract when withdraw if (address(pool.stake2) != address(0)) pool.stake2.onWithdrawn(msg.sender, amount); emit Withdraw(msg.sender, pid, amount, user.index); } ``` ```solidity=272 function _transferTokenOut(address token, uint256 amount) private { if (amount == 0) return; if (token == address(0)) { SafeTransferLib.safeTransferETH(msg.sender, amount); } else { SafeTransferLib.safeTransfer(ERC20(token), msg.sender, amount); } } ```