NetMind security record

Signed messages are not properly verified with the current chain ID, thus allowing attackers to perform replay attacks across chains. Hardcoded or cached chain ID values are also vulnerable since a hard fork may occur and change the chain ID in the future. ```solidity=379 abi.encodePacked( '\x19\x01', DOMAIN_SEPARATOR, keccak256(abi.encode(_data.userAddr, _data.amount, _data.expiration, _nonce)) ) ``` - Reading a state variable `DOMAIN_SEPARATOR`, which seems to use a cached chain ID value. - Encoding the cached chain ID value `DOMAIN_SEPARATOR`. ```solidity=317 bytes32 digest = getDigest(Data( addr, uints[0], uints[1]), _nonce); ``` - `getDigest(Data(addr,uints[0],uints[1]),_nonce)` returns the cached chain ID. ```solidity=368 bytes32 hash = keccak256(abi.encodePacked(prefix, _digest)); ``` - Encoding data using `abi.encodePacked()`. ```solidity=369 address signer = ecrecover(hash, _sig.v, _sig.r, _sig.s); ``` - Calling `ecrecover` with a hash that does not properly include the chain ID. --- ```solidity=429 abi.encodePacked( '\x19\x01', DOMAIN_SEPARATOR, keccak256(abi.encode(_data.userAddr, _data.contractAddr, _data.amount, _data.expiration, _data.chain, _data.txid)) ) ``` - Reading a state variable `DOMAIN_SEPARATOR`, which seems to use a cached chain ID value. - Encoding the cached chain ID value `DOMAIN_SEPARATOR`. ```solidity=340 bytes32 digest = getDigest(Data( addrs[0], addrs[1], uints[0], uints[1], strs[0], strs[1])); ``` - `getDigest(Data(addrs[0],addrs[1],uints[0],uints[1],strs[0],strs[1]))` returns the cached chain ID. ```solidity=404 bytes32 hash = keccak256(abi.encodePacked(prefix, _digest)); ``` - Encoding data using `abi.encodePacked()`. ```solidity=405 address _nodeAddr = ecrecover(hash, _sig.v, _sig.r, _sig.s); ``` - Calling `ecrecover` with a hash that does not properly include the chain ID. --- ```solidity=224 abi.encodePacked( '\x19\x01', DOMAIN_SEPARATOR, keccak256(abi.encode(paymentId, amt, expir))) ``` - Reading a state variable `DOMAIN_SEPARATOR`, which seems to use a cached chain ID value. - Encoding the cached chain ID value `DOMAIN_SEPARATOR`. ```solidity=173 bytes32 digest = getDigest(paymentId, amt, expir); ``` - `getDigest(paymentId,amt,expir)` returns the cached chain ID. ```solidity=216 bytes32 hash = keccak256(abi.encodePacked(prefix, _digest)); ``` - Encoding data using `abi.encodePacked()`. ```solidity=217 address signer = ecrecover(hash, _sig.v, _sig.r, _sig.s); ``` - Calling `ecrecover` with a hash that does not properly include the chain ID. --- ```solidity=224 abi.encodePacked( '\x19\x01', DOMAIN_SEPARATOR, keccak256(abi.encode(paymentId, amt, expir))) ``` - Reading a state variable `DOMAIN_SEPARATOR`, which seems to use a cached chain ID value. - Encoding the cached chain ID value `DOMAIN_SEPARATOR`. ```solidity=194 bytes32 digest = getDigest(paymentId, amt, expir); ``` - `getDigest(paymentId,amt,expir)` returns the cached chain ID. ```solidity=195 bytes32 hash = keccak256(abi.encodePacked(prefix, digest)); ``` - Encoding data using `abi.encodePacked()`. ```solidity=198 address signAddr = ecrecover(hash, vs[i], rs[i*2], rs[i*2+1]); ``` - Calling `ecrecover` with a hash that does not properly include the chain ID. --- ```solidity=296 abi.encodePacked( '\x19\x01', DOMAIN_SEPARATOR, keccak256(abi.encode(_data.userAddr, _data.contractAddr, _data.amount, _data.expiration, _nonce)) ) ``` - Reading a state variable `DOMAIN_SEPARATOR`, which seems to use a cached chain ID value. - Encoding the cached chain ID value `DOMAIN_SEPARATOR`. ```solidity=237 bytes32 digest = getDigest(Data( addrs[0], addrs[1], uints[0], uints[1]), _nonce); ``` - `getDigest(Data(addrs[0],addrs[1],uints[0],uints[1]),_nonce)` returns the cached chain ID. ```solidity=271 bytes32 hash = keccak256(abi.encodePacked(prefix, _digest)); ``` - Encoding data using `abi.encodePacked()`. ```solidity=272 address _accessAccount = ecrecover(hash, _sig.v, _sig.r, _sig.s); ``` - Calling `ecrecover` with a hash that does not properly include the chain ID. --- ```solidity=223 abi.encodePacked( '\x19\x01', DOMAIN_SEPARATOR, keccak256(abi.encode(nonce, amt, expir))) ``` - Reading a state variable `DOMAIN_SEPARATOR`, which seems to use a cached chain ID value. - Encoding the cached chain ID value `DOMAIN_SEPARATOR`. ```solidity=169 bytes32 digest = getDigest(nonce, amt, expir); ``` - `getDigest(nonce,amt,expir)` returns the cached chain ID. ```solidity=215 bytes32 has

In the `claimReward()` function, designed for users to claim rewards, a logic flaw is present at line 173. It imposes a condition `block.timestamp > lf.lockTime + rewardDelay`, indicating that rewards can only be claimed after a specific time. ```solidity=168 function claimReward(uint256 id) public notContract{ LockInfo storage lf = lockInfo[id]; require(lf.locked > 0, "lockId unexsit"); require(lf.owner == msg.sender, "only owner can call"); require(lf.rewardsEarned == 0, "already claim"); require(block.timestamp > lf.lockTime + rewardDelay, "unarrived claim time"); //claim reward uint256 reward = lf.locked * rewardPropotion / 1000; require(address(this).balance - reward >= totalLocked, "reward used up"); lf.rewardsEarned = reward; payable(msg.sender).transfer(reward); emit ClaimReward(id, msg.sender, reward); } ``` However, the `checkReward()` function, which assesses the available rewards, considers the condition `block.timestamp = lf.lockTime + rewardDelay` as eligible for rewards. This inconsistency causes transactions invoking `claimReward()` to revert even when users should be entitled to rewards. ```solidity=160 function checkReward(uint256 id) public view returns(uint256){ LockInfo memory lf = lockInfo[id]; if (block.timestamp < lf.lockTime + rewardDelay || lf.rewardsEarned > 0){ return 0; } return lf.locked * rewardPropotion / 1000; } ```

According to the document, there are only three states of `Job`, ```bat 1: running， 2: finish，3: abort， ``` ```solidity=189 require(_jobMsg.state == 1 || _jobMsg.state == 4, "task status error"); ```

The `Conf` contract initializer is the default account with the authority to update state variables. This initializer can delegate such rights to other accounts. However, a current flaw in the code allows newly authorized accounts to delegate the ability to update state variables to other new accounts. ```solidity=17 mapping (address => uint) public wards; function rely(address guy) external auth { wards[guy] = 1; } function deny(address guy) external auth { wards[guy] = 0; } modifier auth { require(wards[msg.sender] == 1); _; } ``` ```solidity=62 function files(string[] calldata whats, address[] calldata dstas) external auth { .... ```

In the `stake()` function for the user to deposit assets into the contract, the existence of `nodeAddr` is verified on line 267, which means that `_nodeAddrIndex` will hold a non-zero value.

The `ecrecover()` function is subject to signature malleability. The signature malleability is possible within the Elliptic Curve cryptographic system. An Elliptic Curve is symmetric on the `X`-axis, meaning two points can exist with the same `X` value. In the `r`, `s` and `v` representation this permits us to carefully adjust `s` to produce a second valid signature for the same `r`, thus breaking the assumption that a signature cannot be replayed in what is known as a replay-attack. ```solidity=320 (bool result, address signAddr) = verifySign( digest, Sig(vs[i], rssMetadata[i*2], rssMetadata[i*2+1]) ); ``` - `verifySign` called. ```solidity=369 address _nodeAddr = ecrecover(hash, _sig.v, _sig.r, _sig.s); ``` - `ecrecover` called without proper checks. --- ```solidity=343 (bool result, address signAddr) = verifySign( digest, Sig(vs[i], rssMetadata[i*2], rssMetadata[i*2+1]) ); ``` - `verifySign` called. ```solidity=405 address _nodeAddr = ecrecover(hash, _sig.v, _sig.r, _sig.s); ``` - `ecrecover` called without proper checks. --- ```solidity=176 (bool result, address signAddr) = verifySign(digest, Sig(vs[i], rs[i*2], rs[i*2+1])); ``` - `verifySign` called. ```solidity=217 address signer = ecrecover(hash, _sig.v, _sig.r, _sig.s); ``` - `ecrecover` called without proper checks. --- ```solidity=198 address signAddr = ecrecover(hash, vs[i], rs[i*2], rs[i*2+1]); ``` - `ecrecover` called without proper checks. --- ```solidity=197 address signAddr = ecrecover(hash, vs[i], rs[i*2], rs[i*2+1]); ``` - `ecrecover` called without proper checks.

The function `vote()` is designed to vote for specific proposals identified by `_proposalId`. The function does not verify that the proposal has been executed, which means that it does not check whether the associated `_proposalMsg.proposalSta` variable is `true`.

The `SafeMath` library is used unnecessarily. With Solidity compiler versions 0.8.0 or newer, arithmetic operations will automatically revert in case of integer overflow or underflow. ```solidity=140 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `AccountManage` contract. ```solidity=256 _userAccountMsg.balance = _userAccountMsg.balance.add(msg.value); ``` - `SafeMath.add` is called in `tokenCharge` function of `AccountManage` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 14) are shown above.* --- ```solidity=22 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `Management` contract. ```solidity=116 _proposalMsg.expire = _time.add(86400*3); ``` - `SafeMath.add` is called in `_propose` function of `Management` contract. --- ```solidity=112 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `TrainingTask` contract. ```solidity=193 _jobMsg.freezeAmount = _jobMsg.freezeAmount.add(freezeAmount); ``` - `SafeMath.add` is called in `updateJob` function of `TrainingTask` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 6) are shown above.* --- ```solidity=103 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `ERC20` contract. --- ```solidity=103 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `ERC20` contract. ```solidity=136 allowances[owner][msg.sender] = allowances[owner][msg.sender].sub(amount); ``` - `SafeMath.sub` is called in `transferFrom` function of `ERC20` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 8) are shown above.* --- ```solidity=193 library SafeMath { ``` - An implementation of `SafeMath` library is found.

One or more logic contracts do not protect their initializers. An attacker can call the initializer and assume ownership of the logic contract, whereby she can perform privileged operations that trick unsuspecting users into believing that she is the owner of the upgradeable contract. ```solidity=139 contract AccountManage is Ownable{ ``` - `AccountManage` is an upgradeable contract that does not protect its initializer. ```solidity=193 function init(address _conf) external ``` - `init` is an unprotected initializer function. --- ```solidity=109 contract CommunityFund is ICommunityFund,Ownable{ ``` - `CommunityFund` is an upgradeable contract that does not protect its initializer. ```solidity=156 function init(address[] calldata _nodeAddrs) external initializer{ ``` - `init` is an unprotected initializer function. --- ```solidity=109 contract Crosschain is Initializable,Ownable { ``` - `Crosschain` is an upgradeable contract that does not protect its initializer. ```solidity=167 function init( ``` - `init` is an unprotected initializer function. --- ```solidity=107 contract Payment is Initializable, Ownable { ``` - `Payment` is an upgradeable contract that does not protect its initializer. ```solidity=129 function init(address _conf, uint256 _signum) public initializer{ ``` - `init` is an unprotected initializer function. --- ```solidity=113 contract Pledge is Initializable,Ownable,IPledge{ ``` - `Pledge` is an upgradeable contract that does not protect its initializer. ```solidity=154 function init() external initializer{ ``` - `init` is an unprotected initializer function. --- ```solidity=105 contract PriceService is Ownable{ ``` - `PriceService` is an upgradeable contract that does not protect its initializer. ```solidity=116 function init( ``` - `init` is an unprotected initializer function. --- ```solidity=118 contract RewardContract is Initializable,Ownable,IRewardContract { ``` - `RewardContract` is an upgradeable contract that does not protect its initializer. ```solidity=172 function init(address _conf) external initializer{ ``` - `init` is an unprotected initializer function. --- ```solidity=107 contract RewardPool is Initializable, Ownable { ``` - `RewardPool` is an upgradeable contract that does not protect its initializer. ```solidity=139 function init(address _conf, address _reward, uint256 _dailymaxmove, uint256 _signum, uint256 _moveable) public initializer{ ``` - `init` is an unprotected initializer function. --- ```solidity=109 contract TechnologyFund is ITechnologyFund,Ownable{ ``` - `TechnologyFund` is an upgradeable contract that does not protect its initializer. ```solidity=155 function init(address[] calldata _nodeAddrs) external initializer{ ``` - `init` is an unprotected initializer function. --- ```solidity=111 contract TrainingTask is Ownable{ ``` - `TrainingTask` is an upgradeable contract that does not protect its initializer. ```solidity=147 function init( ``` - `init` is an unprotected initializer function. --- ```solidity=162 contract WrapToken is Initializable,Ownable,ERC20{ ``` - `WrapToken` is an upgradeable contract that does not protect its initializer. ```solidity=165 function init( address _minter) external initializer{ ``` - `init` is an unprotected initializer function.

The smart contract contains one or more values that are not used, which can lead to unnecessary complexity and reduced maintainability. --- ```solidity=277 uint256 _nodeNum = nodeNum; ``` - The variable `_nodeNum` is never used after this assignment. --- ```solidity=281 _nodeNum = _nodeAddrIndex; ``` - The variable `_nodeNum` is never used after this assignment.