Skip to content

Security findings with a deadline and owner

Security Testing · SAST, SCA and software supply chain

Analysis of your repository code, dependencies, secrets and licenses on an isolated runner. Results from different scanners become a single queue, grouped and prioritized by evidence, with an SBOM per commit to answer where a package is used, EPSS and KEV to see what is being exploited, exceptions decided by two people with an expiry date, and room for the SARIF and SBOM output of the tools your team already uses.

The problem

What this product solves

Every scanner has its own format, its own severity scale and its own screen. The team ends up watching one and ignoring the rest.

The same problem appears dozens of times, in tests, examples and docs, and hides what is in the code that ships to production.

Exceptions approved "for now" become permanent because nobody writes down the reason or the deadline. And when a new flaw hits a popular package, nobody can say where it is used.

updated

Who uses it, and for what

Typical profiles, no customer names. Each use carries the status of the feature behind it.

  • Security team at a fintechBring code flaws, vulnerabilities and licenses into one queue, with priority, owner and deadline.Scanner Orchestration
  • Platform teamAnswer where the organization uses a package or a vulnerable version, from the stored SBOMs.Supply Chain Security
  • Engineering leadershipKnow which vulnerable dependencies are open, which exceptions are expiring and why they were approved.SCA

Features

What the product does

Self-service: add it from your account.

  • SAST

    Static code analysis on the isolated runner when a scan requests `sast`: OpenGrep engine (LGPL-2.1) with AIUBY-written rules for JavaScript/TypeScript, Python and Go plus rules for Kotlin, PHP, Ruby, Rust, Swift and Groovy (SQL and command injection, eval, XSS, disabled TLS verification, unsafe deserialization, weak hashes, debug mode). Organization rules (structural patterns, no regex), on-demand AI analysis with every finding checked against the file and short lessons per CWE. Findings carry file, line, severity and CWE, in the same triage, waivers and gate as the other scanners. No cross-function or cross-file data flow; test, vendor and node_modules folders are skipped.

  • SCA

    Direct and transitive dependencies, vulnerabilities and licenses (OSV and Trivy on the isolated runner), secrets via gitleaks and base image detection in registry scans.

  • Supply Chain Security

    CycloneDX SBOM generated on the isolated runner for each scan requested with SBOM or uploaded from elsewhere (CycloneDX or SPDX), components per repository and commit, SBOM diff, package, purl or CVE search across all repositories (zero-day response), organization license policy with violations in triage, CycloneDX and SPDX export, scan provenance attestation and AI-BOM. On-demand watch: new OSV advisories, unmaintained dependencies via deps.dev and repository and CI posture on GitHub. The attestation is unsigned and there is no SLSA build provenance.

  • Scanner Orchestration

    Multiple scanners, normalized findings, expiring waivers and evidence. Scans requested from the app, API v1, the MCP tool and CI, with a dedicated key scope. Repeated findings become one group, prioritized only by scanner evidence (tests, docs and examples rank lower), with triage suggestions from a path rule or, optionally, AI, which only become waivers when a person accepts them, and version-bump proposals for review (nothing is applied).

  • Finding Risk

    The same issue seen by different scanners correlated by CVE and counted once in the gate; two-person waivers and severity reductions (requesters cannot approve); FIRST EPSS and the CISA KEV catalog on findings and in the CI gate, where KEV fails even with an approved waiver and CVEs without a recent lookup fail.

  • External Findings

    Findings from other tools in the same triage: SARIF 2.1.0 from any scanner, external SBOMs in CycloneDX or SPDX and AI model files (pickle or PyTorch) read without executing, with a verdict based on what they would import. From the app or API v1 with a security:write key; imports do not count as scans in the gate.

  • Application DAST

    Passive web application scanning with ZAP on an isolated runner, only against Test Automation targets with verified ownership, with minute and per-hour caps; results return with a single-use token into the same triage as the other scanners. No active scanning.

  • Security Governance

    Owner and due date per finding with an overdue queue, weekly trend by severity, a technical compliance report with evidence and gaps, Jira-format webhooks to open issues from findings and a hardened base image check on Dockerfiles.

