BitsLab AI is BitsLab's AI-powered smart contract security scanner.

How a Uniswap v4 Delta Settlement Flaw Led to a Loss of Funds？

🚨 Security Alert | Ledger Users Report Suspected Wallet Theft Exceeding $86M 💸 On October 9, multiple Ledger hardware wallet users in Southeast Asia reported unauthorized asset transfers involving devices purchased through CryptoBilis, a Ledger reseller. Public on-chain investigations estimate that more than $86 million may have been stolen across multiple networks, including Bitcoin, Ethereum, and TRON. Ledger has confirmed an ongoing investigation and requested that CryptoBilis suspend sales and shipments of Ledger devices. The exact number of affected users and total losses have yet to be officially confirmed. 🔍 Key Security Findings On-chain analysis identified coordinated asset transfers across multiple blockchains. Several TRON wallets submitted token approvals almost simultaneously, followed by rapid withdrawals. This pattern suggests that the attacker may have gained signing control over multiple wallets. The initial compromise remains unclear. Potential attack vectors include device tampering during distribution or delivery, and compromised recovery phrases. However, there is currently no confirmed evidence of an exploitable vulnerability in Ledger's firmware or hardware security mechanisms. ⚠️ Security Recommendations Ledger advises users who purchased devices through CryptoBilis within the past 90 days to take precautions: Unused devices: Do not initialize or use them until further notice. Initialized devices: Consider generating a new recovery phrase on a trusted device and transferring assets to a new wallet as soon as possible. Recovery phrase security: Never restore the original recovery phrase on the new device or share it with anyone. ✍️ BitsLab Security Reminder: Hardware wallet security depends on the entire lifecycle, from private key generation and device distribution to everyday use. If a recovery phrase may have been compromised, replacing the hardware wallet or reinstalling the wallet application will not eliminate the risk. Assets should be transferred to a wallet secured by a newly generated recovery phrase. The investigation is ongoing. The exact attack vector and total losses remain unconfirmed. #SecurityAlert #Web3Security #Ledger

🚨【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…

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. 👇

In BitsLab’s security analysis of cross-VM systems, precompiles, and native modules, this type of state mismatch is a key area of focus.

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?

🚨 BitsLab Research: One forged email is enough to hijack a nanobot agent. No clicks. No user interaction. No prior access. We disclosed CVE-2026-33654 — a zero-click Indirect Prompt Injection chained with Authentication Bypass in the Email Channel. Here's how it works 🧵👇

🚨 INCIDENT REPORT — Verus-Ethereum Bridge $11.58M drained in a single transaction. ETH 1,625.37 · tBTC 103.57 · USDC 147,658 Not a signature bug. Not a reentrancy. It was a data-structure ambiguity that let the attacker walk through proof verification untouched. BitsLab breakdown 👇

Balancer V2 deployed ONE contract to hold every token across every pool. Looks like a single point of failure. It's actually why cross-pool arbitrage moves zero tokens, and why a flash loan can tap the entire protocol's liquidity. A thread on the Vault 🧵👇