←
Solution17,669 posts
Solution avatar

Solution

@solution_o1

Christian| Founder @the41lab| Grey Hat| product engineer @joiniwa

◷ Joined June 2024▧ 1,076 Photos and videos
Solution avatar
Solution@solution_o1·Nov 14

Something has bothered me for a while, and I finally built the thing that fixes it. In security work, "we fixed it" is almost always an assertion. A bug gets found. A patch gets written. Someone reviews the diff, nods, and says it looks right. Maybe a re-audit happens. Then everyone moves on and the fix becomes a line in a report. But notice what usually does not happen: nobody takes the original exploit, runs it again against the patched code, and proves the specific thing it did no longer happens. We reason about fixes. We rarely re-run them. That gap has consequences. A patch can look correct and miss the actual path. A patch can close the hole and quietly break legitimate use at the same time. A patch can work for the wrong reason. All three happen, and a diff review catches none of them reliably, because reading code is not the same as executing it. So I built ExploitLens. You give it three things: a real exploit, the commit it worked against, and the commit meant to stop it. It replays the exploit against both commits under identical frozen inputs, using real Foundry execution, not a simulation of execution, the real thing. Then it aligns the two call trees semantically and finds the first causal divergence: the exact call where the two runs stop agreeing, which is where the prohibited effect stops being reachable. It also runs a third phase that I think matters more than people expect. It checks that legitimate use still works at the patched commit. A patch that stops the exploit by breaking the contract is not a fix, and if you only test the exploit you will never notice. The output is a Fix Receipt: a schema validated evidence bundle with a hash over its own contents. Rederive the hash offline and a single altered byte fails the check. You do not have to trust me, or the tool, or a dashboard. Here is the part I care about most. ExploitLens will not tell you a contract is secure. No replay can establish that. It cannot tell you no other vulnerability exists, because it never went looking. It will not give you a verdict without a reproduction, and when a gate fails, the failure stays in the committed bundle rather than getting smoothed into something more comfortable. What it will tell you is narrow and provable: this exploit, against this patch, under these inputs, no longer produces this effect and here is exactly where it stopped. I would rather ship a small true claim than a large vague one. The security industry has enough green badges. for now it'll carry two cases you can click through yourself. One is a controlled reentrancy fixture. The other is a real 2022 DeFi incident TempleDAO/STAX replayed and verified end to end. Code: github.com/solutiono1/exploi… Over the next couple of weeks I am taking it further: wiring it into @Telegraphprotoc so it can buy verified on chain facts about the real incident, instead of assuming its local reproduction matches what actually happened. A local proof is only as good as its connection to reality, and that connection has to be bought, not assumed. I will be posting the build as it happens including the parts that break. If you do security work, or you have opinions about what a fix should have to prove before anyone calls it fixed, I want to hear them.

Post attachment
Solution avatar
⟳ Solution retweeted
Solution@solution_o1·13h

i have question that has been bothering me here it goes "can a project built out of thin air scale with funds like if its been heavily backed or has raised funding, than a project built with real use case and everything but as a start up looking for funding and backing? also which of them will last long over time also maybe depending on marketing?" trying to see something.....

Solution avatar
⟳ Solution retweeted
Solution@solution_o1·12h

I keep thinking about how deeply I've transitioned from Solana and Sui to primarily building on EVMs. I haven't even built anything beyond 1 on either of those ecosystems. My love for Solana, especially in 2024/2025, was unmatched. But look at where I am now. 😂😂 Well, I'll be building something scalable on those chains soon.

Solution avatar
⟳ Solution retweeted
Solution@solution_o1·Nov 17