How it works

From start to audit record

  1. Request

    A person with permission requests a scan of a GitHub repository and picks the scanners. SAST and SBOM run when they are selected.

  2. Isolated runner

    Scanners run in a disposable container outside the platform, with no access to production, a fixed configuration and a time limit.

  3. Code and dependencies

    SAST flags code flaws with file, line and CWE. OSV and Trivy flag dependency vulnerabilities and licenses.

  4. SBOM and licenses

    The commit SBOM is stored, feeds the "where do we use it" search and goes through the organization license policy.

  5. Triage

    The result comes back signed, is normalized into a single format and is grouped and prioritized from P1 to P4 using only the scanner evidence.

  6. Decision

    Each group is fixed or gets an exception with a justification and an expiry. The policy gate counts only what is open.

Features

Feature by feature

What each one does, how it works, an example from the documentation and what it does not do. Each badge comes from the catalog.

SAST

Flaws in your code flagged with file, line and CWE

SAST looks for flaws in the repository's own code, not in its dependencies. It runs in the same isolated executor as the other scanners when the scan requests the sast scanner, and its findings go into the same list, the same triage, the same exceptions and the same scan.gate.

The engine is OpenGrep, with rules written by AIUBY for JavaScript and TypeScript (including JSX and TSX), Python and Go, and rules for Kotlin, PHP, Ruby, Rust, Swift and Groovy: SQL and command injection, eval with dynamic values, XSS, TLS without verification, insecure deserialization, weak hashing and debug configuration. The organization can add its own rules, and an AI analysis, requested separately, looks for what the rules miss.

How it works

  • Each finding carries rule, relative file, line, severity and CWE; the Type › Code (SAST) filter isolates these findings on screen.
  • Organization rules: up to 50, structural OpenGrep patterns only, with no regular expressions, applied alongside the AIUBY rules with the custom prefix.
  • On-demand AI analysis: the model reads up to 8 files with secrets redacted, and only what is checked against the file (the line exists and the quoted snippet is on it) becomes a finding.
  • A short lesson per CWE for open findings, in Portuguese (the flaw, how to fix it and how to test it), with a record of who completed it.
  • Nothing in the repository counts as configuration: ignore files and comments asking to skip a rule are disregarded, and code snippets never leave the container.
  • scan.gate counts open SAST findings by severity, and the same query is available through API v1 and the CLI.
Request the scan and read the findings Without the scanners field, the request runs gitleaks, trivy and osv.
# Session API: the sast scanner goes in the request
POST /api/platform/security/scans
{"repoId": "...", "scanners": ["gitleaks", "trivy", "osv", "sast"]}

# Code findings, through the CLI and API v1
aiuby security findings --tool sast
GET /api/v1/engineering/security/findings?tool=sast

What it does not do

  • Rules match patterns within an expression: there is no data flow analysis across functions and files, so there are false positives and false negatives.
  • AI analysis is not deterministic: it never closes a finding, and its model cost is metered by the Gateway.
  • Folders such as node_modules, vendor, build, dist, test and tests are excluded.
  • It does not fix the code: the fix belongs to a person or to Code Automation.

SCA

Vulnerable dependencies and problematic licenses in a single list

SCA analyzes the repository's dependencies: OSV and Trivy run in the isolated executor on a clone of the requested commit and flag known vulnerabilities and licenses, in direct and transitive dependencies. gitleaks runs in the same scan and looks for secrets left in the code.

The result comes back signed, is converted to a single format and goes into the workspace findings list, where each vulnerability shows the package, the severity and, when one exists, the published fixed version.

How it works

  • A person with permission requests the scan of a GitHub repository; private repositories are read with the workspace's own read-only Cortex token.
  • Scanners run with a fixed AIUBY configuration: any configuration in the repository is ignored.
  • A vulnerability with a published fixed version and a dependency declared in the manifest moves up in triage priority.
  • Findings and scans are available through API v1, with filters by status, severity, tool, category and repository, and through the MCP server.
  • Secrets found reach the platform masked.
  • In the artifact registry, Trivy also identifies the base image of each scanned image.
