Onam
Code Security

Which of the problems in this repository actually need fixing first?

Scan the code, the dependencies and the running app — and see the real issues first.

Onam Code Security runs static analysis, dependency and SBOM analysis, IaC checks, secret detection and dynamic testing against your repositories and web apps — and keeps findings it can confirm apart from the ones a person needs to review.

413
SAST security rules
9
languages scanned
8
dependency ecosystems
479
DAST test payloads
Illustration: a code repository scanned by four checks — static analysis, dependencies, secrets and infrastructure files. Static-analysis findings go to AI Code Fix, which puts corrected files on a separate branch that a developer reviews before merging; the other findings go to a findings board.
Illustration. AI Code Fix covers static-analysis findings and is run with you on request; nothing merges without your review.
Why this matters

The first scan of a mature repository returns a wall of findings, and most of them are pattern matches nobody can act on without reading the code.

The one real injection flaw is in there somewhere, ranked next to a hundred hotspots with the same severity. The dependency report is no better: sorted by CVSS, it puts a theoretical 9.8 above a medium-rated bug that attackers are exploiting this week. The team triages for a day, fixes nothing important, and stops opening the report.

The cost of a noisy scanner

When every pattern match is reported as an alert, the real injection flaw sits on page four. Teams stop reading the report, and the scanner becomes a compliance checkbox instead of a control.

Confirmed issues first, hotspots kept separate
Watch

Code Security in two minutes

Voices are AI-generated. More short Q&A videos: Onam Security: cloud security

How does it actually work?

The mechanism, not the marketing

  1. 1

    You give Onam a repository's HTTPS address and a branch — GitHub, GitLab or Bitbucket — and, if you want dynamic testing, the URL of a running app you are authorised to test. Each scan runs as its own isolated job against a shallow clone of that branch, and the clone is deleted when the scan ends.

  2. 2

    Static analysis runs on the open-source Semgrep engine with three rule sources: community security packs (OWASP Top 10, security audit, secrets, Node.js), Onam-curated taint rules that follow untrusted input to a dangerous call, and Onam-reviewed pattern rules. Pattern rules that were judged code-quality rather than security are dropped before a scan runs.

  3. 3

    Every result is graded by how much the rule can prove. Taint and AST matches become Security issues and keep the severity the rule asserts; pattern matches become Hotspots to review, capped at medium, so they can never outrank a confirmed flaw. Each finding carries the file, line, rule, CWE and OWASP category.

  4. 4

    Dependency analysis reads manifests and lockfiles itself, matches each component against OSV and NVD advisories, adds EPSS exploit probability and CISA KEV membership, and turns them into a single 0–10 risk score. The same pass produces a CycloneDX 1.5 SBOM for the repository.

  5. 5

    IaC templates and Dockerfiles in the same clone are checked in the same scan, and secret rules run over every file. If you gave a target URL, dynamic testing discovers the app's endpoints and sends rate-limited test payloads at them.

  6. 6

    Results land in the Code Security console — projects, alerts, scan history, per-scanner tabs and trend reports — and static and dynamic scan results also feed the AppSec pillar of the platform's CNAPP posture score, next to your cloud posture.

What do you actually get?

Specific outputs, measurable outcomes

Confirmed issues kept apart from hotspots
taint-backed findings first, pattern matches in a separate review list capped at medium
CWE and OWASP on every code finding
with the file, line and rule that produced it
Coverage for mainstream languages
Python, JavaScript, TypeScript, Java, C#, Go, C, C++ and Ruby
Dependency risk beyond CVSS
a 0–10 score built from CVSS, EPSS, CISA KEV and whether a fixed version exists
A CycloneDX 1.5 SBOM per repository
and import of existing CycloneDX or SPDX JSON SBOMs
SBOM governance
license classification and policy checks, an NTIA minimum-elements check, VEX statements and SBOM diffs
Dynamic testing of a running app
endpoint discovery, injection and SSRF payloads, header and cookie checks, JSON, HTML and SARIF reports
A fix path for every finding
rule guidance and a copyable AI fix prompt, plus AI Code Fix to put corrected files on a branch
Reports and trends
scan history per project, with CSV and PDF export
From repository to reviewed fix

One scan, five scanners, one place to read the result

Static analysis, dependency analysis and IaC checks run together on every repository scan. Dynamic testing joins in when you give it a URL. Fixes come back as a branch, never as a merge.

Repository and optional target URL feed one scan job running SAST and secrets, SCA and SBOM, IaC and Dockerfile checks, and DAST; results are triaged into security issues, hotspots, dependency risk and runtime findings, then shown in the console, the posture score, an AI fix prompt and AI Code Fix branches
How a code scan flows. Each scan is an isolated job; the clone is deleted when it ends.
In the console

The proven findings come first

A scan result opens on four numbers — total findings, security issues, hotspots to review and the languages found — then the security issues table, with file and line for each. Hotspots have their own panel. Every finding opens to the rule's guidance and an AI fix prompt you can copy.

Around it: a projects view with a risk score per repository, an alerts list across SAST, DAST and SCA, scan history, and trend reports you can export as CSV or PDF.

Illustrative layout of a scan result: summary tiles for total findings, security issues, hotspots and languages, a security findings table, and a finding detail with a copyable AI fix prompt
Illustrative — a stylised view of the layout, not a screenshot. Repository names and findings are invented.
Code and cloud

What is joined today, and what is not yet

Code security lives in the same platform as Onam's cloud posture, identity and data engines. Here is exactly how far that connection goes today.

Joined today
  • Code findings sit in the same platform, under the same login and roles, as your cloud findings
  • SAST and DAST results feed the AppSec pillar of the CNAPP posture score
  • Dependency advisories come from the same OSV and NVD store the vulnerability engine uses
  • Static-analysis findings also appear in the platform-wide findings store, tagged as code
Not yet
  • Linking a code finding to the container image or workload built from that repository
  • Reachability — whether the vulnerable function in a dependency is actually called
  • Tracing a runtime misconfiguration back to the template line that created it

Full detail is in the Code Security documentation.

One-page overview

Code security on one page

Inputs, how it works, what you get and the limits — the same sheet our team uses in briefings.

Download (PNG)
Code security one-page overview: inputs, how it works, what you get, outcomes and limits. Open full size
FAQ

Questions we get a lot

Python, JavaScript, TypeScript, Java, C#, Go, C, C++ and Ruby. Depth varies by language: Python, JavaScript/TypeScript, Java, C#, Go and Ruby have Onam-curated taint rules as well as community and pattern rules; C and C++ rely on community and pattern rules, so expect more of their results in the hotspot list. Other languages are not analysed today.
Ready to see it live

Ready to see Code Security on your code?

Point us at a repository and a test URL. We will run the scan with you and walk your team through what it found.