Quick look at what ExploitLens is turning into. The idea has not changed. You have an exploit, and a commit that is meant to stop it. ExploitLens replays the exploit against both commits under identical frozen inputs, checks that normal use still works afterwards, and writes an evidence bundle anyone can re-check offline without trusting me. What has changed is who can run it. For most of this build it could prove exactly two things: a reentrancy fixture and the TempleDAO/STAX incident from October 2022. Both prepared by me in advance. Good for a demo. Useless to you. So the last stretch has been about opening that up. Landing now: A CLI that runs on your machine against your repository. You point it at your project, it reads what it can from your repo, and it tells you plainly what it refuses to guess. Two things, always: what the exploit actually moves, and which rule it breaks. Those are judgement calls about the exploit itself, and a plausible wrong answer there does not throw an error, it gives you a confident meaningless verdict. So it marks them and makes you fill them in. Then it runs, and writes a bundle. You can drop that folder into the viewer and read it, or check it offline from the command line. Nothing is uploaded. The files are read in your browser. The whole claim here is that a receipt can be checked without trusting whoever made it, so asking you to hand me your evidence first would be self defeating. And an MCP server, which is the one I am most interested in. An agent that has just written a patch can call ExploitLens and ask for evidence that it holds, instead of telling you it does. Three tools: look at what a run would touch before touching it, run it, or check a receipt somebody else handed you. Worth saying why that matters now. OpenAI and Paradigm shipped EVMbench this year, measuring AI agents on detecting, patching and exploiting smart contract vulnerabilities. Patching comes back as the weakest of the three. Agents are writing security patches at scale already, and nothing independently checks an individual one. One design note, since it is the question people ask first. The hosted runner only ever executes a fixed list of reviewed cases, because a server that runs strangers' code is a remote code execution service with extra steps. The CLI is different because you typed the path yourself. The MCP server is different again, because the arguments come from a model, so the boundary is set by a human at launch and nothing the agent sends can widen it. Where @Telegraphprotoc comes in: A replay proves things about a reproduction running on one machine. It knows nothing about whether that reproduction matches the incident it claims to be about. That is a fact about a public chain, and no amount of local determinism supplies it. So ExploitLens buys it. On chain facts about the real incident transaction are purchased through Telegraph, paid per request in USDC, and every answer arrives with a receipt naming the miner and a hash anyone can look the call up by afterwards. Purchased intelligence is recorded as evidence and never quietly becomes a verdict. Where a bought answer and the replay disagree, the disagreement is what gets shown. Still coming: A GitHub Action, so this runs on any pull request that claims to fix a vulnerability. The verification half published as a standalone package, so checking a Fix Receipt does not require cloning anything. More cases, including incidents that are not mine. github.com/solutiono1/exploi… Built for @Telegraphprotoc

Post attachment
Solution avatar
⟳ Solution retweeted
Solution@solution_o1·Nov 17

ExploitLens replays a real exploit twice. Once against the commit it worked on, once against the commit meant to stop it, same frozen inputs both times. The whole point is the comparison, so the main view puts the two call traces side by side. Until this week that view was close to useless. The TempleDAO/STAX run produces 11 calls on the vulnerable side and 5 on the patched side. They were rendered as two independent lists. Nothing lined up. If you wanted to know which patched call corresponded to the fourth vulnerable one, you worked it out yourself, by eye, from badges. The aligner had already computed every one of those pairings. The interface simply was not showing them. So I rebuilt it: a row is the pairing. One row, two cells, and an explicit placeholder on whichever side has no counterpart. The part I expected to be trivial and wasn't: The aligner does not pair calls in order. On STAX it pairs the sixth vulnerable call with the third patched one. A naive two pointer merge walks both lists forward and quietly drops that pairing, rendering both calls as unmatched. You get a view that looks clean and is wrong. So the merge emits a pair even when the cursor has already moved past the partner. Inserted calls have the opposite problem. A call that exists only on the patched side has no vulnerable row to sit beside. Flush them at the end and the inserted call shows up nine rows below where it actually runs. It gets placed in patched order instead. Then the line I decided not to cross. A call can carry no alignment record at all. That is not the same fact as a call the aligner marked as deleted. The first means we did not match it. The second means it is absent from the other commit. Collapsing them would turn a gap in my analysis into a finding about somebody's patch, which is exactly the kind of quiet overreach this whole project exists to refuse. So an unmatched call renders as "Not aligned", never as "Removed by the patch", and there is a test holding that in place. Same reasoning one level up: if a bundle ships no alignment data at all, the merged view is skipped entirely and you get the two trees separately, with a line saying why. Merging unaligned traces would pair calls by position alone. That looks like a finding and is not one. Last piece: the labels were raw 4 byte selectors, so the page was a column of hashes. I built a lookup table, but I did not type it from memory. Every signature is hashed with keccak-256 to derive its selector, and a test recomputes all 50 entries on every run. A wrong entry would print a confident, plausible, incorrect function name onto an evidence page, which is worse than printing hex. Now a wrong entry fails the suite. Two rules there. The raw selector stays on screen next to every decoded name, because four bytes collide and the name is a reading while the hex is the fact. And unknown selectors stay as hex. 0xca669fa7 is in the committed STAX bundle and resolves to nothing, so it still renders as 0xca669fa7. Guessing would be worse. What the page says now, reading down: balanceOf aligns to balanceOf. migrateStake, removed. Its child migrateWithdraw, removed. Then a different migrateStake, inserted on the patched side. withdrawAll, removed. And its child transfer, removed. That is the money leaving. One detail I like, because it shows the thing is not cheating: both migrateStake calls carry the identical selector, 0xbdcd9c80, and the aligner still reports a removal plus an insertion rather than a match. Alignment there is structural, not name matching, and the view shows that rather than smoothing it into something tidier. Built on @Telegraphprotoc exploitlens launching soon and we've been planing to bring it open source, more info soon.

