Skip to content

Offensive Security & Red Teaming

A finding you cannot reproduce is a rumour.

Most penetration test reports are a scanner export with a logo on it. They arrive as a list of CVEs ranked by a number that was calculated without any knowledge of your environment, and the engineering team reasonably ignores them. We test the way an attacker does: chained, against your actual architecture, aimed at an outcome you would care about. Every finding comes with the exact steps to reproduce it, the observed impact, and the change that closes it.

Every finding, with the steps to prove it
ReproducibleEvery finding, with the steps to prove it
Findings shown as a path, not a list
ChainedFindings shown as a path, not a list
Fixes verified inside the engagement
RetestedFixes verified inside the engagement

Sounds like

You might recognise one of these.

  • The pen test came back with sixty findings and we do not know what to fix first.

  • A customer requires an annual third-party test before they will sign.

  • We ship a device and we have no idea what happens if someone opens it.

  • We built an AI feature and we are not sure what a hostile prompt can make it do.

  • We would like to know whether our detection would actually catch this.

What this includes

The work, specifically.

Not every engagement needs all of it. This is the range we cover and what each part is actually for.

  • Application and API penetration testing

    Manual testing against OWASP ASVS and the API Top 10: authentication and session handling, the whole authorization matrix, injection, business-logic abuse, file upload, SSRF and the multi-step flows scanners never reach because they cannot hold state.

  • Network, cloud and identity assessment

    External and internal network testing, cloud configuration and IAM privilege-escalation paths, and the identity plane specifically, because in most breaches the interesting move is not an exploit, it is a credential used somewhere it should not have worked.

  • Adversary emulation and purple teaming

    Named techniques mapped to MITRE ATT&CK, executed against your environment with your defenders watching, so the deliverable is a detection gap analysis rather than a trophy. We have written custom implants and command-and-control tooling for exactly this purpose, which means we are not limited to what an off-the-shelf framework already has a signature for.

  • Reverse engineering and binary analysis

    Static and dynamic analysis of compiled software, firmware and drivers: disassembly, decompilation, protocol recovery from a binary that has no documentation, and exploitability assessment of a memory-safety bug you have already found but cannot triage.

  • Embedded, IoT and hardware security

    Device teardown, debug-interface discovery, firmware extraction, radio and network sniffing, and the boring but decisive questions: is secure boot real, is the update signed, does every unit ship with the same key. We have run this work against a connected-device testbed and delivered both the exploit and the remediation.

  • AI and LLM red teaming

    Prompt injection through retrieved content, tool-invocation abuse, data exfiltration through the model’s context, and authorization that was implemented in a system prompt rather than in code. Assessed as an application security problem, because that is what it is.

  • Continuous vulnerability research

    We hunt on public disclosure programs between engagements, against systems whose owners did not scope the test for us and will push back on anything we cannot prove. That is where the discipline on this page comes from: authorization checked before the first packet, findings ruled out on the target’s threat model rather than written up anyway, and a validator that will not let a draft claim something no captured request supports.

  • Vulnerability disclosure and bug bounty programs

    The other side of that inbox: a disclosure policy that says what is in scope and what a researcher is permitted to do, a security.txt at the location RFC 9116 specifies so the finder does not end up mailing your sales address, an intake and severity rubric, and the internal handling path from report to fix to advisory. We will also triage the queue with you for the first months, which is where programs actually fail — not at launch, at report ninety.

What you get

Deliverables, not documents.

  • Findings with exact reproduction steps, evidence and observed impact
  • Severity rated against your environment, not a generic CVSS base score
  • Attack narrative showing how findings chain into an outcome that matters
  • Detection gap analysis mapped to MITRE ATT&CK techniques
  • Specific remediation guidance, at the code or configuration level
  • Free retest of remediated findings within the engagement window
  • An executive summary an executive can actually act on
  • For a disclosure program: the published policy, the security.txt, the intake rubric and the internal handling path, tested with live reports

Shapes

How this usually runs.

  1. Scoped penetration test

    1–3 weeks

    One application, network or cloud environment, tested manually against a defined scope, with the report and a walkthrough session. Retest included.

  2. Adversary emulation

    3–6 weeks

    Objective-based testing against a stated goal, with an agreed rules-of-engagement document and a purple-team debrief with your defenders.

  3. Device or firmware assessment

    3–8 weeks

    Hardware in hand: teardown, firmware extraction, analysis and exploitation, with remediation guidance the product team can schedule.

  4. Disclosure program stand-up

    3–5 weeks, then optional triage support

    Policy, scope, safe-harbour language and security.txt, plus the intake rubric and the handling path from report to advisory. We then sit on the queue with your team for an agreed period, because the first hundred reports are what teach an organization whether the process it wrote down actually works.

