Cyber security record

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. ### External call(s) ```solidity=265 IERC20(asset).approve(bridgeAddress, amount); ``` ### State variables written after the call(s) ```solidity=262 balance[asset][assetOwner] -= amount; ``` ```solidity=263 totalBalance[asset] -= amount; ```

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. ### External call(s) ```solidity=119 IERC20(asset).safeTransfer(msg.sender, amount); ``` * This function call executes the following external call(s). * In `SafeERC20._callOptionalReturn`, * `returndata = address(token).functionCall(data,"SafeERC20: low-level call failed")` * In `Address.functionCallWithValue`, * `(success,returndata) = target.call{value: value}(data)` ### State variables written after the call(s) ```solidity=115 balance[asset][msg.sender] -= amount; ``` ```solidity=116 totalBalance[asset] -= amount; ```

The function `_requiresExpectedSigner()` is used to check if `expectedSigner` is the correct signer, which will be called by the function `preProcess()` from the contract `PermissionMw`. ```solidity function _requiresExpectedSigner( bytes32 digest, address expectedSigner, uint8 v, bytes32 r, bytes32 s, uint256 deadline ) internal view { require(deadline >= block.timestamp, "DEADLINE_EXCEEDED"); require( uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "INVALID_SIGNATURE_S_VAULE" ); address recoveredAddress = ecrecover(digest, v, r, s); require(recoveredAddress == expectedSigner, "INVALID_SIGNATURE"); } ``` If `ecrecover()` fails to recover an address, a zero address will be returned, which is not checked in `_requiresExpectedSigner()`. If the role `NameRegistry` assign a zero address to the signer through the function `setMwData()`, an invalid signature could bypass the permission check of the function `preProcess()` in the middleware `PermissionMw`. ```solidity //file src/middlewares/mocaid/PermissionMw.sol function setMwData(bytes calldata data) external override onlyNameRegistry { signer = abi.decode(data, (address)); } function preProcess( DataTypes.RegisterNameParams calldata params, bytes calldata data ) external payable override onlyNameRegistry { DataTypes.EIP712Signature memory sig; (sig.v, sig.r, sig.s, sig.deadline) = abi.decode( data, (uint8, bytes32, bytes32, uint256) ); _requiresExpectedSigner( _hashTypedDataV4( keccak256( abi.encode( Constants._REGISTER_TYPEHASH, keccak256(bytes(params.name)), params.parentNode, params.to, nonces[params.to]++, sig.deadline ) ) ), signer, sig.v, sig.r, sig.s, sig.deadline ); } ``` References: - https://docs.soliditylang.org/en/v0.8.9/units-and-global-variables.html?highlight=ecrecover#mathematical-and-cryptographic-functions

In the contract `StableFeeMiddleware`, the function `usdOracle.getRoundData()` returns the token's Oracle price. According to the documentation, it must validate the returned **timestamps**, **round ID**, and **price** to ensure the price is valid. ```solidity function _getPriceAt(uint80 roundId) internal view returns (int256) { // prettier-ignore ( /* uint80 roundID */, int price, /*uint startedAt*/, /*uint timeStamp*/, /*uint80 answeredInRound*/ ) = usdOracle.getRoundData(roundId); return price; } ``` Moreover, The function **_getPrice()** is using `latestRoundData()` to get the token's price by Chainlink, but there are no validations that the data is not stale. Reference: - https://docs.chain.link/data-feeds/historical-data#getrounddata-return-values

The value for moca xp can be updated via `setMocaXP` with a limitation of `_MAX_XP` by the operator. ```solidity=374 function setMocaXP(uint256 tokenId, uint256 xp) external { require(xp <= _MAX_XP, "XP_TOO_BIG"); DataTypes.MetadataPair[] memory pairs = new DataTypes.MetadataPair[](1); pairs[0] = DataTypes.MetadataPair(_MOCA_XP_KEY, xp.toString()); batchSetGatedMetadatas(tokenId, pairs); emit MocaXPSet(tokenId, xp); } ``` However, since `batchSetGatedMetadatas` is external function, the operator can invoke `batchSetGatedMetadatas` directly to bypass the validation on moca xp value.

When register cyber ID, there is a pre-register process when the middleware of the contract is not address(0) ```solidity=177 function register( string calldata cid, address to, bytes32 secret, uint8 durationYear, bytes calldata middlewareData ) external payable { ... uint256 cost; if (middleware != address(0)) { cost = ICyberIdMiddleware(middleware).preRegister{ value: msg.value }( DataTypes.RegisterCyberIdParams( msg.sender, cid, to, durationYear ), middlewareData ); } _register(cid, to, durationYear, cost); } ``` During the preregister process in stable fee middleware, it will query the fee and calculate the cost: ```solidity=83 function preRegister( DataTypes.RegisterCyberIdParams calldata params, bytes calldata data ) external payable override returns (uint256) { uint80 roundId = abi.decode(data, (uint80)); uint256 cost = getPriceWeiAt(params.cid, roundId, params.durationYear); _chargeAndRefundOverPayment(cost, params.msgSender); return cost; } ``` However, the `roundID` is based on the `middlewareData`, which is user's input. As a result, the user has the chance to select the price for the registration.

Addresses are not validated before assignment or external calls, potentially allowing the use of zero addresses and leading to unexpected behavior or vulnerabilities. For example, transferring tokens to a zero address can result in a permanent loss of those tokens. ```solidity=61 weth = _weth; ``` - `_weth` is not zero-checked before being used.

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. *This finding is considered minor because the reentrancy only causes out-of-order events. * ### External call(s) ```solidity=75 IERC20(asset).safeTransferFrom(msg.sender, address(this), amount); ``` * This function call executes the following external call(s). * In `SafeERC20._callOptionalReturn`, * `returndata = address(token).functionCall(data,"SafeERC20: low-level call failed")` * In `Address.functionCallWithValue`, * `(success,returndata) = target.call{value: value}(data)` ### Events emitted after the call(s) ```solidity=82 emit Deposit(_logId++, msg.sender, asset, actualAmount); ``` --- ### External call(s) ```solidity=95 IWETH(weth).deposit{ value: msg.value }(); ``` ### Events emitted after the call(s) ```solidity=97 emit Deposit(_logId++, msg.sender, weth, msg.value); ``` --- ### External call(s) ```solidity=119 IERC20(asset).safeTransfer(msg.sender, amount); ``` * This function call executes the following external call(s). * In `SafeERC20._callOptionalReturn`, * `returndata = address(token).functionCall(data,"SafeERC20: low-level call failed")` * In `Address.functionCallWithValue`, * `(success,returndata) = target.call{value: value}(data)` ### Events emitted after the call(s) ```solidity=127 emit Withdraw(_logId++, msg.sender, assets, amounts); ``` --- ### External call(s) ```solidity=265 IERC20(asset).approve(bridgeAddress, amount); ``` ```solidity=269 IBridge(bridgeAddress).bridge(assetOwner, recipient, assets, amounts); ``` ### Events emitted after the call(s) ```solidity=279 emit Bridge( _logId++, bridgeAddress, assetOwner, recipient, assets, amounts ); ```

The smart contract does not check or store the return value of an external call in a local or state variable, which may introduce vulnerabilities due to the unhandled outcome. ```solidity=265 IERC20(asset).approve(bridgeAddress, amount); ```

The following function are missing access control in `StableFeeMiddleware`: - `preRegister` - `preRenew` - `preBid`