Post attachment
Solution avatar
⟳ Solution retweeted
Solution@solution_o1·Nov 15

here is the demo explaining further... @NEARProtocol @NEARFoundation @NearBuilders

1:25

Your wallet address is a public confession. Every client you send it to can see what every other client paid you. They can see your balance. They can see the gap between the invoice you sent them and the one you sent someone else. Forever, on a public ledger, with no way to take it back. And after handing over all of that, you still have nothing a landlord, a bank or a visa officer will accept as proof of income. A block explorer is not a payslip. So freelancers getting paid in stablecoins are stuck choosing between privacy and provability. You get neither. I built Cachet to fix both. THE IDEA Every invoice gets its own sealed envelope on NEAR. Your browser derives a one-time keypair and a random salt for each invoice from a single master seed, using HKDF. The invoice details get hashed with that salt into a commitment I call a seal. Your client pays into the contract against that seal. The chain records an amount, a token, a timestamp and a 32 byte hash. It never records who was paid, what the work was, or that two invoices belong to the same person. Your client pays you without ever seeing your wallet. GETTING THE MONEY OUT You release an envelope by signing a message with the key only you hold. The message is SHA-256 of a domain string, the contract account, the envelope id, and the destination account. All four matter. The domain string stops the signature meaning anything elsewhere. The contract account stops replay against another deployment. The envelope id stops reuse on a different invoice. And the recipient is baked in, so whoever relays the transaction cannot redirect your money to themselves. NEAR verifies that signature on chain with env::ed25519_verify. That host function is the reason this design is possible at all. On a chain without native Ed25519 verification, a one-time key per invoice would need its own account, or a far more expensive scheme. PROVING IT LATER This is the part that makes it a product and not a privacy toy. You pick which payments to disclose. Not all of them. The ones you choose. You sign a statement naming who the proof is for and when it expires. Anyone can verify it in their browser. No wallet. No account. No sign up. Three checks run: 1. The invoice details rehash to the seal recorded on chain 2. The payment actually exists in the contract, for that amount, in that token 3. Each payment carries a signature from the key that owns it That third check is the one people miss. Your client knows the invoice details and the salt, because they paid it. They still cannot present your income as theirs, because they never had the key. THE ATTACK I FOUND ON MYSELF Nobody reads a blockchain directly. You read it through a server somebody runs, and that server can answer with whatever it likes. If the same party hands you a proof and tells you which endpoint to check it on, they can run an endpoint that invents the payment. I wrote the attack and it worked: a proof for an invoice nobody ever paid reported Verified, total 9,000 USDC. So verification now reads through three independent operators, FastNEAR, the NEAR Foundation and dRPC, and confirms a payment only when two agree. Run the same attack now and it reports Not verified, because the endpoints disagree. The attack script is in the repo. One command. Try to break it. WHAT IS ACTUALLY REAL Live on NEAR testnet at cachetapp.testnet, with real payments and real withdrawals on chain. The contract has no owner, no upgrade method, no pause. I cannot freeze your envelope or take your money, and neither can anyone who compromises me. No server. No database. No accounts. No cookies. No analytics. The invoice travels in the link fragment, the part after the #, which browsers never send to any server. There is a content security policy naming every host the app is allowed to contact, so the browser enforces that claim instead of asking you to trust me. 67 tests, including a payer trying to pass off someone else's invoice as their own income. BEING HONEST ABOUT THE LIMITS Amounts and settlement times are public on NEAR. Opening two envelopes into the same account links them. Cachet hides you from the people who pay you. It is not a mixer and I will not pretend otherwise. Settling through Confidential Intents is the roadmap, not this release. Built at NEAR HACKATHON. Live: cachet-962.pages.dev Code: github.com/solutiono1/cachet @NEARProtocol #NEARHackathon @NearBuilders

Solution avatar
⟳ Solution retweeted
Solution@solution_o1·Nov 15