Tooling

What we build it with.

No tool here was picked because it was new. Where we do reach for something novel, it is in one place, for a stated reason, and it is written down.

Application
  • Burp Suite
  • OWASP ASVS
  • Semgrep
  • Custom tooling
Network & cloud
  • Nmap
  • Nessus
  • Metasploit
  • Hashcat
  • Aircrack-ng
Binary & firmware
  • Ghidra
  • gdb
  • OllyDbg
  • Binwalk
  • Verilog/FPGA
Emulation
  • MITRE ATT&CK
  • Custom implants and C2
  • Elastic
  • Sysmon

Questions

Offensive security, honestly.

  • A scanner tells you which versions are old. It cannot chain three low-severity issues into an account takeover, it cannot reason about your business logic, and it cannot tell the difference between a vulnerable library you import and a vulnerable library you actually call. Scanning is a control you should run continuously and automatically. Testing is what tells you whether the controls work.

  • Not without asking. The rules of engagement are written before anything starts and they name the destructive classes explicitly: denial of service, data modification, credential lockout, social engineering of named staff. Anything in those categories happens only against a non-production environment or with written go-ahead, and there is a documented stop procedure with a phone number attached.

  • Yes. An attestation letter suitable to share with a customer or an auditor, describing scope, dates, methodology and remediation status, without disclosing the findings themselves.

  • For breadth, yes: enumeration, correlating one host’s behaviour against another, reading more source than a person can in the time. Never for the claim itself. Disclosure programs are currently drowning in AI-written reports that cite functions which do not exist and debugger output that was never captured, and two well-known open-source projects have curtailed their bounty programs over it. Our own research harness enforces the counter-rule mechanically: a finding cannot be written up unless every endpoint, parameter and response in it maps to a request we actually sent. You will get fewer findings from us than from a tool, and you will not spend your engineers' time disproving them.

  • We will, but we will also tell you that an independent tester is worth more. Testing your own work has a real blind spot: you inherit the assumptions you made while building it. For anything where the assurance is the point, use someone else, and we are happy to be the someone else for a system another firm delivered.

  • Probably not yet, and the honest sequence is disclosure policy first, paid bounty later. A vulnerability disclosure policy costs you a published page, a security.txt and a commitment to answer; it converts the finder who was going to tell you anyway from a legal risk into a report. A bounty adds money, and money buys volume rather than quality. The question that decides it is not budget, it is whether you can absorb the queue: an engineer who can reproduce a claim, a path to a fix with an owner and a date, and someone willing to write "not a vulnerability" and defend it. If a report today would sit unanswered for three weeks, a bounty will make that visible to the entire researcher community rather than fix it.

  • The programs that publish numbers say so. curl ran its bounty from 2019 and paid out over $100,000 across 87 confirmed vulnerabilities; its confirmed-report rate ran above 15% for years, fell below 5% during 2025, and the project ended the bounty on 31 January 2026 — then went back to accepting reports, without money, a month later. Nextcloud suspended its payouts in April 2026 for the same reason. The lesson is not that disclosure is finished, it is that the reward was paying for volume and the maintainers were paying for triage. If you launch one, expect the triage cost to be the real budget line, write a rubric that lets you close a report quickly on the threat model, and require reproduction that names a request the reporter actually sent.

  • An acknowledgement inside a stated window, a decision, and no legal threat for work that stayed inside your published scope. That last one is the part that has teeth: a policy without a safe-harbour statement is an invitation to a researcher to accept legal risk on your behalf, and most will simply not take it. Federal civilian agencies have been required to publish a policy that says this since CISA's Binding Operational Directive 20-01 in 2020, and the language there is a reasonable model for a private program.

Sources

  1. 1.OWASP Top 10:2025, OWASP Foundation
  2. 2.RFC 9116: A File Format to Aid in Security Vulnerability Disclosure, IETF,
  3. 3.BOD 20-01: Develop and Publish a Vulnerability Disclosure Policy, CISA,
  4. 4.The CERT Guide to Coordinated Vulnerability Disclosure, CERT/CC, Carnegie Mellon Software Engineering Institute
  5. 5.The end of the curl bug-bounty, Daniel Stenberg (curl),
  6. 6.Due to AI: Bug bounty programs without rewards, now also at Nextcloud, heise online,

Next step

Tell us what’s breaking.

Forty-five minutes, no charge, no deck. We’ll tell you what we’d do, what it would likely cost, and whether you should be building this at all.