Smart Contract Auditing Workflows
Smart contract auditing is a structured review of blockchain program code, its intended rules, and its deployment assumptions. The workflow turns a fixed code snapshot into reproducible findings, reviewed fixes, and a record of what was and was not examined.
itOffensive security and application security | OpenSkills.info
Recommended first:smart-contract-security
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic: Smart Contract Auditing Workflows
A smart contract audit is a security review with unusually strict paperwork, because the paperwork is what stops everyone from arguing about which code was actually reviewed. The auditor examines a fixed revision, a defined set of files, and a stated collection of assumptions. Without those three things, the report may be accurate in the abstract and attached to nothing in particular, which is an expensive form of literature.
The first idea is scope: the repository, full commit hash, paths, compiler inputs, dependencies, deployed addresses, and exclusions that define the audit unit. A project name is not a scope. Neither is a branch, because branches move while people are looking at them. Freeze the target, or treat every accepted change as a new differential review with its own blast radius.
The second idea is an invariant, a rule that must remain true across every reachable state under stated assumptions. Auditing starts by naming assets, actors, authority, external dependencies, and these rules. This feels less dramatic than finding an exploit. It is also how an auditor knows that a surprising behavior is wrong rather than merely surprising.
Tools then produce leads. Static analyzers point at patterns and draw useful structural maps. Fuzzers and invariant tests try call sequences that humans would not patiently enumerate. Symbolic execution explores constrained paths. None of them can recover an economic rule that nobody wrote down. A clean tool run therefore means the configured tools found no matching condition, not that the contract has received a small certificate of invulnerability from the universe.
A defensible finding ties a root cause to exact code, preconditions, a violated property, an ordered path, a reproducible proof, and a reasoned impact. Triage then groups duplicates and challenges severity. This is where a stack of submissions becomes a report rather than a leaderboard of alarming nouns.
Fixes receive their own review. Rerun the original proof, add a regression test, inspect the wider diff, and record the remediation commit. The final step compares compiled source with deployed bytecode. That proves the reviewed build and the running artifact are related. It does not prove the logic correct; identity and correctness are different chores, because apparently one chore would have been too convenient.
Read the Intro for the complete evidence pipeline. Keep the Cheatsheet beside an engagement for scope, finding, triage, and fix-review gates. Use the Practice Reference to structure a real review, then use the Exercise to produce one small evidence packet from a vulnerable vault. Field Notes covers the parts that consume time and credibility when teams treat them as administration.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://ethereum.org/developers/docs/smart-contracts/security/
Supports
- independent review
- audit limits
- development practices
- testing layers
- tool and service ecosystem
- monitoring and recovery
- https://ethereum.org/developers/docs/smart-contracts/testing/
Supports
- testing role
- audits versus bug bounties
- manual review and formal verification
- https://ethereum.org/developers/tutorials/secure-development-workflow/
Supports
- static analysis
- structural inspection
- property testing
- automation limits
- https://docs.soliditylang.org/en/latest/security-considerations.html
Supports
- external-call control transfer
- reentrancy
- checks-effects-interactions
- compiler warnings
- gas and authorization risks
- https://scs.owasp.org/SCSVS/
Supports
- smart contract verification control groups
- audit scope and coverage
- update source
- https://diligence.security/blog/2019/09/how-to-prepare-for-a-smart-contract-audit/
Supports
- documentation value
- clean code
- testing
- automated analysis
- frozen commit
- audit preparation
- field notes
- https://diligence.security/blog/2023/04/how-to-prepare-for-a-smart-contract-audit-with-consensys-diligence/
Supports
- scope document
- repository and commit identity
- in-scope paths
- key risks
- code freeze
- test evidence
- field notes
- https://diligence.security/audits/2020/04/rico/lukso-rico-audit-2020-04.pdf
Supports
- audit report scope
- objectives
- code boundaries
- report limitations
- https://docs.code4rena.com/competitions
Supports
- competitive audit phases
- judging
- sponsor input
- report publication
- https://docs.code4rena.com/competitions/submission-guidelines
Supports
- finding location
- impact
- reproduction
- proof burden
- severity
- known issues
- field notes
- https://docs.code4rena.com/awarding
Supports
- duplicate findings
- validity and severity judging
- partial credit
- triage decisions
- https://ethereum.org/developers/docs/smart-contracts/verifying
Supports
- source and compiler input recompilation
- bytecode comparison
- verification versus correctness
- proxy deployment provenance
- https://docs.openzeppelin.com/upgrades-plugins/proxies
Supports
- proxy delegation
- implementation relationship
- storage
- upgrade behavior
- https://secure-contracts.com/
Supports
- smart contract security workflow
- static analysis
- fuzzing
- symbolic execution
- property testing
- https://secure-contracts.com/program-analysis/slither/docs/src/Usage.html
Supports
- Slither commands
- detectors
- printers
- review workflow
- https://crytic.github.io/slither/slither.html
Supports
- Slither features
- structural printers
- framework integration
- awesome link rationale
- https://secure-contracts.com/program-analysis/echidna/introduction/how-to-test-a-property.html
Supports
- executable invariants
- generated call sequences
- counterexamples
- quiz invariant reasoning
- https://github.com/sindresorhus/awesome
Supports
- required awesome-list discovery starting point
- EVM Security list discovery
- https://github.com/crytic/awesome-ethereum-security
Supports
- Slither
- Echidna
- Mythril
- Surya
- Ethernaut
- and security ecosystem discovery
- https://github.com/ConsenSysDiligence/mythril
Supports
- symbolic execution for EVM bytecode
- detector-based analysis
- awesome link rationale
- https://github.com/ConsenSysDiligence/surya
Supports
- Solidity call graphs
- inheritance and function inspection
- awesome link rationale
- https://ethernaut.openzeppelin.com/
Supports
- Solidity and EVM exploitation practice
- awesome link rationale
- https://www.damnvulnerabledefi.xyz/
Supports
- DeFi security challenges
- multi-contract audit practice
- awesome link rationale
- https://trailofbits.com/services/software-assurance/
Supports
- scope
- parallel review
- root-cause reporting
- proofs
- reusable deliverables
- fix review
- product landscape
- field notes
- https://www.openzeppelin.com/security-audits
Supports
- manual and automated smart contract audit services
- supported review domains
- product landscape
- https://diligence.security/
Supports
- Ethereum audit services
- pre-audit assessment
- expert review
- public reports
- product landscape
- https://www.chainsecurity.com/
Supports
- smart contract and DeFi audit services
- public audit reports
- product landscape
- https://www.certora.com/audits
Supports
- manual audits with formal specifications
- reusable rules
- audit process
- product landscape
- https://code4rena.com/
Supports
- competitive smart contract audits
- product landscape
- https://www.cantina.security/
Supports
- onchain security services
- researcher competitions and bounties
- product landscape
- https://immunefi.com/audit-competition/
Supports
- time-bounded audit competitions
- findings and triage
- product landscape
- https://immunefi.com/
Supports
- smart contract bug bounty programs
- continuing disclosure
- product landscape
