KonnektVPN security record

200000000000000000000000000 of the `KPN` tokens are sent to the contract deployer when deploying the contract. This could be a centralization risk as the anonymous deployer can distribute tokens without obtaining the consensus of the community. Any compromise to the deployer account that holds undistributed tokens may allow the attacker to steal and sell tokens on the market, resulting in severe damage to the project.

According to L32-L60, the decimals of the rewards are 18. The rewards are paid using USDT. But the decimal of the USDT is 6. The inconsistency may lead to the project's loss. ```solidity=32 uint256 public tier1mon6 = 750 * (10**18); uint256 public tier1mon12 = 1800 * (10**18); uint256 public tier1mon24 = 4500 * (10**18); // TIER 2 uint256 public tier2mon6 = 1500 * (10**18); uint256 public tier2mon12 = 3500 * (10**18); uint256 public tier2mon24 = 8000 * (10**18); // TIER 3 uint256 public tier3mon6 = 4200 * (10**18); uint256 public tier3mon12 = 9000 * (10**18); uint256 public tier3mon24 = 21000 * (10**18); // TIER 4 uint256 public tier4mon6 = 8000 * (10**18); uint256 public tier4mon12 = 17000 * (10**18); uint256 public tier4mon24 = 37000 * (10**18); // TIER 5 uint256 public tier5mon6 = 13500 * (10**18); uint256 public tier5mon12 = 28500 * (10**18); uint256 public tier5mon24 = 58500 * (10**18); // TIER 6 uint256 public tier6mon6 = 25000 * (10**18); uint256 public tier6mon12 = 50000 * (10**18); uint256 public tier6mon24 = 112500 * (10**18); ``` ```solidity=209 function _payUSDT(address _target, uint rewardAmount) internal { IERC20(USDT).transfer(_target, rewardAmount); emit RewardsPaid(_target, rewardAmount); } ```

The issue lies within the `claimTokens` function where the `KPNToken` is an `ERC777` token. ```solidity=49 function claimTokens() public{ require(owner == msg.sender, "Claiming ERC20: Only contract owner can call function"); require(whiteList.length > 0, "Claiming ERC20: No addresses on whitelist"); uint256 totalSendAmount = _calculateTotalClaim(); require(KPNToken.balanceOf(address(this)) >= totalSendAmount, "Claiming ERC20: Contract Balance Too Low"); for(uint i = 0; i < whiteList.length; i++){ uint256 sendAmount = whiteList[i].amount; address target = whiteList[i].target; whiteList[i].amount = 0; KPNToken.transfer(target, sendAmount); } emit BulkTokenClaim(totalSendAmount, block.timestamp); } ``` If the user is a malicious contract that either lacks a `tokensReceived()` function or explicitly rejects the saleTokens, this will lead to the entire transaction being reverted. This means that users will be unable to receive the claimed tokens - a situation known as a denial of service (DoS) attack.

If there isn't sufficient USDT available in the `LockTokens`, users are unable to directly reclaim their locked `KPN`. There are two ways of withdrawing `KPN` from the contract: `cancelStake` and `withdrawLocked`. The `cancelStake` is using to withdraw locked token before the `lock` expired. ```solidity=172 function cancelStake() public { require(block.timestamp < lockedBalances[msg.sender].lockTime + lockedBalances[msg.sender].timestamp, "ERC20: Cannot Cancel Completed Stake"); ``` The `withdrawLocked` function is utilized to retrieve locked tokens once the `lock` period has ended. However, should there be insufficient USDT available to cover the rewards, the transaction will fail, preventing users from withdrawing their tokens. Additionally, once the `lock` period is over, users are unable to withdraw their tokens by using the `cancelStake` function. Therefore, the sole option for users wanting to withdraw their tokens, in the event that the contract lacks sufficient USDT, is to place a new stake and then cancel this recent stake. ```solidity=189 function withdrawLocked() public { require(block.timestamp > lockedBalances[msg.sender].lockTime + lockedBalances[msg.sender].timestamp, "ERC20: Time Lock not complete"); require(lockedBalances[msg.sender].amount > 0, "ERC20: No Funds Locked"); uint256 tokenAmount = lockedBalances[msg.sender].amount; // gets local copy of variable to save on gas cost require(KPN.balanceOf(address(this)) >= tokenAmount, "ERC20: Contract Balance Too Low"); LockAmount memory lockStruct = lockedBalances[msg.sender]; totalLockedTokens -= tokenAmount; // deletes the staking struct delete lockedBalances[msg.sender]; // approves and transfers kpn balance from this contract KPN.approve(address(this), tokenAmount); KPN.transferFrom(address(this), msg.sender, tokenAmount); _payUSDT(msg.sender, lockStruct.rewardAmount); emit TokensWithdrawn(msg.sender, block.timestamp); } ```

