The OWASP Application Security Verification Standard (ASVS) organizes roughly 350 requirements across 17 chapters into an open, versioned checklist meant to be verified requirement by requirement rather than read as general advice. The current release, ASVS 5.0.0, was published 30 May 2025 under a Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license and organises roughly 350 requirements across 17 chapters, per the project's own documentation. Unlike the OWASP Top 10's risk-awareness framing, ASVS exists to answer a narrower, more testable question for a specific application: for each individual requirement, does this build satisfy it or not?
Key takeaways
- ASVS defines an "application" as the software product being developed.
- ASVS 5.0.0's roughly 350 requirements are grouped into 17 numbered chapters.
- The classic embedded web bugs — default logins, command injection in diagnostics pages, admin pages over plain HTTP, debug features left on — each map to a specific ASVS 5.0.0 requirement.
- ASVS covers the application layer.
What is ASVS for?
OWASP describes three concrete uses for the standard: as a metric security architects and assessors can use to judge how trustworthy an application is; as guidance for developers and security-control vendors building the mechanisms an application needs; and as a basis for specifying application security requirements in development contracts. Every requirement in the document is written to be individually verifiable — producing a clear pass or fail. The ASVS 5.0 "What is the ASVS" chapter gives each requirement an identifier in the form <chapter>.<section>.<requirement> and recommends prefixing the version, as in v5.0.0-1.2.5, because numbers can change between major releases. That way a specific control can be cited precisely in a report, a ticket, or a contract clause rather than paraphrased.
ASVS defines an "application" as the software product being developed. For a device maker, that covers three surfaces: the web admin page served by the device itself, any local REST or WebSocket API, and the cloud backend the device and its app talk to. The chapter notes that, for a machine-to-machine API, "the requirements in chapter V3 related to web frontends will not be relevant".
What are the 17 chapters?
ASVS 5.0.0's roughly 350 requirements are grouped into 17 numbered chapters. The chapter files in the OWASP/ASVS repository carry these names; the right-hand column is our reading for a connected device:
| Chapter | Name | Where it bites on a device |
|---|---|---|
| V1 | Encoding and Sanitization | CGI handlers that pass form fields to shell commands |
| V2 | Validation and Business Logic | Setpoint ranges, firmware-upload workflow order |
| V3 | Web Frontend Security | Local admin page: cookies, CSRF, framing |
| V4 | API and Web Service | Local REST / WebSocket API, cloud API |
| V5 | File Handling | Firmware and configuration file uploads |
| V6 | Authentication | Default accounts, brute force, initial passwords |
| V7 | Session Management | Admin sessions on the web UI |
| V8 | Authorization | Viewer vs admin roles; one user's device data vs another's |
| V9 | Self-contained Tokens | JWTs between app, cloud and device |
| V10 | OAuth and OIDC | Cloud and app sign-in |
| V11 | Cryptography | Key storage and algorithms in the backend |
| V12 | Secure Communication | TLS on the web UI and to the cloud |
| V13 | Configuration | Debug modes, exposed metadata, backend secrets |
| V14 | Data Protection | Personal and telemetry data in the cloud |
| V15 | Secure Coding and Architecture | Third-party components, SBOM, remediation time frames |
| V16 | Security Logging and Error Handling | Error messages, log integrity |
| V17 | WebRTC | Camera and doorbell video streaming |
Chapters are organised so a team can select the ones relevant to their application's architecture rather than apply the entire document uniformly to every build.
How do Level 1, Level 2 and Level 3 build on each other?
ASVS's three verification levels are cumulative, not independent tracks — each level includes everything in the level below it, plus more:
| Level | Share of total requirements | What it represents |
|---|---|---|
| Level 1 | ~20% | "The minimum requirements to consider when securing an application... a critical starting point," per the ASVS 5.0 documentation. The standard adds that Level 1 "is not necessarily penetration testable by an external tester without internal access to documentation or code". |
| Level 2 | brings L1+L2 to ~70% of the total | The level most applications handling sensitive data should target, per the standard's own framing — "most applications should be striving to achieve this level." |
| Level 3 | the remaining ~30% | The highest-assurance tier, generally defense-in-depth mechanisms and other controls described as useful but harder to implement, aimed at applications where the consequences of failure are most severe. |
A device maker's companion mobile app or cloud management backend is a reasonable candidate for Level 1 or Level 2 verification; a backend handling safety-relevant commands or large volumes of personal data is a better candidate for Level 3. ASVS does not prescribe a level: an organization "should analyze its risks and decide what level it believes it should be at".
Which ASVS requirements matter most on a device's web and API surfaces?
The classic embedded web bugs — default logins, command injection in diagnostics pages, admin pages over plain HTTP, debug features left on — each map to a specific ASVS 5.0.0 requirement. Requirement text is condensed from the V6 Authentication chapter and the other chapter files:
| ID | Requirement (condensed) | Level | Device reading |
|---|---|---|---|
| 6.3.2 | Default user accounts (e.g. "root", "admin") are not present or are disabled | 1 | No shared factory login on the admin page |
| 6.4.1 | System-generated initial passwords are securely random, expire, and cannot become the long-term password | 1 | Per-device label password forces a change at first login |
| 6.3.1 | Controls against credential stuffing and brute force, as documented | 1 | Back-off on the login form and local API |
| 6.2.1 | User passwords at least 8 characters; 15 strongly recommended | 1 | Password field limits in firmware |
| 1.2.5 | Protection against OS command injection | 1 | Ping / traceroute / NTP fields in diagnostics pages |
| 8.2.1 / 8.2.2 | Function-level and data-specific access restricted to explicit permissions (IDOR, BOLA) | 1 | Viewer role cannot reach admin endpoints; cloud user cannot read another user's device |
| 3.5.3 | Sensitive functions use POST, PUT, PATCH or DELETE, not GET | 1 | No GET /reboot that a malicious web page can trigger |
| 12.2.1 | TLS for all client connections to external-facing HTTP services, no fallback | 1 | Cloud APIs and remote admin |
| 12.1.1 | Only recent TLS versions (TLS 1.2, 1.3) enabled | 1 | Old TLS stacks in device firmware |
| 13.4.2 | Debug modes disabled in production | 2 | Developer endpoints and verbose modes removed from release builds |
| 5.2.3 | Compressed uploads checked against maximum uncompressed size and file count | 2 | Firmware and config archive uploads |
| 15.1.2 | An SBOM of third-party libraries is maintained | 2 | Per-release component list for the firmware and backend |
| 15.2.1 | No component past its documented remediation time frame | 1 | Old embedded web server or OpenSSL build still shipping |
For the vulnerability class behind 1.2.5 on devices, see how to fix command injection in embedded firmware.
What does ASVS leave out for a device?
ASVS covers the application layer. Several device concerns sit outside it:
- Hardware and firmware platform: secure boot, debug ports, key storage on the chip, update integrity. OWASP's ISVS covers these for IoT devices.
- Companion mobile apps: covered by OWASP MASVS.
- Consumer IoT baseline duties: ETSI EN 303 645 V3.1.3 provision 5.1-1 requires device passwords to be "unique per device or defined by the user", and provision 5.1-5 asks for a mechanism that makes brute-force attacks via network interfaces "impracticable". These overlap with V6, but the device-level wording is what labelling schemes test; see our EN 303 645 guide.
- Test method: ASVS says what to verify, not how. OWASP points testers to the Web Security Testing Guide.
The standard itself says ASVS "should be evaluated alongside guidance for other aspects of the application lifecycle".
Is there an official certification?
No. OWASP does not run or endorse an ASVS certification program. The project's own Assessment and Certification documentation is explicit: "any assurance, trust mark, or certification claiming ASVS compliance is not officially endorsed by OWASP," though organisations "may offer assurance services, provided they do not claim official OWASP certification." A vendor or auditor stating a product is "ASVS 5.0 Level 2 certified" is describing a self-declared or third-party assessment against the standard's requirements, not an OWASP-issued credential — worth confirming what assessment method was actually used before relying on the claim.
How does ASVS fit next to the OWASP Top 10 and OWASP SAMM?
These three OWASP projects answer different questions and are complementary rather than overlapping:
| Project | Question it answers | Granularity |
|---|---|---|
| OWASP Top 10 | What are the most critical categories of risk right now? | Awareness, 10 broad categories |
| ASVS | Does this specific application satisfy this specific, testable control? | ~350 individually verifiable requirements |
| OWASP SAMM (see our guide) | How mature is the organisation's software-development process overall? | Organisational maturity, 5 business functions |
A device or software maker can reasonably use the Top 10 to prioritise initial attention, ASVS to verify a specific application build against a concrete checklist, and SAMM to track whether the development process producing that application is improving over time. For the local and cloud APIs, the OWASP API Security Top 10 plays the same awareness role.
Worked example: how would you scope ASVS for an industrial gateway's web UI?
Synthetic example; the product is invented for illustration.
An industrial gateway has a local web admin page, a local REST API used by an installer tool, and a cloud management portal.
List the surfacesThree applications: on-device web UI, on-device REST API, cloud portal. The threat model marks the web UI and API as reachable from the plant network. Pick levelsThe gateway can change PLC setpoints, so the team targets Level 2 for the on-device surfaces and the cloud portal, with Level 3 for the cloud's authorization chapter. Drop chapters that do not applyNo WebRTC, so V17 is out; the REST API skips V3. The cloud portal uses OIDC, so V10 stays in. Write the documentation requirements firstASVS puts documentation requirements at the start of chapters (for example 6.1.1 on rate limiting, 15.1.1 on remediation time frames). The team writes these decisions down before testing. Verify and recordResults go into a sheet keyed by v5.0.0-identifiers. Two failures: the API acceptsGETfor a restart action (3.5.3) and the release build still answers a debug endpoint (13.4.2).Re-check per releaseFailed items become tickets; the same IDs are re-tested on the next firmware build.
What are the common pitfalls?
- Testing only the cloud portal. The web server inside the firmware is usually the weaker surface.
- Citing IDs without a version. Major releases renumber requirements;
v5.0.0-6.3.2stays unambiguous. - Applying 12.2.2 blindly. Publicly trusted certificates are required for "external facing services"; a device's local admin page often cannot get one. Record the decision and how the device proves its identity instead.
- Skipping documentation requirements. Several implementation requirements are checked against your own documented rules; with no document, they cannot pass.
- Treating ASVS as a device standard. Hardware, boot and update security need ISVS or EN 303 645 alongside it.
What is a practical starting point?
Pick a level deliberately, chapter by chapter if neededA companion app's authentication chapter might warrant Level 2 while its less sensitive features stay at Level 1 — the standard's chapter structure supports mixed-depth adoption, and it encourages organizations to create a tailored fork that keeps requirement numbers traceable. Cite requirement IDs, not summaries, in internal tickets and vendor contractsThe v5.0.0-x.y.zidentifiers exist so a specific control can be unambiguously referenced and re-checked after a code change.Verify any third-party "ASVS certified" claim against the actual assessment method used, since OWASP itself does not issue or endorse certifications. Pair ASVS with CVE/KEV monitoring, not instead of it— passing a point-in-time verification does not substitute for ongoing vulnerability tracking once the application ships; see KEV and EPSS for vulnerability prioritization.
SoftWSP does not run ASVS verifications or test web interfaces. It covers the firmware side of the V15 component requirements: from a firmware image it extracts a CycloneDX 1.6 SBOM, matches the components against NVD, the CISA KEV catalog, FIRST EPSS and CISA's CSAF ICS advisories, and drafts a cited report for an engineer to review. You can open the resulting SBOM in the free SBOM viewer; more on the format in our firmware SBOM guide. For a review that puts this firmware evidence next to your own web and API verification: see device firmware security.
This guide summarises a public OWASP project (ASVS 5.0.0, as checked on 11 November 2026); it does not constitute legal or compliance advice.
Put this guide to work
Frequently asked questions
What is OWASP ASVS?
The Application Security Verification Standard (ASVS) is an OWASP open framework of application security requirements, used as a metric for assessing how trustworthy an application is, as guidance for developers building security controls, and as a basis for specifying security requirements in contracts. The current release is version 5.0.0, published 30 May 2025, licensed under Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0), and distributed as a public GitHub repository and companion site. Per the project's own documentation, ASVS 5.0.0 organises roughly 350 requirements across 17 chapters.
What are ASVS Level 1, Level 2 and Level 3?
Three cumulative verification levels of increasing rigor. Level 1, per the ASVS 5.0 documentation, "contains the minimum requirements to consider when securing an application and represents a critical starting point," covering roughly 20% of all requirements and aimed at being achievable even without full code or documentation access. Level 2, intended for most applications handling sensitive data, adds further requirements so that L1+L2 together cover roughly 70% of the standard. Level 3 adds the final tier, generally described as defense-in-depth mechanisms and other controls that are useful but harder to implement, for applications needing the highest assurance.
Is there an official ASVS certification?
No. OWASP does not run or endorse a certification program for ASVS compliance. The project's own assessment-and-certification documentation states explicitly that "any assurance, trust mark, or certification claiming ASVS compliance is not officially endorsed by OWASP," and that organisations offering assurance services based on ASVS should not claim an official OWASP certification. Any "ASVS certified" claim from a third party is a self-declared assessment, not an OWASP-issued credential.
How is ASVS different from the OWASP Top 10?
The OWASP Top 10 is an awareness document ranking the most critical categories of web application risk at a point in time, intended to be a starting conversation rather than an exhaustive checklist. ASVS is a verification standard: a long, versioned list of specific, individually testable requirements (identified like v5.0-V6.2.1) meant to be checked one by one during design, development or testing. A team typically uses the Top 10 to prioritise where to look first and ASVS to decide, in detail, whether what they built actually satisfies a given security control.
How is ASVS different from OWASP SAMM?
They sit at different altitudes. OWASP SAMM (see our [OWASP SAMM guide](/guides/owasp-samm/)) scores an organisation's software-development process maturity across five business functions, independent of any one application. ASVS instead defines requirements for a specific application's security controls and verifies whether that application meets them. A mature organisation typically uses SAMM to assess and improve how its SDLC operates, and ASVS as the concrete checklist applied to each application that SDLC produces.
Sources
- OWASP: Application Security Verification Standard (ASVS) project page
- OWASP ASVS: companion site (asvs.owasp.org)
- GitHub: OWASP/ASVS — source repository, version history, 5.0.0 release
- GitHub: OWASP/ASVS 5.0 — "What is the ASVS" chapter (levels, requirement counts)
- GitHub: OWASP/ASVS 5.0 — Assessment and Certification chapter (certification disclaimer)
- Creative Commons: Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license text
- GitHub: OWASP/ASVS 5.0 — chapter files V1–V17 (requirement text and levels)
- GitHub: OWASP/ASVS 5.0 — V6 Authentication chapter (default accounts, initial passwords, brute force)
- OWASP: Web Security Testing Guide (WSTG) project page
- ETSI EN 303 645 V3.1.3 (2024-09): Cyber Security for Consumer Internet of Things — provisions 5.1-1 and 5.1-5
About this guide
SoftWSP Firmware Security Desk
Covers the Firmware vulnerabilities & fixes cluster: 127 guides.

In this cluster
Questions about this page?