Through API v1 Findings from most to least severe; a scan returns its own findings.
# Base: https://aiuby.com/api/v1, key with the engineering:read scope
GET /engineering/security/findings?status=&severity=&tool=&category=&repoId=&cursor=&limit=
GET /engineering/security/scans?repoId=&cursor=&limit=
GET /engineering/security/scans/{id}

What it does not do

  • It reads GitHub repositories; other code hosts are not analyzed.
  • It does not assess exploitability: there is no reachability evidence or runtime exposure.
  • Triage cannot tell transitive dependencies apart when the scanner does not report it; lockfiles and images count as "cannot tell".
  • Registering an exception happens in the UI, with a person's session; through API v1, the key reads and, with the security:scan scope, requests scans.

Supply Chain Security

Find where the organization uses a package, in minutes

Supply Chain Security stores the SBOM, the list of software components, from every scan requested with SBOM and from SBOMs uploaded from outside, in CycloneDX or SPDX. With them, the platform shows the difference between two SBOMs, answers where a package, a purl or a CVE appears across all the organization's repositories, and applies the license policy, whose violations become findings in the same triage as the scanners.

On-demand monitoring of a repository checks the components of the latest SBOM against new OSV advisories, flags deprecated dependencies or ones inactive for two years through deps.dev, and reads the repository and CI posture on GitHub, such as unprotected branches or third-party actions without a pinned SHA.

How it works

  • Per component: name, version, purl, ecosystem, licenses, whether it is direct or transitive, and the vulnerabilities the SBOM flagged.
  • "Where do we use it" search by CVE, GHSA or PYSEC, by purl with or without version and by package name, over the latest SBOM of each repository's default ref.
  • License policy per organization: lists of forbidden, review and allowed licenses as SPDX ids, with prefixes such as AGPL-*; forbidden becomes a high-severity finding, review becomes medium.
  • Export in CycloneDX 1.5 and SPDX 2.3, a provenance attestation for a scan, and a workspace AI-BOM with the models and agents in use.
  • Workflows with pull_request_target, script injection and missing permissions become CI posture findings.
  • The same view is available through API v1, the CLI and the MCP server.
Through the CLI The search accepts, for example, CVE-2021-23337, pkg:npm/lodash@4.17.4 or lodash.
aiuby sbom get <repo>            # latest SBOM for the default ref (repo = owner/name or id); --format cyclonedx|spdx prints the document
aiuby sbom where <package|purl|cve>

What it does not do

  • The provenance attestation is a platform document, unsigned; there is no SLSA or in-toto build provenance.
  • A repository with no stored SBOM does not appear in the search, which does not mean it does not use the package.
  • Monitoring runs on request; a lookup that failed or exceeded the cap comes back incomplete and does not close findings.
  • SBOMs above 5,000 components are truncated and marked as truncated: a package missing from one proves nothing.

Scanner Orchestration

Findings from several scanners become one queue with owners and deadlines

Orchestration runs the scanners in an isolated executor, a disposable container outside the platform, receives the signed result and converts everything to a single format. Repeated findings become a group: the same problem across several files shows up only once.

Each group gets a priority from P1 to P4 based only on scanner evidence, and can get a triage suggestion and a version bump proposal. The suggestion changes nothing on its own: it only becomes an exception when a person accepts it, with a justification and a deadline.

How it works

  • A group is the same repository, ref scope, category, rule or CVE and package, in the same path class: code, test, documentation or example.
  • Priority adds up severity, published fixed version and dependency declared in the manifest; test, documentation or example paths move down and stay at P3 at most.
  • Triage suggestion from the path rule, with no AI; with AI on, the model receives a redacted excerpt of the file and must cite a file and line from the group itself, or the response is discarded.
  • Accepting a false positive or example registers an exception with an expiry of up to 180 days on each open finding in the group; once it expires, the finding counts again.
  • For a vulnerability with a fixed version, the proposal lays out the swap from the current package to the target and marks the risk (a major version change is high risk). Nothing is applied.
  • Scans can also be requested through API v1 and the aiuby_scan_request MCP tool, with a key scoped to security:scan, so CI can trigger analysis of the commit.