Yesterday I posted about a paid answer that was fabricated. Today I found the same class of bug in my own code, and mine was worse. My pipeline told me a known exploit did not reproduce. It had reproduced, The test passed, The exact token transfer the exploit depends on was sitting in the trace the whole time. Root cause: Foundry 1.5.1 stopped putting address on the per node log records inside a trace arena. It survives only on the test result's top level logs. Three lines of JSON. No deprecation warning, because why would there be. My log reader required that field, So: every log failed the guard → zero effects extracted → the invariant had nothing to evaluate → it returned "not-violated" A clean negative, On a working exploit. That is the shape worth being frightened of. Not a crash, Not an error, Not a stack trace. A confident, well formed "nothing wrong here", from a tool whose entire job is to tell you whether something is wrong. The fix is small: a log is emitted by whichever contract is executing, so the owning call node is the emitter. I didn't assume that. I matched every arena log against the top level logs that still carry addresses: 7 of 7 agreement, 0 mismatches. Two things I'd take from this if you build anything that reports a verdict: an empty input set and a genuine negative must not produce the same output and pin your toolchain version, because "it compiled" is not "it still means the same thing" github.com/solutiono1/exploi… @Telegraphprotoc

Post attachmentPost attachment
Solution avatar
⟳ Solution retweeted
Solution@solution_o1·Nov 14

Your wallet address is a public confession. Every client you send it to can see what every other client paid you. They can see your balance. They can see the gap between the invoice you sent them and the one you sent someone else. Forever, on a public ledger, with no way to take it back. And after handing over all of that, you still have nothing a landlord, a bank or a visa officer will accept as proof of income. A block explorer is not a payslip. So freelancers getting paid in stablecoins are stuck choosing between privacy and provability. You get neither. I built Cachet to fix both. THE IDEA Every invoice gets its own sealed envelope on NEAR. Your browser derives a one-time keypair and a random salt for each invoice from a single master seed, using HKDF. The invoice details get hashed with that salt into a commitment I call a seal. Your client pays into the contract against that seal. The chain records an amount, a token, a timestamp and a 32 byte hash. It never records who was paid, what the work was, or that two invoices belong to the same person. Your client pays you without ever seeing your wallet. GETTING THE MONEY OUT You release an envelope by signing a message with the key only you hold. The message is SHA-256 of a domain string, the contract account, the envelope id, and the destination account. All four matter. The domain string stops the signature meaning anything elsewhere. The contract account stops replay against another deployment. The envelope id stops reuse on a different invoice. And the recipient is baked in, so whoever relays the transaction cannot redirect your money to themselves. NEAR verifies that signature on chain with env::ed25519_verify. That host function is the reason this design is possible at all. On a chain without native Ed25519 verification, a one-time key per invoice would need its own account, or a far more expensive scheme. PROVING IT LATER This is the part that makes it a product and not a privacy toy. You pick which payments to disclose. Not all of them. The ones you choose. You sign a statement naming who the proof is for and when it expires. Anyone can verify it in their browser. No wallet. No account. No sign up. Three checks run: 1. The invoice details rehash to the seal recorded on chain 2. The payment actually exists in the contract, for that amount, in that token 3. Each payment carries a signature from the key that owns it That third check is the one people miss. Your client knows the invoice details and the salt, because they paid it. They still cannot present your income as theirs, because they never had the key. THE ATTACK I FOUND ON MYSELF Nobody reads a blockchain directly. You read it through a server somebody runs, and that server can answer with whatever it likes. If the same party hands you a proof and tells you which endpoint to check it on, they can run an endpoint that invents the payment. I wrote the attack and it worked: a proof for an invoice nobody ever paid reported Verified, total 9,000 USDC. So verification now reads through three independent operators, FastNEAR, the NEAR Foundation and dRPC, and confirms a payment only when two agree. Run the same attack now and it reports Not verified, because the endpoints disagree. The attack script is in the repo. One command. Try to break it. WHAT IS ACTUALLY REAL Live on NEAR testnet at cachetapp.testnet, with real payments and real withdrawals on chain. The contract has no owner, no upgrade method, no pause. I cannot freeze your envelope or take your money, and neither can anyone who compromises me. No server. No database. No accounts. No cookies. No analytics. The invoice travels in the link fragment, the part after the #, which browsers never send to any server. There is a content security policy naming every host the app is allowed to contact, so the browser enforces that claim instead of asking you to trust me. 67 tests, including a payer trying to pass off someone else's invoice as their own income. BEING HONEST ABOUT THE LIMITS Amounts and settlement times are public on NEAR. Opening two envelopes into the same account links them. Cachet hides you from the people who pay you. It is not a mixer and I will not pretend otherwise. Settling through Confidential Intents is the roadmap, not this release. Built at NEAR HACKATHON. Live: cachet-962.pages.dev Code: github.com/solutiono1/cachet @NEARProtocol #NEARHackathon @NearBuilders

