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

Firmware vulnerabilities & fixes

OWASP DSOMM: the DevSecOps Maturity Model's dimensions and levels, explained

Last updated:

OWASP DSOMM (the DevSecOps Maturity Model) is a free, self-assessment framework that scores an organisation's actual security practices across 6 dimensions, 24 sub-dimensions and 252 individual activities, each rated on a 5-level maturity scale from "basic understanding" to "advanced deployment at scale." Rather than a pass/fail checklist, a team marks which specific activities it performs — from centralised build logging to sandboxing AI coding agents — and gets back a heatmap of where its real security gaps sit, pulled directly from the model's own public YAML source rather than a marketing summary. The model is maintained as an OWASP community project and, as of August 2026, added a dedicated sixth dimension specifically for the security of AI-assisted development workflows.

Key takeaways

  • Uneven security work that a single maturity score hides.
  • As 6 dimensions holding 24 sub-dimensions.
  • Mostly in the middle.
  • A named risk, a measure, and often an assessment checklist.

What problem does DSOMM solve?

Uneven security work that a single maturity score hides. A team might have excellent static analysis but no patch-management process, or strong logging but no incident-response hook. DSOMM breaks "security maturity" into many small, independently assessable activities, organised into a matrix so a team can see which areas are strong and which sit at level 1, rather than averaging everything into one misleading number. The model is designed to be tracked over time alongside the pipeline it describes: the application's README recommends "a gitops-like flow," where a team's implementation state is itself version-controlled.

How are the 6 dimensions and their sub-dimensions organised?

As 6 dimensions holding 24 sub-dimensions. Cloning the model's source repository for this guide confirmed the current structure (dimension → sub-dimensions):

Dimension Sub-dimensions
Agentic AI (added August 2026) Isolation · Guidance · Data Protection · Verification
Build and Deployment Build · Deployment · Patch Management
Culture and Organization Design · Education and Guidance · Process
Implementation Application Hardening · Development and Source Control · Identity and Access Management · Infrastructure Hardening
Information Gathering Logging · Monitoring · Test KPI
Test and Verification Application Tests · Consolidation · Dynamic Depth for Applications · Dynamic Depth for Infrastructure · Static Depth for Applications · Static Depth for Infrastructure · Test Intensity

Per the Culture and Organization dimension's own description in its source file, that dimension "is about enhancing the security culture within an organization," with its Design sub-dimension covering "managing architectural risks for the software solution" and Education and Guidance covering "education and guidance of all stakeholders." Each sub-dimension is a single YAML file holding its activities. The project's architecture documentation states the generator "fails on duplicate uuids and duplicate activity names" and "fails on missing uuid or level," so every published activity carries a unique identifier and a maturity level.

How are the activities spread across the five levels?

Mostly in the middle. In the last released model, version 5.0.2 (published 17 September 2026), 155 of 251 activities sit at level 2 or 3:

Dimension Activities L1 L2 L3 L4 L5
Agentic AI 40 2 15 12 8 3
Build and Deployment 29 6 11 6 4 2
Culture and Organization 28 4 7 10 5 2
Implementation 55 8 15 17 10 5
Information Gathering 31 4 8 11 5 3
Test and Verification 68 5 19 24 11 9
Total 251 29 75 80 43 24

Source: the DSOMM data model published in the DevSecOps-MaturityModel-data project, version 5.0.2, counted 12 November 2026.

The source YAML on the main branch has one more, giving the 252 used elsewhere in this guide: "Minimum release age," a level-2 Patch Management activity added on 21 September 2026. Only 29 activities are level 1, so the floor of the model is small enough to finish before the bulk of the work at levels 2 and 3. The Agentic AI dimension has just 2 level-1 activities, which makes it the quickest dimension to start.

What does one activity actually look like?

A named risk, a measure, and often an assessment checklist. Here is the first activity under the Agentic AI dimension's Isolation sub-dimension, quoted from its source YAML:

  • Activity: "Usage of sandboxing for AI agents" (level 1)
  • Risk, as stated: "An AI agent may be manipulated (e.g. via prompt injection in source code, issues, dependencies or web content) or may malfunction. Without isolation, it can read secrets, modify unrelated projects, exfiltrate data or damage the developer workstation and connected systems."
  • Measure, as stated: "Run AI agents and AI coding assistants with command execution capabilities in a dedicated, least-privilege sandbox (e.g. a container or virtual machine) which contains only the required project files and is destroyed after use."
  • Assessment, as stated: demonstrating the sandbox configuration, a live session running inside it, that no credentials are reachable from inside the environment, and that the environment is destroyed after the task finishes.
  • Cross-references: the activity maps to OWASP SAMM v2 control I-SB-A-2 and ISO/IEC 27001:2022 control 8.31, alongside several named implementation guides.

