A security audit that separates what is confirmed from what is doubtful.

Who it is for

For companies and public bodies with software of their own or built by a supplier: a website, a portal, an API or an internal application. Also for anyone who has to show security assurances to a customer or a public body.

The problem

You do not know whether your application has holes. A supplier built it, or a team that is no longer there. The last audit was a PDF with hundreds of warnings from an automatic tool, in no order, and nobody knew where to start. And now a customer asks for proof that your software is secure.

How we solve it

We read the code and look at the application the way someone who wants to get in would. Each possible flaw is proposed by one agent and a different one tries to prove it false. What holds up reaches the report, with its evidence. We tell you what to fix first and the smallest change that closes it.

What it includes

  • Code review

    Of the whole application, not a sample.

  • Dependencies and configuration

    Libraries with known vulnerabilities, images and credentials forgotten in the repository.

  • Confirmed findings

    Each with its evidence: where it is, how it is exploited and what it allows.

  • What is still to be validated

    What we could neither confirm nor rule out, stated as such.

  • Minimum fix

    The smallest change that closes each finding.

  • Report walkthrough

    We go through it with you, in the order things should be fixed.

How we work

We agree the scope: which repositories and which applications. You give us read-only access to the code. We work without touching anything: we do not change the code or run it outside an isolated environment. You get the report with what is confirmed, what is still to be validated and the minimum fix for each finding. If you want, we fix it ourselves and check it again.

What we measure

Confirmed findings by severity, findings still to be validated, candidates discarded during verification and, if there is a second round, findings already fixed.

How it is built

The audit starts with automatic scanners: Semgrep for the code, OSV-Scanner for the dependencies, Trivy for images and configuration, and Gitleaks for credentials in the history. What they find are leads, not findings.

Then comes reconnaissance: what the application does, where data comes in and what it protects. The code is split into units and each one is reviewed by an isolated agent, which starts from those leads and also looks for what a scanner cannot see: permission and logic flaws.

Each candidate goes to an independent verifier agent whose job is to refute it. What it cannot refute is confirmed; what can be neither confirmed nor ruled out is delivered as still to be validated. Findings are stored in a fixed, validated format, and the report is built from it.

For Liferay we use our own guide, with the usual flaws in its modules, services and permissions. In our projects, static analysis also carries our own rules for Liferay and stops the integration if a new finding appears.

Frequently asked questions

What do I get when the audit ends?

A report with what is confirmed, what is still to be validated and the minimum fix for each finding, ordered by what to fix first.

Why does one agent try to refute what another proposes?

Because a tool on its own raises many false alarms, and nobody reads a report full of them. Only what survives a serious attempt to take it apart reaches the report.

Will you touch my code or my systems?

No. The audit only reads. It does not change the code or publish anything, and it only runs it inside an isolated environment.

How is it different from a penetration test?

The audit looks at the code from the inside. A penetration test attacks the running system from the outside. They complement each other: one finds the flaw and the other shows how far it reaches.

Also in Security

The next step

Tell us how you work today and we will tell you where to start.