Nullgap.dev Docs

Security and privacy

How your code is handled

Where your source code goes during a review or a pentest, what Nullgap stores afterwards, what it never stores, and who can see it.

This page follows your code through a run: how Nullgap gets it, where it sits while the run works, what is left afterwards, and who can read what.

The short version, which Nullgap also publishes at GET /api/trust without sign-in:

curl -s "$NULLGAP_URL/api/trust"
StoredNever stored
Findings, with the line of code each one refers to and its explanationThe prompts sent to the AI
The threat model and project rules you write or approveThe raw responses from the AI
Review and pentest status and logsYour repository: it is checked out for a run and deleted when the run ends
Reports generated from a pentestCredentials found in your code: they are masked before storage
An audit log of changes made in your organisation
Account, membership and billing records

The rest of this page explains each line and its limits.

#How your code is fetched

Nullgap reads code through the connection you set up for the code host, with the access that connection grants. See connecting your code.

RunWhat is fetched
Pull request reviewThe pull request's changes from the code host, and a checkout of the repository at the pull request's head commit
Pentest, retestA checkout at the branch, tag or commit you chose
Pentest estimateA checkout, to count lines. Nothing else is read
Fix runA checkout at the branch the fix is based on
Building or regenerating a threat modelA checkout of the default branch

Each run makes its own fresh checkout. Runs do not share working copies, and a checkout is never reused for another organisation.

A repository added by its public address is fetched the way anyone could fetch it. Uploaded archives are covered below.

#Where it lives during a run

The checkout is written to a temporary directory on the service's scratch storage. It is deleted when the run ends, whether the run succeeded, failed or was cancelled.

While the run works:

  • Nullgap AI reads the parts of the code the run needs. What is sent for AI processing, and how it is protected, is on AI processing.
  • Proofs and fix verification run commands against a working copy inside the sandbox.
  • Nothing from the checkout is written to the database except what is listed in the next section.

One limit to know: if the service is stopped abruptly in the middle of a run, that run's working copy is not cleaned up by the run itself. It stays on the service's scratch storage until that storage is cleared.

#What is stored afterwards

#Findings

A finding stores what is needed to understand and fix it: its title, severity and explanation, the file and line it refers to, the excerpt of code at that place, its evidence, and its proof record if it was proven. See reading a finding and proof.

Before an excerpt is stored, values that look like credentials are masked, so a key that was sitting in your code is not copied into a finding or a report. See credentials in your code.

#Run records and logs

A review or pentest record holds its status, timings, the commit it ran on, and for a review the pull request's number, title, description and author login. Its log holds progress lines, capped in number and length. Logs describe what the run did; they are not a transcript of AI processing.

#Other records

  • The threat model and project rules for each application, which you can read and edit. See project rules and custom checks.
  • Reports generated from a pentest.
  • Fix runs: what was attempted, the result of verification, and the pull request that was opened.
  • The remembered patterns of findings you dismissed, which hold a few normalised lines of the dismissed code so the same flaw is recognised again. See dismissal memory.
  • The audit log.

#What is written to your own systems

Nullgap writes comments, checks and fix pull requests to your code host, issues to your tracker and messages to Slack, when you have set those up. These live in your systems under your control and your retention; Nullgap's retention and erase tools do not reach them.

#What is not stored

  • Your repository. Only the excerpts in findings and dismissal patterns outlive a run.
  • Prompts and raw AI responses. Nullgap does not write them to its database or its run logs. Retention on the AI processing side is covered on AI processing.
  • Credentials found in your code, in readable form.

#Credentials in your code

Two mechanisms apply to everything read from a checkout:

  • Credential files are not read for AI processing at all. That covers .env files (but not .env.example and similar templates), private key and keystore files (.pem, .key, .p12, .pfx, .jks, .keystore), SSH private keys, .npmrc, .netrc and files named credentials.
  • Credential-looking values are masked in everything sent for AI processing and in the excerpts stored with findings. A masked value keeps its first four characters and its length, and nothing else.