All 251 released activities carry a risk and a measure. The assessment checklist is optional in the schema, and 78 of the 251 include one; older activities such as "SBOM of components" have none, so the assessor writes their own evidence test. Each activity also rates difficultyOfImplementation (knowledge, time, resources) and usefulness from 1 to 5, and lists dependsOn prerequisites by uuid. The generated dependency tree shows, for example, that "SBOM of components," "Pinning of artifacts" and "Signing of code" all depend on "Defined build process."

Which activities matter most for a firmware build?

The Build, Deployment and Patch Management activities, plus the secrets tests. DSOMM's wording is written for containers and web services, so each needs a firmware reading:

Activity (level) Sub-dimension Firmware reading
Defined build process (1) Build The image build runs from a codified pipeline (Yocto, Buildroot or vendor SDK), not a developer laptop
Inventory of production components (1) Deployment A list of every product and firmware version in the field, with owner and last review date
Test for stored secrets in build artifacts (1) Static depth for infrastructure Scan the image itself, not only the repository, for keys and passwords
Automated PRs for patches (1) Patch Management Update PRs for layers, packages and toolchains
Building and testing of artifacts in virtualized environments (2) Build A fresh build container per job; "the filesystem should not be used again in other builds"
Pinning of artifacts (2) Build DSOMM's example is a Docker digest; for firmware, pinned layer revisions and source checksums
SBOM of components (2) Build An SBOM generated for each image at build time
Minimum release age (2) Patch Management Three to seven days, via Renovate minimumReleaseAge or Dependabot cooldown, with an exception path for urgent fixes
Signing of code (3) Build Signed commits
Inventory of production dependencies (3) Deployment Which shipped version contains which dependency
Same artifact for environments (4) Deployment The image that passed testing is the image that is released
Signing of artifacts (5) Build Every build artifact signed

The last row is where firmware and DSOMM diverge. A device with secure boot or signed over-the-air updates needs a signed image before it ships, whatever level DSOMM gives artifact signing. Treat level as DSOMM's view of web-pipeline maturity, not as your release priority. The pipeline attacks these activities defend against are catalogued in the OWASP Top 10 CI/CD Security Risks.

Why does a device/firmware security site care about an "Agentic AI" dimension?

Because AI coding assistants and agents now write part of most firmware, and DSOMM's maintainers added a dimension for that risk rather than leaving it implicit. The dimension's own description states it "addresses the secure usage of AI during software development and operations, as well as the security of AI-assisted engineering workflows." Its four sub-dimensions map onto concrete controls: sandboxing agent execution (Isolation), secure-coding rules an assistant must follow (Guidance), keeping secrets and embedded keys out of AI tools (Data Protection), and reviewing AI-generated code and specifications before they ship (Verification). It deliberately does not duplicate static and dynamic testing covered elsewhere: the architecture notes say SAST and DAST "stay in Test and Verification" and AI activities reference them through dependsOn.

How do you run an assessment and keep it in Git?

Run the application locally and store the state in files. The README gives a one-line Docker start (wurstbrot/dsomm:latest on port 8080) and shows how to mount a custom meta.yaml for your teams and a custom model.yaml. The public site at dsomm.owasp.org stores its heatmap state in the browser's localStorage, which is fine for a first look and poor as a record.

For a lasting record, the README's team mode marks each activity per team with teamsImplemented and attaches teamsEvidence in Markdown, such as a link to a pentest ticket. The architecture notes say assessment state "is not maintained in the model source," and activity uuids are stable "to track assessment state across model updates." Keep your team file in the same repository as the pipeline, review changes like code, and the heatmap survives a model upgrade.

How does DSOMM compare with OWASP SAMM?

It works at a finer grain. SAMM scores a whole software security program; DSOMM scores the pipeline activities underneath it:

