uups-checker 1.0.0

package/audits/PAALAI-security-audit-20260324.md

@@ -0,0 +1,475 @@
+# PAAL AI Token Security Audit Report
+
+**Contract**: PAALAI  
+**Token**: $PAAL  
+**Type**: ERC20 Token with Tax System  
+**Deployment Date**: July 18, 2023  
+**Audit Date**: March 24, 2026  
+**Auditor**: Kiro AI Security Analysis  
+
+---
+
+## Executive Summary
+
+**Risk Level**: 🔴 **CRITICAL**
+
+The PAAL AI token contract contains a **HIDDEN HONEYPOT MECHANISM** that can trap users with a 45% tax. The contract has:
+1. **CRITICAL**: Hidden 45% tax backdoor via initializer manipulation
+2. **HIGH**: Owner can change router and manipulate LP pairs
+3. **MEDIUM**: Complex initializer system with external dependencies
+4. **GOOD**: Has tax limits and some protections
+
+---
+
+## Contract Overview
+
+PAAL AI is an ERC20 token with:
+- Total Supply: 1,000,000,000 tokens (9 decimals)
+- Buy/Sell Tax: 4% (400/10000)
+- Transfer Tax: 0%
+- Tax Distribution: Marketing, Development, Staking, External Buyback
+- Max Tax Limits: 10% buy, 10% sell, 10% transfer
+
+**Key Features**:
+- Automated tax collection and distribution
+- Price impact-based swap amounts
+- Multiple LP pair support
+- External "Initializer" contract integration
+- Pre-liquidity transfer protection
+
+---
+
+## CRITICAL FINDINGS
+
+### 🔴 CRITICAL #1: HIDDEN 45% TAX BACKDOOR
+**Severity**: CRITICAL - HONEYPOT MECHANISM  
+**Function**: `takeTaxes()`
+
+```solidity
+function takeTaxes(address from, uint256 amount, bool buy, bool sell) internal returns (uint256) {
+    uint256 currentFee;
+    if (buy) {
+        currentFee = _taxRates.buyFee;  // Normally 4%
+    } else if (sell) {
+        currentFee = _taxRates.sellFee;  // Normally 4%
+    } else {
+        currentFee = _taxRates.transferFee;  // Normally 0%
+    }
+    
+    if (currentFee == 0) { return amount; }
+    
+    // ❌ HONEYPOT BACKDOOR
+    if (address(initializer) == address(this)
+        && (block.chainid == 1
+        || block.chainid == 56)) { 
+        currentFee = 4500;  // 45% TAX!
+    }
+    
+    uint256 feeAmount = amount * currentFee / masterTaxDivisor;
+    // ...
+}
+```
+
+**THE TRAP**:
+1. If `initializer` is set to `address(this)` (the token contract itself)
+2. AND chain is Ethereum (1) or BSC (56)
+3. Then ALL transactions get hit with **45% tax** instead of 4%
+
+**How It's Activated**:
+```solidity
+function _checkLiquidityAdd(address from, address to) internal {
+    // ...
+    if (address(initializer) == address(0)){
+        initializer = Initializer(address(this));  // ❌ SETS TO SELF
+    }
+    // ...
+}
+
+function enableTrading() public onlyOwner {
+    // ...
+    if (address(initializer) == address(0)){
+        initializer = Initializer(address(this));  // ❌ SETS TO SELF
+    }
+    // ...
+}
+```
+
+**Impact**:
+- Users think they're paying 4% tax
+- Actually paying 45% tax (11x higher!)
+- Owner can activate this at any time by not setting an initializer
+- Completely hidden from view functions
+- Bypasses all tax limits (maxBuyTaxes = 10%)
+
+**This is a TEXTBOOK HONEYPOT** - users can buy but lose 45% on every transaction.
+
+---
+
+### 🔴 CRITICAL #2: Owner Can Change Router After Launch
+**Severity**: CRITICAL  
+**Function**: `setNewRouter()`
+
+```solidity
+function setNewRouter(address newRouter) external onlyOwner {
+    require(!_hasLiqBeenAdded, "Cannot change after liquidity.");
+    // ...
+}
+```
+
+**Wait, this looks safe?** NO! Look at this:
+
+```solidity
+function setLpPair(address pair, bool enabled) external onlyOwner {
+    if (!enabled) {
+        lpPairs[pair] = false;
+        initializer.setLpPair(pair, false);
+    } else {
+        // Can add new pairs anytime
+        lpPairs[pair] = true;
+        // ...
+    }
+}
+```
+
+**The Attack**:
+1. Owner can add/remove LP pairs at will
+2. Owner can manipulate which pairs trigger buy/sell taxes
+3. Owner can create fake pairs to confuse users
+4. 3-day cooldown is bypassable by removing and re-adding
+
+**Impact**: Owner controls what counts as "buying" vs "selling" vs "transferring".
+
+---
+
+### 🔴 CRITICAL #3: Malicious Initializer Contract Risk
+**Severity**: CRITICAL  
+**Function**: `setInitializer()`
+
+```solidity
+function setInitializer(address init) public onlyOwner {
+    require(!tradingEnabled);
+    require(init != address(this), "Can't be self.");
+    initializer = Initializer(init);
+    try initializer.getConfig() returns (address router, address constructorLP) {
+        dexRouter = IRouter02(router); 
+        lpPair = constructorLP; 
+        lpPairs[lpPair] = true; 
+        _approve(_owner, address(dexRouter), type(uint256).max);
+        _approve(address(this), address(dexRouter), type(uint256).max);
+    } catch { revert(); }
+}
+```
+
+**The Risk**:
+- Owner can set ANY contract as initializer
+- Initializer can return ANY router address
+- Initializer can return ANY LP pair address
+- Contract gives unlimited approval to whatever router initializer returns
+- Malicious initializer could return a fake router that steals tokens
+
+**Attack Scenario**:
+1. Owner deploys malicious initializer
+2. Initializer returns address of malicious "router"
+3. Contract approves malicious router for unlimited tokens
+4. Malicious router drains all tokens from contract
+
+---
+
+### 🟡 HIGH #4: Owner Can Manipulate Taxes (Within Limits)
+**Severity**: HIGH  
+**Function**: `setTaxes()`
+
+```solidity
+function setTaxes(uint16 buyFee, uint16 sellFee, uint16 transferFee) external onlyOwner {
+    require(!taxesAreLocked, "Taxes are locked.");
+    require(buyFee <= maxBuyTaxes  // 10%
+        && sellFee <= maxSellTaxes  // 10%
+        && transferFee <= maxTransferTaxes,  // 10%
+        "Cannot exceed maximums.");
+    _taxRates.buyFee = buyFee;
+    _taxRates.sellFee = sellFee;
+    _taxRates.transferFee = transferFee;
+}
+```
+
+**Impact**:
+- Owner can change taxes from 4% to 10% at any time
+- Can set 10% transfer tax to block wallet-to-wallet transfers
+- Only protection: `lockTaxes()` makes it permanent
+- No timelock or delay
+
+**Mitigation**: At least there are hard caps (10%).
+
+---
+
+### 🟡 HIGH #5: Owner Can Change Tax Wallets Anytime
+**Severity**: HIGH  
+**Function**: `setWallets()`
+
+```solidity
+function setWallets(address payable marketing, address payable staking, address payable development, address payable externalBuyback) external onlyOwner {
+    require(marketing != address(0) && staking != address(0) && development != address(0) && externalBuyback != address(0), "Cannot be zero address.");
+    _taxWallets.marketing = payable(marketing);
+    _taxWallets.development = payable(development);
+    _taxWallets.staking = payable(staking);
+    _taxWallets.externalBuyback = payable(externalBuyback);
+}
+```
+
+**Impact**:
+- Owner can redirect all tax revenue to their own wallets
+- No timelock or multi-sig requirement
+- Can change at any time
+
+---
+
+### 🟡 MEDIUM #6: Dangerous multiSendTokens Function
+**Severity**: MEDIUM  
+**Function**: `multiSendTokens()`
+
+```solidity
+function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
+    require(accounts.length == amounts.length, "Lengths do not match.");
+    for (uint16 i = 0; i < accounts.length; i++) {
+        require(balanceOf(msg.sender) >= amounts[i]*10**_decimals, "Not enough tokens.");
+        finalizeTransfer(msg.sender, accounts[i], amounts[i]*10**_decimals, false, false, true);
+    }
+}
+```
+
+**Issues**:
+1. Uses `uint16` for loop counter - max 65,535 iterations
+2. No gas limit check - could run out of gas
+3. Checks balance on EVERY iteration (inefficient)
+4. Could be used to airdrop to many addresses and manipulate holder count
+
+**Not a security risk**, but poor implementation.
+
+---
+
+### 🟡 MEDIUM #7: Low Gas Limit on Tax Distributions
+**Severity**: MEDIUM  
+**Function**: `contractSwap()`
+
+```solidity
+if (ratios.marketing > 0) {
+    (success,) = _taxWallets.marketing.call{value: marketingBalance, gas: 55000}("");
+}
+```
+
+**Issue**:
+- Only 55,000 gas provided for each transfer
+- If tax wallet is a contract with expensive receive(), it will fail
+- Failed transfers are silently ignored (no revert)
+- ETH gets stuck in contract
+
+**Impact**: Tax distributions could fail, leaving ETH trapped in contract.
+
+---
+
+### 🟢 POSITIVE #8: Some Good Security Practices
+**Severity**: INFORMATIONAL
+
+**Good Implementations**:
+1. ✅ Has maximum tax limits (10%)
+2. ✅ Has `lockTaxes()` to make taxes immutable
+3. ✅ Renounce ownership requires trading to be enabled first
+4. ✅ Pre-liquidity transfer protection
+5. ✅ Reentrancy protection via `inSwapFlag`
+6. ✅ Excludes lock contracts from fees (PinkLock, Unicrypt)
+
+---
+
+### 🟢 INFORMATIONAL #9: Price Impact Swap Feature
+**Severity**: INFORMATIONAL
+
+```solidity
+function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
+    require(priceImpactSwapPercent <= 150, "Cannot set above 1.5%.");
+    piSwapPercent = priceImpactSwapPercent;
+}
+```
+
+**Feature**: Contract can swap based on % of LP instead of fixed amount.
+
+**Good**: Prevents excessive price impact from swaps.
+
+---
+
+## Exploitability Assessment
+
+### Can External Attackers Exploit This?
+
+**NO** - External attackers cannot exploit this contract because:
+- All critical functions are `onlyOwner`
+- No flash loan attack vectors
+- No reentrancy vulnerabilities
+- No price oracle manipulation
+
+### Can Owner Exploit This?
+
+**YES** - Owner has MULTIPLE exploit vectors:
+
+1. **45% Tax Trap**: Set initializer to self, activate 45% tax
+2. **Malicious Initializer**: Deploy fake initializer that returns malicious router
+3. **Tax Manipulation**: Change taxes up to 10% at will
+4. **Wallet Redirection**: Redirect all tax revenue to own wallets
+5. **LP Pair Manipulation**: Control what counts as buy/sell
+
+---
+
+## Hidden Honeypot Analysis
+
+**Is This Currently a Honeypot?**
+
+To determine if the 45% tax is active, check:
+```solidity
+address(initializer) == address(this)
+```
+
+If `initializer` equals the token contract address, then **YES, it's a honeypot**.
+
+**How to Check On-Chain**:
+1. Call `initializer` public variable
+2. If it returns the token contract address → HONEYPOT ACTIVE
+3. If it returns a different address → Check that initializer contract
+4. If it returns `0x0000...` → Not set yet, could be activated later
+
+---
+
+## Risk Summary
+
+| Risk Category | Level | Details |
+|--------------|-------|---------|
+| **Honeypot Risk** | 🔴 CRITICAL | Hidden 45% tax backdoor |
+| **Malicious Initializer** | 🔴 CRITICAL | Can set fake router to steal tokens |
+| **Router Manipulation** | 🔴 CRITICAL | Owner controls LP pairs and routing |
+| **Tax Manipulation** | 🟡 HIGH | Can change taxes up to 10% |
+| **Wallet Manipulation** | 🟡 HIGH | Can redirect tax revenue |
+| **External Exploit** | 🟢 LOW | Well-protected against external attacks |
+| **Code Quality** | 🟡 MEDIUM | Some good practices, but critical flaws |
+
+---
+
+## Comparison to Other Audited Contracts
+
+**vs. DSync Token** (previous audit):
+- ❌ Worse: Has hidden 45% tax backdoor
+- ❌ Worse: Malicious initializer risk
+- ✅ Better: Has tax limits (DSync had 60% sell tax)
+- ✅ Better: Has lockTaxes() function
+
+**vs. LendFlare (LFT)** (previous audit):
+- ❌ Similar: Both are honeypots
+- ❌ Worse: More complex trap mechanism
+- ✅ Better: At least has some tax limits
+
+---
+
+## Recommendations
+
+### For Users:
+
+1. **CHECK INITIALIZER**: Before buying, verify `initializer` address
+2. **AVOID IF SELF**: If initializer == token address, DO NOT BUY
+3. **VERIFY TAXES**: Test with small amount first
+4. **CHECK OWNERSHIP**: Verify owner hasn't renounced (they can still exploit)
+5. **ASSUME WORST**: Treat as high-risk until proven safe
+
+### For Owner/Team (If Legitimate):
+
+1. **REMOVE BACKDOOR**: Delete the 45% tax code entirely
+2. **USE REAL INITIALIZER**: Deploy proper initializer contract
+3. **LOCK TAXES**: Call `lockTaxes()` to make taxes immutable
+4. **MULTI-SIG**: Transfer ownership to multi-sig wallet
+5. **TIMELOCK**: Add timelock for critical functions
+6. **TRANSPARENCY**: Publish initializer contract source code
+7. **AUDIT INITIALIZER**: Get initializer contract audited
+
+### Critical Code Changes Needed:
+
+```solidity
+// REMOVE THIS ENTIRE BLOCK:
+if (address(initializer) == address(this)
+    && (block.chainid == 1
+    || block.chainid == 56)) { 
+    currentFee = 4500;
+}
+```
+
+---
+
+## Initializer Contract Analysis
+
+**What Should Initializer Do?**
+- Set launch parameters (block, timestamp)
+- Calculate initial swap thresholds
+- Manage LP pair registry
+- Provide anti-bot protection
+
+**What It SHOULDN'T Do**:
+- Return arbitrary router addresses
+- Have owner control after launch
+- Implement hidden tax mechanisms
+
+**Recommendation**: Initializer contract MUST be audited separately.
+
+---
+
+## On-Chain Verification Steps
+
+To verify if this is currently a honeypot:
+
+1. **Check Initializer Address**:
+   ```
+   Call: initializer()
+   If returns: <token_address> → HONEYPOT ACTIVE
+   ```
+
+2. **Check Current Taxes**:
+   ```
+   Call: _taxRates()
+   Returns: buyFee, sellFee, transferFee
+   ```
+
+3. **Test Small Transaction**:
+   - Buy $10 worth
+   - Check received amount
+   - If received < 96% of expected → HONEYPOT
+
+4. **Check Ownership**:
+   ```
+   Call: getOwner()
+   If returns: 0x0000... → Renounced (but backdoor may still be active)
+   ```
+
+---
+
+## Conclusion
+
+**VERDICT**: 🔴 **EXTREME DANGER - LIKELY HONEYPOT**
+
+This contract contains:
+- ❌ Hidden 45% tax backdoor that bypasses all limits
+- ❌ Malicious initializer attack vector
+- ❌ Owner can manipulate routing and LP pairs
+- ❌ No timelock or multi-sig protection
+- ✅ Some tax limits (but bypassable via backdoor)
+
+**For Users**: **DO NOT BUY** until you verify:
+1. Initializer is NOT set to token address
+2. Initializer contract is audited and safe
+3. Owner has locked taxes
+4. Test transaction confirms actual tax rate
+
+**For Owner**: If this is legitimate, remove the 45% tax backdoor immediately and implement proper security measures.
+
+**Exploitability**: Not exploitable by external attackers, but owner has god-mode control including a hidden 45% tax trap.
+
+**Current Status**: Cannot determine if honeypot is active without checking on-chain initializer address. **ASSUME DANGEROUS UNTIL PROVEN SAFE.**
+
+---
+
+**Audit Complete** ✓
+
+**CRITICAL WARNING**: This contract has a hidden mechanism that can charge 45% tax instead of the advertised 4%. Verify initializer address before any interaction.