Triage suggestion and decision The suggestion changes nothing: the exception is only registered by a workspace admin's decision.
POST /api/platform/security/triage/suggestions
{ groupKey }

POST .../suggestions/{id}/decision
{ decision, reason, until? }

POST /api/platform/security/triage/proposals
{ groupKey }

POST /api/platform/security/triage/reassess
{ repoId }

What it does not do

  • It does not assess exploitability: there is no reachability evidence or runtime exposure, and the screen says so.
  • The platform does not apply the version bump proposal; it goes to a person for review.
  • AI suggestions are optional and limited to 30 per hour per workspace; without them, groups in code get no suggestion.
  • The context excerpt for AI only comes from GitHub repositories.

Finding Risk

The same CVE counts once, with EPSS and KEV

Finding risk combines what two scanners say about the same problem and adds the likelihood of exploitation. Trivy reports by CVE and OSV often by GHSA; each vulnerability with a package gets the canonical CVE and a correlation key, and the gate counts the group only once.

Exceptions and severity downgrades now take two people: one requests, with a reason and a deadline, and another, an admin, decides. FIRST EPSS and the CISA KEV catalog are queried for open CVEs and feed the CI gate as additional reasons to fail.

How it works

  • The requester cannot approve, enforced in the application and by a database rule; API keys can neither request nor decide.
  • Raising severity takes effect immediately; lowering it requires approval and a deadline, and stops applying if the scanner changes the severity.
  • Gate with epssAtLeast and kev=true: a CVE in the KEV catalog fails even with an approved exception or a downgraded severity.
  • An open CVE without a lookup in the last 7 days fails as missing data; a missing lookup never becomes a pass.
  • EPSS, KEV and the scanner's original severity appear on the finding, with the pending request and the approve and reject buttons.
  • Only CVE identifiers leave the platform for the public sources, at most one round per hour.
Pull request gate (GitHub Actions) A key with security:read only: even if leaked, it cannot request scans, register exceptions or read findings.
curl -sS --fail-with-body "https://aiuby.com/api/v1/engineering/security/gate?repo=${GITHUB_REPOSITORY}&failOn=high&kev=true&maxAgeDays=7" \
  -H "Authorization: Bearer $AIUBY_TOKEN" | tee gate.json | jq -e '.data.decision == "pass"'

What it does not do

  • EPSS and KEV only add reasons to fail: there is no "fail only if exploitable".
  • The gate reads the state of the default ref; the pull request scan is not compared with the base.
  • The approver is not notified: the request stays in the UI and the audit log.
  • There are no exceptions per package or per rule: requests are per finding and apply to its group.

External Findings

Results from other tools in the same queue and triage

External sources bring findings from tools the team uses outside AIUBY into the same list. A SARIF 2.1.0 file from any scanner becomes code findings; an external SBOM in CycloneDX or SPDX becomes the repository SBOM and feeds "where do we use it" and the license policy.

An AI model file (pickle or PyTorch) is read without executing anything: the platform lists what the model would import when loaded and gives a verdict. Everything comes in through the UI or API v1, with a key scoped to security:write, and goes through the same conversion, redaction and caps as the executor.

How it works

  • Each SARIF result is checked one by one, with text redacted and truncated and the path sanitized.
  • An SPDX SBOM becomes the same intermediate format as CycloneDX and goes through the same normalization.
  • Model verdict: malicious when it imports something that executes code or accesses the system, suspicious outside the known list, unknown when it did not read everything, and never safe without reading the whole file.
  • An import becomes its own record, which does not count as a scan in the gate, in coverage or as a scanned commit.
  • Input that exceeded the cap is marked as truncated and closes no findings.

Example use case

A team that runs its own code scanner in CI sends the SARIF from every build to AIUBY, and a vendor sends the SPDX SBOM for the component it delivered. The findings go into the same triage as the AIUBY scanners, with owner and deadline, and searching for a new CVE now includes the vendor component. Before publishing a model downloaded from the internet, the data team uploads the file and sees that it would import os.system when loaded.

