End-to-End Encryption for Pentest Findings, Explained

What end-to-end encryption means for pentest findings, how it differs from encryption at rest, what it protects, and what to ask a platform about it.

End-to-end encryption means a finding is encrypted on the device of the person who writes it and opened only on the devices of the people allowed to read it. Every server in between, and the database that keeps it, holds ciphertext and no key that opens it. For a testing firm, whose platform holds every client’s unfixed weaknesses, that is the difference between a database worth stealing and one that is not.

The term is used loosely, so it is worth being precise about what it covers, what it does not, and how to tell the real thing from encryption at rest with a better name.

Encryption at rest is a different promise

Almost every database and cloud disk is encrypted at rest. The data is written to storage encrypted, and decrypted by the database server as it reads it. That protects against one thing well: someone walking off with the physical disk, or a raw copy of the storage, without the key.

It does not protect against anyone who can ask the database a question. The server holds the key, because it needs it to answer queries, so whoever controls the server reads plaintext: a stolen administrator password, a leaked connection string, or the provider’s own staff. A backup taken through the database is usually plaintext too. That is why “data is encrypted at rest” says so little in a security questionnaire, as answering a security questionnaire about your pentest platform explains.

Encryption in the application, where the platform encrypts selected fields with a key its own servers hold, moves the line a little. The database alone no longer reads the data, but the application server still does, and so does anyone who controls it.

What end-to-end changes

With end-to-end encryption the key never reaches a server at all. The browser encrypts a finding before sending it, the database stores what it was sent, and only a browser holding the right key can turn it back into words. Nobody on the server side has the means to read it: not the platform’s staff, not the people who run the database, and not an attacker who has taken either.

The hard part is not the cipher. AES and elliptic curve key exchange are standard, and built into every modern browser. The hard part is getting keys to the right people without anyone having to manage them:

  • A new colleague needs the keys for the clients they test, and nobody else’s.
  • A new laptop needs its owner’s keys, without a key file being copied around.
  • A client needs the key to their own findings and nothing more.
  • A lost device must stop being able to open anything, without the work being lost with it.

A design that answers those with “export your key and keep it safe” will be switched off within a month. A good one answers them without asking anybody to do anything.

What it protects

  • A copy of the database. A dump, a snapshot or a backup holds ciphertext, wherever it ends up.
  • Whoever runs the database. An administrator of the server, the cloud account or the hosting provider can see the rows, but not the words in them.
  • The platform’s own servers. A breach of the vendor reaches no key that opens a finding.
  • Access granted by mistake. A database account with too much access still reads nothing of the work.

What it does not protect

End-to-end encryption is a strong control, not a complete one, and a vendor who will not say where it stops is worth questioning.

  • The code in the browser. In a web application the code that does the encrypting is served by the vendor, so whoever can change that code can reach what a signed-in person can. Ask who can deploy it, and how.
  • A compromised device. Malware on a tester’s laptop sees what the tester sees.
  • What you send onwards. A ticket in a client’s tracker or an email carrying a finding is readable where it lands, because that is the point of sending it.
  • What has to stay readable. A platform still needs client names, dates, statuses and severities to schedule, count and report on the work. Ask exactly which fields are encrypted and which are not.

Questions to ask a platform

  1. Where are the keys made, and where are they kept? In the browser and on the device is the answer you want. A key management service the vendor runs is encryption at rest with extra steps.
  2. Can your own staff read a finding? Not whether they will, but whether they could, given full control of the vendor’s servers.
  3. Exactly what is encrypted? Titles, evidence, screenshots, files and the credentials clients send, or only some of them?
  4. How does a new laptop, a new colleague or a client get access? If the answer involves anyone exporting a key, expect it to be done badly.
  5. What happens when a device is lost? Both halves: the device stops opening anything, and the work survives.
  6. Do the integrations and the API still work? And how do they get the words they need without a server holding a key?

Second factors matter here too, because a stolen password should not be enough to sign in and be handed keys. Setting up multi-factor authentication covers the policy side, and handling evidence and client credentials safely covers the rest of the evidence trail.

In Pental’s Portal the testing work is end-to-end encrypted. Findings in full, evidence, every file on an engagement, notes, comments and the credentials clients send are encrypted with AES-256-GCM in the browser of whoever writes them, and kept as ciphertext in a database your firm owns. Each browser makes a key of its own that it never hands out, and a person’s password opens their work on a new one, so nobody sets anything up. So that a first sign-in or a forgotten password needs nobody else, your database also keeps each person a recovery key under two locks, its own and Pental’s, and neither opens it alone. Client and engagement names, dates, statuses and severities stay readable. See how the end-to-end encryption works.

Common Questions

What is the difference between encryption at rest and end-to-end encryption?
Encryption at rest protects data on the disk, and the server holding it decrypts it to answer every query, so whoever controls the server reads plaintext. End-to-end encryption encrypts it on the user’s device before it is sent, so the server only ever holds ciphertext and no key that opens it.
Can a pentest platform be end-to-end encrypted and still work normally?
Yes, if the keys travel without anyone handling them. Reports are generated in the browser from the opened work, integrations are handed the words as they are sent, and the fields a platform must schedule and count by, such as dates, statuses and severities, can stay readable.
What does end-to-end encryption not protect against?
The code that runs in the browser, which whoever can deploy it could change; malware on a user’s device; and anything sent onwards, such as a ticket or an email. A good vendor says where its encryption stops as plainly as where it starts.
Should the credentials clients send be end-to-end encrypted too?
Yes. Credentials a client sends for a test are among the most sensitive data a testing firm holds, so they should be encrypted in the client’s own browser before they are sent, and opened only by the people at the firm who are allowed to read them.

Keep Reading

Setup guide

See the product set up, end to end

The whole setup in 5:44, with chapters you can jump to: your firm's name, your own domain, your own database in any of three places, email from your own address, branding, updating the database on Supabase Cloud, and moving the database if you change your mind.

  • 0:00 · Your name and your firm’s name
  • 0:15 · Custom domain
  • 0:43 · Your own database, three ways
  • +4 more