OWASP DSOMM OWASP SAMM
Unit measured Individual pipeline/tooling activities Organisation-wide practice areas
Structure 6 dimensions → 24 sub-dimensions → 252 activities, 5 levels 5 business functions → 15 practices → 2 streams, 3 levels
Typical use Week-to-week CI/CD backlog, tracked in-repo Periodic program self-assessment, reported to leadership
Format Interactive web matrix + YAML, GitOps-trackable Self-scoring spreadsheet/toolkit

The two are not competitors. Every DSOMM activity cites SAMM v2 stream IDs, so results roll up. See OWASP SAMM, explained for the program-level model, and NIST SSDF if a customer asks for a secure-development attestation.

Worked example: what does a first assessment look like for a router team?

Synthetic example, not a real product. A twelve-person team ships OpenWrt-based router firmware from GitLab CI. It runs DSOMM in Docker with a meta.yaml holding one team, and marks only what it can show evidence for:

  1. Build"Defined build process" is met. "SBOM of components" is partly met: an SBOM exists for the release image but not for the bootloader. Marked unmet, with a ticket as evidence.
  2. Deployment"Inventory of production components" is met by the support team's model and version list.
  3. Static depth for infrastructure"Test for stored secrets in build artifacts" is unmet: the repository is scanned, the image is not. A test key turns up in the first image scan.
  4. Patch ManagementRenovate already opens PRs; the team adds a five-day waiting period.
  5. Agentic AIDevelopers use a coding assistant with shell access on their laptops. "Usage of sandboxing for AI agents" is unmet, and moves to the top of the backlog.

The team commits the result next to .gitlab-ci.yml and schedules a re-run each quarter.

Where should a device or firmware team start, and what are the pitfalls?

  1. Assess your actual pipeline, not your target stateThe heatmap is only useful if the marked activities are implemented today.
  2. Treat level 1 as the floor, not the goalThe model's own level-1 label is "basic understanding of security practices."
  3. If your team uses AI coding assistants or agents, assess the Agentic AI dimension earlyIt is the newest part of the model and the least likely to be covered.
  4. Re-run on a cadence and keep the result in version control, so the trend drives prioritisation, not a single snapshot.

Common pitfalls:

  • Marking an activity done without evidence. Use teamsEvidence; an auditor will ask.
  • Reading DSOMM levels as firmware priorities, as with artifact signing above.
  • Leaving the assessment in one browser's localStorage.
  • Pinning a model version and never reading the changelog. Version 5.0.0 was a breaking change.

SoftWSP produces some of the evidence these activities ask for, on the shipped binary rather than the pipeline. It extracts a CycloneDX 1.6 SBOM from the firmware image, matches the components against NVD, CISA KEV, FIRST EPSS and CISA CSAF ICS advisories, and drafts a cited report that an engineer reviews; watchlist alerts flag new CVEs on a CVE ID, vendor or product. It does not score DSOMM or check pipeline settings; your team does that. See device firmware security and the firmware SBOM guide.

This guide is based on a direct read of the OWASP DevSecOps Maturity Model's own public source — the devsecopsmaturitymodel/DevSecOps-MaturityModel-data GitHub repository (cloned for this guide on 12 November 2026 to confirm dimension names, sub-dimensions and activity counts), its architecture documentation, generated model, level configuration and changelog, plus the application README, the project's OWASP page and public site — rather than a secondary summary. Activity counts reflect the model as fetched and will change as the project is updated; this guide is general information, not a substitute for running the live assessment against your own pipeline.

Put this guide to work

Frequently asked questions

What is OWASP DSOMM?

