🚨【Internet Token DAO Exploit Analysis】 On September 21, @internet_token on Base was exploited after an authentication flaw in its LiquidityUnifier contract allowed an attacker to supply a fake Uniswap V3 pool and forge a callback. 💸 The attacker ultimately bypassed the protocol’s supply validation and minted roughly 925M INT out of thin air. Part of the newly minted supply was then sold into the official INT/WETH pool, draining around 5.847 WETH, roughly $16K, while the attacker retained a large amount of INT. Subsequent copycat minting pushed the INT supply to approximately 156B. This is a textbook Smart Contract Security trust-boundary vulnerability. There was no obvious arithmetic bug in a single function. The real root cause emerged from the interaction between external contract authentication, callback trust, and cross-contract state transitions. 🔑 Key On-Chain Information Network: Base INT Token: 0x968D6A288d7B024D5012c0B25d67A889E4E3eC19 INT/WETH Pool: 0xdec6eadbd8ed3f655cba4bb4eeff6fb43b16969d Governor: 0xc5C3a1882Eff9539527D88E2453cAB10d9bc1581 Treasury / Timelock: 0xE05dD5B785f578337B2B8F695Fbc521669c69403 🛡️ Root Cause The issue sits between LiquidityUnifier.swapV3() and uniswapV3SwapCallback(). swapV3() lets the caller supply the pool address. The contract checks token0/token1, but does not verify that the pool was actually deployed by a trusted Uniswap V3 Factory. That means an attacker can deploy a fake pool, return the expected token0/token1, and pass it into swapV3(). The flow then becomes: Fake Pool → swapV3() → fake swap() → forged callback → INT mint So the protocol did not just trust the callback caller. It trusted a caller whose identity was chosen by the attacker. 🌍 Full Analysis：bitslab.xyz/blog/internet-to…

🚨【URGENT SECURITY ALERT】@FomoPeek Supply-Chain Malware and iOS Kernel Exploitation ✍️ While many users are now uninstalling FomoPeek, one important point is still being overlooked: This was not a typical Web3 phishing or malicious-signature attack. It involved a supply-chain trojan capable of exploiting the iOS kernel. 💡 If you installed FomoPeek v1.1 or v1.2 on your phone, your other hot wallets on the same device, including MetaMask, OKX Wallet, Trust Wallet and others, may also have been exposed. 🤔 This can be true even if you never imported a private key into FomoPeek itself. 1. Why didn’t the App Store catch it? Traditional app review mainly focuses on the code and behavior visible during the review process. FomoPeek presented itself as a read-only whale-tracking tool and claimed that users did not need to provide any private keys. The malicious exploit code was reportedly embedded into the app as obfuscated modules during the build process. Once launched, the app could identify the device model and iOS version, then select from eight built-in kernel exploit chains to match the target environment. 2. Attack chain: from memory corruption to Keychain access Based on reverse-engineering analysis, the attack flow looked like this: 1️⃣ Memory corruption WebKit / JavaScriptCore vulnerabilities were used to gain arbitrary memory read and write capabilities. 2️⃣ PAC bypass The exploit bypassed Apple’s Pointer Authentication Codes, allowing attackers to modify protected kernel data structures. 3️⃣ Sandbox escape and privilege escalation After gaining elevated privileges, the attacker could break out of the iOS application sandbox and access data outside FomoPeek’s own app container. 4️⃣ Keychain access The malware could access and decrypt data stored in the iOS Keychain, potentially exposing seed phrases, private keys and credentials belonging to other wallets on the same device. 🔦 It could also monitor clipboard data for additional sensitive information. 3. Is uninstalling FomoPeek enough? No. If the exploit had already succeeded, sensitive Keychain data may already have been extracted and sent to a remote command-and-control server. 🔌 Deleting the app stops the software from continuing to run on the device. It does not invalidate private keys that may already have been stolen. ⚒️ If a private key has been exposed, the attacker can still use it to move assets later. 4. Immediate actions recommended by @0xbitslab If you or someone you know installed the affected versions, take the following steps immediately: 🔹 Stop using the old wallet addresses Generate a completely new seed phrase and private key on a clean device that has never installed FomoPeek, or use a hardware wallet. 🔧 Move all assets to the new addresses as soon as possible. 🔹 Reset and update the affected device Update the device to an iOS version that includes the relevant security patches. A full device reset should also be considered before using it again for sensitive wallet operations. 🔹 Separate daily-use devices from asset-storage devices Mobile app sandboxes should not be treated as an absolute security boundary. 🧿 For users holding meaningful amounts of crypto, the device used for daily apps should be separated from the device used to manage funds. For long-term self-custody, hardware wallets remain the safer option. ✊

