Home / Services / Solana & Rust audit

Web3 & Crypto · Solana & Rust audit

Solana program audits that understand accounts, not just code.

Most Solana exploits are not Rust bugs. They are account-model bugs: a missing owner check, a PDA seed that can be forged, a CPI into a program nobody verified. We audit Anchor and native Solana programs with that model front and centre, and we prove every Critical and High finding with a working test against a local validator.

What we test

  • Account validation: owner, signer, writable and discriminator checks on every instruction
  • PDA derivation: seeds, bumps, canonical bump enforcement and seed collisions
  • Cross-program invocation safety: program-id verification, privilege escalation through CPI, reentrancy via callbacks
  • Arithmetic: overflow in release builds, precision and rounding in token and share maths
  • SPL Token, Token-2022 extensions, associated token accounts and mint authority handling
  • Account closing and revival, rent exemption, realloc and data-size assumptions
  • Anchor-specific constraints, `init_if_needed`, `remaining_accounts` and type cosplay
  • Upgrade authority, multisig governance and the trust model around the deployer

What you get

  • Report with findings ranked Critical / High / Medium / Low / Informational
  • Proof-of-concept test (Anchor TypeScript or Rust) for every Critical and High
  • Remediation per finding, with Rust diffs where useful
  • Review of the deployment, upgrade and key-management process
  • Free retest and a publishable final report

Why Solana needs a different kind of audit

On the EVM, state lives inside the contract and the compiler enforces types. On Solana, state lives in accounts that anyone can pass to your instruction, and it is the program's job to verify every single one. Most of the large Solana incidents — forged accounts, fake sysvars, unchecked token mints, CPI into attacker-controlled programs — came from a missing or incomplete check, not from a memory-safety bug in Rust. Our audit follows the account model instruction by instruction: which accounts does this take, what does the program assume about each, and what happens if an attacker supplies a different one?

Anchor and native programs

Anchor removes a lot of boilerplate and a lot of bugs, but it introduces its own: constraints that are weaker than they look, `init_if_needed` reinitialisation paths, `remaining_accounts` that are never validated, and account types that can be substituted when discriminators are not checked. Native programs without Anchor get the full manual treatment, since nothing is checked for free. We also review Token-2022 extension handling, which has become a frequent source of fee and transfer-hook surprises.

Rust beyond Solana

The same team audits Rust across the ecosystem: CosmWasm contracts, Substrate and Polkadot pallets, NEAR contracts, and off-chain Rust components such as indexers, relayers, sequencers and signing services. Ownership and the borrow checker remove whole classes of memory bugs, but logic, concurrency, serialisation and arithmetic issues remain — and those are the ones we look for.

How we prove findings

Every Critical and High finding ships with a test that reproduces it against a local validator: an Anchor TypeScript test or a Rust integration test, whichever your team uses. You can run it before the fix to see the exploit and after the fix to confirm it is closed. We do not report theoretical issues as Critical; if we cannot demonstrate impact, we say so and rate accordingly.

Timeline

A single Anchor program of modest size takes about a week. A protocol with several programs and complex CPI flows takes two to three weeks. Quotes are fixed and in writing, retest included, and we can usually start within one to two weeks of signing.

Engagement

How an engagement runs

01

Scope

We agree targets, rules of engagement and what success looks like — in writing, before anything starts.

02

Recon

We map your full attack surface the way an adversary would, not just the assets you remembered to mention.

03

Exploit

We attempt real exploitation and chain small weaknesses into business-level impact.

04

Report

You get prioritised findings, proof-of-concept and remediation steps a developer can act on today.

05

Retest

We verify every fix so issues stay closed — and you get a clean report to show customers.

FAQ

Questions about solana & Rust audit

Do you audit Anchor and native Solana programs?

Both. Anchor programs get a review of the constraints and the places Anchor does not protect; native programs get the full manual account-validation review since nothing is enforced for you.

Do you cover Token-2022 and transfer hooks?

Yes. Token-2022 extensions — transfer fees, transfer hooks, confidential transfers, permanent delegates — change assumptions that older code makes about SPL tokens, and we review those integrations explicitly.

Can you audit other Rust chains?

Yes: CosmWasm, Substrate and Polkadot pallets, NEAR, and off-chain Rust services such as relayers and indexers.

What do the proofs of concept look like?

A test your team can run — Anchor TypeScript or a Rust integration test against a local validator — that performs the exploit before the fix and fails after it.

Find out what an attacker would find first.

Send us what you want tested. We'll come back with scope, timing and a fixed quote — no sales theatre.

Start on Telegram