When transferring deflationary ERC20 tokens, the input amount may not be equal to the received amount due to the charged transaction fee. For example, if a user sends 100 deflationary tokens (with a 10% transaction fee), only 90 tokens actually arrived to the contract. However, a failure to discount such fees may allow the same user to withdraw 100 tokens from the contract, which causes the contract to lose 10 tokens in such a transaction. Reference: https://thoreum-finance.medium.com/what-exploit-happened-today-for-gocerberus-and-garuda-also-for-lokum-ybear-piggy-caramelswap-3943ee23a39f

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=83 USDT = rewardsToken; ``` - `rewardsToken` is not zero-checked before being used. --- ```solidity=271 USDT = _usdt; ``` - `_usdt` is not zero-checked before being used. --- ```solidity=17 KPNToken = IERC20(kpnToken); ``` - `KPNToken` is not zero-checked before being used.

Comparisons that are always true or always false may be incorrect or unnecessary. ```solidity=90 require(amount >= 0, "ERC20: Cannot send 0 tokens"); ```

In contract `LockTokens`, the reward token is the `USDT` token, but it is only initialized with an uncertain address and the actual implementation is unknown. In the function `withdrawLocked()` which the users use to retrieve the reward tokens, the `USDT` token is transferred to the retriever from the current contract. However, we do not find the code that mints or transfers the `USDT` token to the current contract.

State variables that never change should be declared as `constant` to save gas. ```solidity=15 uint256 public maxSupply = 8000000000000000000000000000; ``` - `maxSupply` should be declared `constant`. --- ```solidity=16 uint256 public tier1Cutoff = 750000 * (10**18); ``` - `tier1Cutoff` should be declared `constant`. --- ```solidity=17 uint256 public tier2Cutoff = 1250000 * (10**18); ``` - `tier2Cutoff` should be declared `constant`. --- ```solidity=18 uint256 public tier3Cutoff = 3000000 * (10**18); ``` - `tier3Cutoff` should be declared `constant`. --- ```solidity=19 uint256 public tier4Cutoff = 5000000 * (10**18); ``` - `tier4Cutoff` should be declared `constant`. --- ```solidity=20 uint256 public tier5Cutoff = 7500000 * (10**18); ``` - `tier5Cutoff` should be declared `constant`. --- ```solidity=21 uint256 public tier6Cutoff = 12500000 * (10**18); ``` - `tier6Cutoff` should be declared `constant`. --- ```solidity=24 uint256 public locktime1 = 180 days; ``` - `locktime1` should be declared `constant`. --- ```solidity=25 uint256 public locktime2 = 365 days; ``` - `locktime2` should be declared `constant`. --- ```solidity=26 uint256 public locktime3 = 730 days; ``` - `locktime3` should be declared `constant`.

In the `addToWhitelist()` function, if the `claimableTokens[newTarget]` is equal to 0, then `newTarget` will be added to the `whitelistedAddresses`. ```solidity=54 if (claimableTokens[newTarget] == 0) { whitelistedAddresses.push(newTarget); } ``` After a user claims their tokens via the `claimTokens()` function, the `claimableTokens[msg.sender]` will be reset to 0. ```solidity=63 claimableTokens[msg.sender] = 0; // Prevent Reentrancy ``` If the `addToWhitelist` function is invoked and the `newTarget` is the address of a user who has previously called `claimTokens`, then the address will be added to `whitelistedAddresses` once more. This could lead to duplicate entries in `whitelistedAddresses`.