What makes the Cozy Finance incident noteworthy is not another familiar case of reentrancy, broken access control, or leaked private keys. It is a business-logic failure: the attacker did not bypass the payout flow. They followed it and turned a false external claim into a protocol state the system ultimately accepted as valid. 🖲️ According to @cozyfinance official disclosure, on September 2 the attacker purchased protection in three Cozy v2 markets covering Aave v2, Curve, and Rabbithole Quests. In the same transactions, they also submitted false YES answers to the UMA Optimistic Oracle requests those markets relied on. None of the proposals were disputed during the challenge window, so they eventually settled as valid YES outcomes and triggered the relevant markets. The attacker then claimed roughly 170,000 USDC.e. 💸 Viewed purely from the contract level, the flow looked legitimate: protection was purchased, proposals were submitted, no dispute was raised, the oracle settled, and Cozy released payouts. The real issue was that a covered event that had not actually occurred was converted into a valid state capable of releasing funds. 💡 This is why the incident should not simply be described as an “UMA Oracle exploit.” The deeper question is whether an undisputed oracle result should automatically be treated as a fully verified business fact. When oracle settlement directly controls fund release without enough contextual checks, a false input can propagate all the way to final settlement. ⏰ Another important detail is timing: the attacker submitted the YES proposals in the same transactions used to purchase protection. Buying protection and submitting a proposal may each be valid on their own, but the protocol must also verify whether they are still valid when combined in that sequence. 🔰 The broader lesson is clear: smart contract security is not only about validating individual functions. It also requires reasoning across state transitions, timing, oracle dependencies, and business invariants. Every call can be valid while the final protocol state is still wrong. 🛡️ At BitsLab, we increasingly focus on these cross-state and cross-module failure paths during security reviews, where individually valid operations can still combine into an exploitable protocol state. #Web3Security #DeFiSecurity #Defi

💸 The ~$320M abnormal peg-out from Liquid Network may not have been a key-compromise incident at all. On Sep. 6, nearly 4,000 BTC was withdrawn from the Liquid Federation wallet. But according to Liquid and SideSwap, the Peg-out Authorization Key (PAK) was not compromised, and no other signing keys were stolen. 🔋What makes this incident more interesting is that the withdrawal still went through the normal peg-out flow, with at least 11/15 functionaries ultimately signing the Bitcoin transaction. 🛡️This suggests the failure may not have been “the attacker stole a key and signed the withdrawal,” but rather that a state which should never have been considered valid was accepted as valid, after which downstream components completed authorization and signing under normal rules. 🖲️SideSwap currently says the issue appears to originate from a bug in Elements. The self-described white hats have since communicated with Blockstream via OP_RETURN messages and said they will return “most” of the BTC after the fix has been deployed across all nodes. Key Takeaway: if every signer is validating the same flawed state, even perfectly secure keys can still produce the wrong outcome. #Bitcoin #LiquidNetwork #Web3Security

1/4 🚨 A recent Reflexer GEB incident led to 5.94 ETH in collateral being drained due to an access-control and call-context confusion issue. 💸 The loss was relatively small, but the architectural flaw it exposed is highly relevant to DeFi systems built around shared proxy contracts. 👇

How the $8.5M Term Finance Exploit Exposed a Governance Security Gap

Why upgrade permissions can be more dangerous than smart contract vulnerabilities?

Participating in a meeting could have exposed the Zoom client to remote attack?