What it does not do

  • Model files up to 25 MB, as pickle or PyTorch zip; safetensors is accepted as safe because it does not execute code.
  • AIUBY does not run the external tool: it trusts the uploaded file and only converts it.
  • An imported finding does not close on its own when it disappears from a truncated import.

Application DAST

Your web application scanned from the outside, with no active attack

Application DAST scans a web application with ZAP in passive mode: it browses the pages and checks what the responses reveal, such as missing security headers, unprotected cookies and exposed information, without sending attacks. The scan runs in an isolated cloud executor, outside the platform.

It only runs against a Test Automation target whose ownership was proven by a file the owner published, within the validity period. The request goes into a queue; the worker checks ownership again before dispatching, and the result comes back with a single-use token and becomes findings in the same triage.

How it works

  • Passive scan (ZAP baseline), with caps on minutes per scan and scans per hour.
  • Proof of ownership through the /.well-known/aiuby-test-automation.txt file on the target origin.
  • The platform database stores only the hash of the callback token.
  • Findings get the same triage, expiring exceptions and gate as the other scanners.

Example use case

Before launching the customer portal, the team registers the staging domain as a Test Automation target, publishes the ownership file and requests the scan. The result flags a session cookie without the Secure flag and a missing content security policy. After the fix, a new scan confirms the findings are gone.

What it does not do

  • It does not run active scans: it sends no attack payloads and does not test authentication.
  • It does not scan targets without proven ownership, or third-party domains.
  • It does not go behind a login: it scans what the application shows without credentials.

Security Governance

An owner, a deadline and a trend for every open finding

Security governance turns the findings list into work with someone accountable. Each finding can get an owner and a deadline of up to 365 days; the overdue queue shows what passed its deadline, and the weekly trend over up to 26 weeks shows open, new and fixed findings by severity.

The technical compliance report gathers, per repository, what was scanned and the exceptions in effect, separating what has evidence from what is a gap. Finding events can open Jira items through Jira Cloud automation, in the webhooks' own format.

How it works

  • Owner and deadline per finding, with the workspace overdue queue.
  • Weekly trend by severity: open, new and fixed.
  • Technical compliance report with evidence and gaps per control.
  • Webhook in Jira format, only for Atlassian automation over HTTPS, with no credentials in the URL.
  • Dockerfile check: a final image without a hardened base, or tagged latest or untagged, becomes a finding with a replacement suggestion.

Example use case

The security lead assigns the high findings to the service owners, with a 30-day deadline. Every Monday, the trend shows whether fixes outpace new findings, the overdue queue shows who fell behind, and each new critical finding becomes an item in the team's Jira. For the customer audit, the lead exports the technical compliance report.

What it does not do

  • The compliance report is not a certification or a legal opinion.
  • The Jira item state does not sync back to AIUBY.
  • The Dockerfile check does not pull the image or verify signatures.

AI and limits

What AI does here, and what it never does on its own

Does

  • Suggests a classification for a group of findings (likely false positive, example or test, real), with a justification that cites file and line from that group.
  • Receives only a redacted file excerpt, with no secrets or personal data, through the model gateway, with metered cost and the workspace policy.

Never does

  • Never records an exception: the suggestion only counts when a workspace admin accepts it, with a justification and a deadline.
  • Never applies a version bump or changes the repository: the fix proposal goes to review.
  • In AI code analysis, requested separately, only what is verified against the file becomes a finding, and the result never closes a finding. SAST rules and prioritization stay deterministic.

Governance and security

Rules the code enforces

  • The runner receives only variables and a time limit: it cannot change the image, CPU or service account.
  • Results are accepted only with a valid runner signature.
  • Scanner configuration is fixed: ignore files and comments in the repository do not turn rules off.
  • Exceptions require a justification and last up to 180 days. Once expired, the finding counts again. With finding risk enabled, whoever requests an exception or a severity downgrade cannot approve it.
  • A CVE in the KEV catalog fails the gate even with an approved exception.
  • The policy gate counts only open findings. A valid exception does not count.
  • Only admins of the whole organization change the license policy, and the change is recorded in the audit trail.
  • Discovered secrets arrive masked. The SAST code snippet never leaves the container.

Integrations

What it connects to