Solution avatar
Solution@solution_o1·Nov 14

Hit the Telegraph Season II integration milestone today: first paid V2 request from ExploitLens, settled on chain. It came back confidently wrong, and I think that is the most useful thing I could have posted. I asked for the on chain facts of a real incident, the TempleDAO/STAX exploit transaction, Oct 2022: 0x8c3f442fc6d640a6ff3ea0b12be64f1d4609ea94edd2966f42c01cd9bdcf04b5 Paid $0.01, Payment settled. Signal verifies. Status: success. What came back; block: 15,537,394 from: 0xd8da6bf2…96045 to: 0x00000000…78ba3 tx_hash: "0x" confidence: 0.99 Those are not that transaction's facts. 15537394 is The Merge block. 0xd8da… is vitalik.eth. 0x0000…78ba3 is Permit2. tx_hash came back as "0x", the hash I paid to have looked up was never used. The real block is 15725067. Off by 187,673. The request did carry the hash. I can show the payload. So either the Engine did not map the param through to this miner, or the miner ignored it and answered from defaults. From where I sit as the buyer those are the same event: I paid for a lookup that never happened and got 0.99 confidence attached to it. Verify it yourself: devnode.telegraphprotocol.co… I only caught it because ExploitLens independently reproduces the incident and knows the real block. Without ground truth this answer looks clean. That is the entire argument for Exploitlens. Filing it on @Telegraphprotoc's bounty board rather than just dunking, this is fixable and the network is better for it being known.

Post attachment

Something has bothered me for a while, and I finally built the thing that fixes it. In security work, "we fixed it" is almost always an assertion. A bug gets found. A patch gets written. Someone reviews the diff, nods, and says it looks right. Maybe a re-audit happens. Then everyone moves on and the fix becomes a line in a report. But notice what usually does not happen: nobody takes the original exploit, runs it again against the patched code, and proves the specific thing it did no longer happens. We reason about fixes. We rarely re-run them. That gap has consequences. A patch can look correct and miss the actual path. A patch can close the hole and quietly break legitimate use at the same time. A patch can work for the wrong reason. All three happen, and a diff review catches none of them reliably, because reading code is not the same as executing it. So I built ExploitLens. You give it three things: a real exploit, the commit it worked against, and the commit meant to stop it. It replays the exploit against both commits under identical frozen inputs, using real Foundry execution, not a simulation of execution, the real thing. Then it aligns the two call trees semantically and finds the first causal divergence: the exact call where the two runs stop agreeing, which is where the prohibited effect stops being reachable. It also runs a third phase that I think matters more than people expect. It checks that legitimate use still works at the patched commit. A patch that stops the exploit by breaking the contract is not a fix, and if you only test the exploit you will never notice. The output is a Fix Receipt: a schema validated evidence bundle with a hash over its own contents. Rederive the hash offline and a single altered byte fails the check. You do not have to trust me, or the tool, or a dashboard. Here is the part I care about most. ExploitLens will not tell you a contract is secure. No replay can establish that. It cannot tell you no other vulnerability exists, because it never went looking. It will not give you a verdict without a reproduction, and when a gate fails, the failure stays in the committed bundle rather than getting smoothed into something more comfortable. What it will tell you is narrow and provable: this exploit, against this patch, under these inputs, no longer produces this effect and here is exactly where it stopped. I would rather ship a small true claim than a large vague one. The security industry has enough green badges. for now it'll carry two cases you can click through yourself. One is a controlled reentrancy fixture. The other is a real 2022 DeFi incident TempleDAO/STAX replayed and verified end to end. Code: github.com/solutiono1/exploi… Over the next couple of weeks I am taking it further: wiring it into @Telegraphprotoc so it can buy verified on chain facts about the real incident, instead of assuming its local reproduction matches what actually happened. A local proof is only as good as its connection to reality, and that connection has to be bought, not assumed. I will be posting the build as it happens including the parts that break. If you do security work, or you have opinions about what a fix should have to prove before anyone calls it fixed, I want to hear them.

Post attachment