Engineer working on a laptop connected to a device test rig, surrounded by wiring harnesses and test hardware

Firmware vulnerabilities & fixes

OWASP ASVS: the Application Security Verification Standard, explained

Last updated:

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. Verify and recordResults go into a sheet keyed by v5.0.0- identifiers. Two failures: the API accepts GET for a restart action (3.5.3) and the release build still answers a debug endpoint (13.4.2).
  6. 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.2 stays 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?

  1. 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.
  2. Cite requirement IDs, not summaries, in internal tickets and vendor contractsThe v5.0.0-x.y.z identifiers exist so a specific control can be unambiguously referenced and re-checked after a code change.
  3. Verify any third-party "ASVS certified" claim against the actual assessment method used, since OWASP itself does not issue or endorse certifications.
  4. 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

  1. OWASP: Application Security Verification Standard (ASVS) project page
  2. OWASP ASVS: companion site (asvs.owasp.org)
  3. GitHub: OWASP/ASVS — source repository, version history, 5.0.0 release
  4. GitHub: OWASP/ASVS 5.0 — "What is the ASVS" chapter (levels, requirement counts)
  5. GitHub: OWASP/ASVS 5.0 — Assessment and Certification chapter (certification disclaimer)
  6. Creative Commons: Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license text
  7. GitHub: OWASP/ASVS 5.0 — chapter files V1–V17 (requirement text and levels)
  8. GitHub: OWASP/ASVS 5.0 — V6 Authentication chapter (default accounts, initial passwords, brute force)
  9. OWASP: Web Security Testing Guide (WSTG) project page
  10. ETSI EN 303 645 V3.1.3 (2024-09): Cyber Security for Consumer Internet of Things — provisions 5.1-1 and 5.1-5
Was this guide helpful?

In this cluster

OWASP ASVS: the Application Security Verification Standard, explained