The DevSecOps Maturity Model, an OWASP project (listed on OWASP's own project page as a Lab-stage project) that lets a team self-assess and prioritise security activity across its software development and operations pipeline. Unlike a yes/no checklist, DSOMM breaks security work into a matrix of dimensions, sub-dimensions and individual activities, each assigned a maturity level from 1 to 5 — a team marks which activities it actually performs and gets back a visual heatmap of where its real gaps are. It is maintained as an OWASP community project, originally created by Timo Pagel, with the model's source data and application now hosted under the `devsecopsmaturitymodel` GitHub organisation and published at dsomm.owasp.org.

How is the DSOMM model actually structured?

As a three-level hierarchy, confirmed directly from the model's own source repository (`DevSecOps-MaturityModel-data` on GitHub): a **dimension** (a broad area, e.g. "Build and Deployment"), containing one or more **sub-dimensions** (e.g. "Build", "Deployment", "Patch Management"), each containing named **activities** (e.g. "Defined build process"). Each activity carries, per the project's own `ARCHITECTURE.md`, a unique ID, a description, a stated risk, a measure, an assessment procedure, a difficulty rating (knowledge/time/resources), a maturity level, and cross-references to standards such as OWASP SAMM v2 and ISO/IEC 27001. Cloning the data repository directly for this guide counted 252 individual activities across the current model — a living, versioned number that changes release to release, not a fixed count like a published standard's clause list.

What do DSOMM's 5 maturity levels mean?

Per the level definitions in the DSOMM data model, the five levels are labelled: Level 1, "Basic understanding of security practices"; Level 2, "Adoption of basic security practices"; Level 3, "High adoption of security practices"; Level 4, "Very high adoption of security practices"; and Level 5, "Advanced deployment of security practices at scale." Not every sub-dimension defines all 5 levels — a level is only included where the project judges it relevant and meaningful for that specific topic, so a sub-dimension might stop at level 3 rather than force-fitting activities up to level 5.

What is DSOMM's new Agentic AI dimension, and why was it added?

A sixth dimension, added as an explicit breaking change in the data repository's v5.0.0 release on 18 August 2026 (GitHub issue/PR #80, titled simply "add agentic AI"). Per the dimension's own description in the source YAML, it "addresses the secure usage of AI during software development and operations, as well as the security of AI-assisted engineering workflows," split into four sub-dimensions: Isolation (containing AI agents and AI-generated code in restricted environments), Guidance (secure coding rules and policies for AI-assisted development), Data Protection (preventing sensitive-data leakage through AI tools, including prompt-injection-style input/output validation), and Verification (checking AI-generated specifications, plans and code — explicitly without duplicating SAST/DAST activities already covered by the Test and Verification dimension). This is a live, dated example of a widely used open security framework adding a dedicated section for AI-assisted coding risk, not a speculative or marketing claim.

How does DSOMM differ from OWASP SAMM?

Both are OWASP maturity models, but they measure different things at a different grain. OWASP SAMM scores an organisation's overall software security *program* across 5 business functions and 15 practices, each with 2 streams and 3 levels — a strategic, governance-level self-assessment. DSOMM scores the *pipeline and tooling* directly: 6 dimensions, 24 sub-dimensions and (currently) 252 individual, tool- and practice-level activities across 5 levels, each with its own risk, measure and assessment text, intended to be tracked activity-by-activity in a GitOps-style workflow alongside the code it governs. A team can reasonably run both: SAMM to report program maturity upward to leadership, DSOMM to drive the week-to-week backlog of what to actually implement next in CI/CD.

Is DSOMM free to use, and is it an officially maintained standard?

Yes to free; DSOMM's own GitHub repository states the code is GNU General Public License v3 and the model content is Attribution-ShareAlike, usable by anyone at no cost via the public site or a self-hosted Docker container. On maintenance status: it is an active OWASP community (Lab) project rather than a formally ratified standard like an ISO or IEC document — the model is intentionally versioned and updated (the project's changelog shows multiple releases through 2026, including the Agentic AI addition), so a team adopting it should expect the activity set to keep evolving rather than treat any one snapshot as final.

Sources

  1. OWASP: DevSecOps Maturity Model (project page — license, maintainers, status)
  2. DSOMM live application and documentation
  3. GitHub: devsecopsmaturitymodel/DevSecOps-MaturityModel-data — README
  4. GitHub: DevSecOps-MaturityModel-data — architecture documentation (model structure: dimension/sub-dimension/activity fields)
  5. GitHub: DevSecOps-MaturityModel-data — maturity level configuration (level labels)
  6. GitHub: DevSecOps-MaturityModel-data — Agentic AI dimension source files (Isolation sub-dimension and dimension metadata)
  7. GitHub: DevSecOps-MaturityModel-data — release changelog (v5.0.0 Agentic AI release, 2026-08-18)
Was this guide helpful?

In this cluster

OWASP DSOMM: the DevSecOps Maturity Model's dimensions and levels, explained