@MoveBit_i
iAccount based inHong Kong!
About this account
- Account based in
- Hong Kong
- Connected via
- United States App Store
! X says this location may be affected by a proxy or VPN.
Account-level information from X, not a live location or the device used for a specific post.
Sub-brand of @0xbitslab. A security team focused on the Move ecosystem, building the standard and delivering security audits for the Move ecosystem.
Audits ✉️ [email protected]
Joined August 2022
- Tweets764
- Following342
- Followers17.8K
- Likes888
MoveBit retweeted
🚨【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…
For long-term self-custody, hardware wallets remain the safer option 🧐
🚨【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. ✊
MoveBit retweeted
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
MoveBit retweeted
💸 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
MoveBit retweeted
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. 👇
MoveBit retweeted
In BitsLab’s security analysis of cross-VM systems, precompiles, and native modules, this type of state mismatch is a key area of focus.
MoveBit retweeted
How the $8.5M Term Finance Exploit Exposed a Governance Security Gap
MoveBit retweeted
The $sUSN contract on Sui was audited by @MoveBit_ with no vulnerabilities found.
The bridge code is a clone of @LayerZero's Sui endpoint, which LayerZero has had audited three times, including a Code4rena contest.
🚨 Security Alert | Harmony Hit by Massive Unauthorized Mint
📡Harmony is investigating a major security incident after roughly 4 billion unauthorized ONE tokens were reportedly created — equivalent to around 26% of its previous circulating supply.
On-chain researchers say the exploit may be related to empty blocks, while Harmony’s totalSupply data reportedly failed to immediately reflect the newly created tokens.
💸Around 2.8 billion ONE were reportedly sent to exchanges shortly after the incident.
✅Harmony has since:
• Released an emergency validator patch
• Paused the Harmony Bridge
• Contacted exchanges to freeze related funds
• Begun evaluating a possible blockchain rollback
The full root cause has not yet been disclosed.
💡The key security question is now whether a flaw in protocol-level validation allowed an invalid state transition to be accepted by the network.
🔘For any Layer 1, token supply is a fundamental protocol invariant. If that invariant can be bypassed, the issue goes far beyond a vulnerable smart contract.
MoveBit will continue monitoring the technical disclosure.
#BlockchainSecurity #Harmony #Web3Security
⚠️Your private key doesn’t need to be stolen if an attacker can recreate it.
🛡️Security Breakdown | COLDCARD
【Your private key doesn’t need to be stolen if an attacker can recreate it.】
The deeper issue behind the COLDCARD incident is not phishing or physical compromise — but weak entropy at seed generation.
💡The critical path looked deceptively safe:
seed = ngu.random.bytes(32)
But underneath, the firmware contained:
#define MICROPY_HW_ENABLE_RNG (0)
An RNG integration error allowed rng_get() to fall back to MicroPython’s software PRNG instead of the intended hardware RNG.
Its state could then be constrained from values such as:
🔰MCU UID + SysTick + RTC
Turning seed recovery into an offline search:
Constrain RNG ➡️ generate candidate seeds ➡️ derive addresses ➡️ match on-chain address ➡️ recover key
The key wasn’t necessarily stolen.
⏰It may have been predictable from birth.
That’s why air-gapping alone cannot solve this class of failure: it protects a secret from exfiltration, not from reconstruction.
And firmware updates cannot repair seeds generated with weak entropy. Those seeds must be replaced.
☑️Security takeaway:
Key security doesn’t begin with storage. It begins with entropy.