The masking is pattern-based. It recognises well-known key formats (cloud access keys, code-host and chat tokens, payment keys, signed web tokens), private key blocks, and assignments whose name says it is a credential (api_key, secret, token, password and the like) with a long enough value. It cannot recognise an arbitrary secret with no telltale shape, such as a short password in an oddly named variable. Do not rely on it as a reason to keep secrets in source code; a finding about a hard-coded secret is still worth acting on.

#How long it is kept

By default, findings and run history are kept until you delete them. You can set a retention period, export everything, and erase it: see retention, export and erase.

#Uploaded archives

Code that is not on a code host can be uploaded as an archive. An uploaded archive is different from a connected repository in one way that matters here: the archive itself is kept, because there is nowhere else to fetch it from.

FactValue
Where it is keptOn the service's own storage, under your organisation, in the compressed form you uploaded
During a pentestUnpacked into a fresh directory, which is deleted when the pentest ends
How it is unpackedBy Nullgap's own reader for the .tar.gz and .zip formats. Only regular files and directories are written; links and device entries are skipped; every path is kept inside the destination
Size limits200 MB compressed; 1 GB and 100,000 entries unpacked; 256 MB for a single file
How manyUp to 20 archives per organisation
When it is deletedWhen you remove the repository entry for it, or erase data with the all scope

The retention period does not delete uploaded archives. Remove the repository entry when you no longer need it.

#Who at Nullgap can see what

#Other customers

Nobody outside your organisation can read your data through the product. Every record belongs to one organisation, and a request for an organisation you are not a member of gets the same 404 as one that does not exist.

#Nullgap staff

Staff who support the service work with workspace-level information: your organisation's name and plan, how many members and repositories it has, how much it has used, when it was last active, and the status and error text of background jobs. That view does not include your code or the content of your findings.

There are two paths by which a person at Nullgap reads a finding, and both are switched on per workspace and recorded in your audit log: human validation, described here, and support access, described below.

In human validation a Nullgap researcher checks pentest findings before you rely on them.

  • It applies only to workspaces where human validation has been switched on. Switching it on or off is recorded in your audit log (platform.validation_enabled, platform.validation_disabled).
  • A researcher sees a list of the findings waiting for validation: repository name, title, severity and assurance level.
  • Opening a finding shows the researcher the whole finding, including its evidence and code excerpt. Every such read is written to your audit log as finding.viewed_for_validation, with the actor Nullgap researcher.
  • The researcher's decision is recorded too: finding.validation_confirmed, finding.validation_adjusted (a severity change), or the finding closed as a false positive with their reason.

A researcher never gets a checkout of your repository through this path: they see what the finding stored.

#Support access

Support staff who answer a request cannot open your findings, reviews or pentests. An admin or owner of your organisation can allow it for 1 hour, 24 hours or 7 days, and end it at any moment.

  • While it is on, support can read findings (with their evidence and code excerpt), pull request reviews, pentests, review settings and the list of repositories. Nothing can be changed, and stored credentials, API keys, integrations and sign-in settings are not part of that view.
  • Every page support opens is written to your audit log as support.access_used, with the actor Nullgap support. Giving and ending access are recorded as support.access_granted and support.access_revoked.
  • Every admin sees a banner on every page for as long as it is on.

See the support channel.

Everything else staff do to your workspace (changing a plan, a ceiling or a credit balance, suspending or resuming it) is also written to your audit log. See the audit log as a security control.

#People who operate the infrastructure

The service has to be able to read what it stores in order to work, so the people who operate its infrastructure have the technical means to reach the database. Field-level encryption protects stored secrets, as described under encryption; findings and run records are protected by the access controls and storage protections of the hosting, which are covered by your agreement with Nullgap rather than by this documentation.

  • The sandbox: where proofs and fix verification run.
  • Encryption: how stored secrets are protected.
  • AI processing: what is sent to Nullgap AI and how zero retention is checked.

Nullgap documentation