Only integrations that exist in the code. Each one carries the status of the feature that uses it.

  • GitHubThe analyzed repository, read at the requested commit.SCA
  • OSV and TrivyDependency vulnerabilities and licenses.SCA
  • gitleaksSecrets left behind in the repository.Scanner Orchestration
  • OpenGrepThe SAST engine, with rules written by AIUBY.SAST
  • CycloneDX and SPDXSBOM export formats.Supply Chain Security
  • Google Cloud Run JobsWhere the isolated runner executes each analysis.Scanner Orchestration
  • EPSS and KEVFIRST exploit probability and the CISA known exploited catalog, on the finding and in the gate.Finding Risk
  • SARIFResults from any code scanner imported into the same triage.External Findings
  • ZAPPassive web application scanning against a target with proven ownership.Application DAST
  • deps.dev and OSVDeprecated dependencies and new advisories for SBOM components.Supply Chain Security
  • JiraAn issue opened from a finding through a webhook in the Jira Cloud automation format.Security Governance
  • API v1 and CLIRead findings, scans and SBOMs with a scoped key.API, CLI & keys
  • MCP serverFindings, scans and SBOMs for coding assistants, read-only.MCP server

FAQ

Straight answers

What can I use today?

Available: SAST, SCA, Supply Chain Security, Scanner Orchestration, Finding Risk, External Findings, Application DAST, Security Governance. Self-service: add it from your account.

Does Security Testing do static analysis of my code (SAST)?

Available: SAST, External Findings. SAST uses the OpenGrep engine with rules written by AIUBY for JavaScript, TypeScript, Python and Go, plus Kotlin, PHP, Ruby, Rust, Swift and Groovy, and accepts the organization's own rules. It matches patterns within an expression, without data flow analysis across functions and files. An AI analysis, requested separately, looks for what the rules miss, and only what is verified in the file becomes a finding. If your team uses another code scanner, its SARIF goes into the same triage.

Does my code leave my GitHub account? Do I need to install a scanner?

Available: SCA, Scanner Orchestration. The code leaves temporarily, and there is nothing to install. The runner downloads the repository into a disposable container, runs the scanners, and the container is deleted at the end. Only normalized findings come back to the platform, with secrets masked. The SAST code snippet never leaves the container.

Does it work with GitLab or Bitbucket?

Available: External Findings. AIUBY scanners read GitHub repositories. If your code lives on another platform, results from the scanners that run there come in through SARIF, and the SBOM comes in as CycloneDX or SPDX, into the same triage.

Does it generate an SBOM? What about provenance attestation (SLSA)?

Available: Supply Chain Security. SBOM, yes: CycloneDX generated on the runner for every scan requested with SBOM, or uploaded from outside as CycloneDX or SPDX, with export in both formats, diffs between SBOMs and search by package, purl or CVE across all repositories. There is a scan provenance attestation, but it is not signed, and there is no SLSA or in-toto build provenance.

Does AI decide on its own what is a false positive?

Available: Scanner Orchestration. No. Priority comes only from scanner evidence. The triage suggestion comes from a path rule or, optionally, from a model that receives a redacted excerpt, and it only becomes an exception when a person accepts it, with a justification and a deadline. The version bump proposal is not applied either: it goes to review.

How do I know which vulnerabilities are being exploited?

Available: Finding Risk. Through EPSS, the exploit probability published by FIRST, and the CISA KEV catalog, looked up for open CVEs and shown on the finding. In the CI gate, epssAtLeast and kev=true add reasons to fail. A CVE in KEV fails even with an approved exception, and a CVE without a recent lookup fails too.

How much does it cost?

Available: SAST, SCA, Supply Chain Security, Scanner Orchestration. Pricing is on the Pricing page. AI code analysis has a model cost, metered by the Gateway and drawn from the prepaid balance.

Works together with

  • Developer PortalService scorecards check whether there is an open security finding in the service repositories.
  • AI EngineeringAI triage suggestions go through the same model gateway, with metered cost and workspace policy.
  • Resilience TestingVulnerability findings count toward the service risk score.

Security Testing

Self-service: add it from your account.