What you hand over when you paste

The measurement

Five pieces of text of the kind that goes into a chat box every working day, each written the way a real one looks rather than the way an example does: a project's environment file, a customer's email pasted in to get help writing the reply, a stack trace off a production server, three rows lifted out of a spreadsheet, and a deployment config out of a repository.

Fifty-nine lines. Three thousand one hundred and twenty-five characters. Run through SENTINEL, which reads text in the browser and never sends it anywhere, the five of them together hold twenty-six findings, and sixteen of those are a live credential or a payment card.

The last row is the one to sit with. Four credentials and nothing below high: no addresses, no soft warnings, nothing that reads as a near miss. A deployment config is all secret and no filler, so there is no gentle signal that you are holding something you should not paste.

The three that surprise people

The stack trace. It is the single most-pasted artefact in software, because it is the thing you cannot read and want help with. The one measured here carries the database connection string with its password in the frame that failed, a bearer token in the frame above it, and in the last line a colleague's work address and the IP of whoever was using the system when it broke. None of that is what you wanted help with. All of it travels with the part that is.

The customer email. Pasting the message in to get help writing a reply feels like handing over prose. The measured one contains a card number that passes the Luhn check, which means it is either a real card or a deliberate test one; a scanner cannot tell, and neither can whatever you paste it into.

The session token. The one in the stack trace is a JSON Web Token, and a JWT is not encrypted. The middle segment is ordinary base64 and decodes with no key at all: in this case to a subject id, the holder's name, and "role":"admin". It is signed, not sealed. Anybody who has it can read who it belongs to and what it is allowed to do, and until it expires, use it.

Logs, and the .env file behind them

A stack trace is one failure. A log is every request around it, and the question people actually ask is whether it is safe to paste one in to find out why something broke. Seven lines of an ordinary web application log, of the kind that sits around any error, were run through ENVSHIELD, which masks secrets in pasted config and logs in the browser:

• a login line with the user's email address and IP address;
• an access-log line for a password-reset link, with the reset token in the query string, which lets whoever holds it set a new password until it expires;
• a debug line of an outgoing API call with its Authorization header, a live payment-provider key;
• a debug line of incoming headers with the session cookie, a JWT, and a CSRF token;
• a database error with the connection string and its password;
• and a retry line that printed an AWS secret key from the environment.

Six secrets in seven lines, and the line anybody would want help with, the database error, is one of them. ENVSHIELD masked all six and kept the rest of each line, so the log still reads and still shows the failure: postgres://‹redacted›:‹redacted›@db-prod-2.internal:5432/orders (ECONNREFUSED) is as useful to an assistant as the original.

It did not start at six. Run before this section was written, it found four, and missed the two that were not in a KEY=value line or a known key shape: the reset token in the URL and the CSRF token in the cookie header. It now masks the values of URL parameters named like secrets (token, code, key, signature, password and the rest) and every value in a Cookie or Set-Cookie header. The point of the next section applies to it too: it masks what it recognises.

What it leaves alone on purpose is the email and IP addresses: they are personal data rather than credentials, and a scanner for secrets that also stripped every address would make most logs useless. If the log is about real people, ALIAS swaps those for placeholders and puts them back in the reply. And paste the twenty lines around the error rather than the file; nobody diagnoses a fault from ten thousand lines of successful requests.

The .env file itself is the simplest case: never paste it as it is. If the question is about configuration, paste it through ENVSHIELD, which keeps every key name and masks every value that looks like a secret, and the assistant can see which settings exist without being given any of them.

What a scanner cannot tell you

Two of the numbers above moved while this was being written, and the reason is worth saying out loud.

The connection-string rule required a username before the colon, so it found postgres://user:password@host and missed redis://:password@host, which is how Redis is written when there is no username, and how RabbitMQ is written too. It read correctly. It was wrong, and it had been wrong since it was written, because nothing was checking it. The environment file above went from six high findings to seven when that was fixed.

Separately, an Anthropic key was being reported under the label OpenAI key: both begin sk-, both are high severity, and whichever pattern ran first took the spot. The severity was right and the name was wrong, which is the worse failure of the two: it sends somebody to rotate a credential that was never exposed while the one that was stays live.

Both are fixed, and there are now fifty-five strings checking the thirty-four patterns, every rule covered, run on every push. The general point stands regardless: a scanner tells you what it recognises. It does not tell you what it missed. Treat a clean result as the absence of a known shape, not as permission.

What to do instead

Not "never paste anything", which nobody follows. Three habits that cost seconds:

• Scan before you send, not after. SENTINEL takes pasted text or whole files and marks what is in them, in your browser. It will also write you a cleaned copy with the values masked, which is usually the thing you actually wanted to paste.
• Swap the names, keep the shape. An assistant almost never needs the real values; it needs the structure. ALIAS replaces names, addresses, phone numbers, amounts and card numbers with consistent placeholders, and puts the real ones back into the reply afterwards. The key stays in your browser. You get the help; the assistant gets PERSON_1.
• Rotate what has already gone. If a credential has been pasted, it is not a secret any more, and no policy page changes that. Rotate it. The value of knowing which one is exactly why the mislabelling above mattered.

And the obvious one: a token that has already expired, a test card, and a database on a laptop are all fine to paste. The point of scanning first is to know which kind you are holding.

Where this leaves the file you were going to attach

Everything above is about text. A file carries more: a Word document remembers who edited it and often what they deleted, a photo remembers where it was taken, a PDF keeps the text under a black box you drew over it. If you were about to attach rather than paste, the question of what a free tool does with an upload and what a Word document is still carrying are the two to read next.