The AWS key started with AKIA. It always does. That four-letter prefix is how GitHub's secret scanning knows to flag it. But the developer who pasted it into a Slack channel on a Tuesday afternoon did not know that. They were debugging a staging environment and needed a teammate to test an endpoint. The key sat in that Slack channel for 14 months before an automated scanner found it. By then, the key had been rotated. But for 72 hours between the paste and the rotation, that key was live and sitting in a chat log accessible to anyone with workspace access.
Every developer has done this. Every single one.
The Real Cost of Leaked API Keys
GitHub reported in 2024 that they scan and alert on over 40,000 leaked secrets per day across public repositories. That is only public repos. It does not count Slack, Microsoft Teams, Jira, Confluence, email, or the dozens of other places developers paste credentials during the course of normal work.
A leaked Stripe secret key (format: sk_live_ followed by 24+ alphanumeric characters) can process refunds, create charges, and access every transaction in the account. A leaked AWS access key can spin up EC2 instances for crypto mining at your expense. A leaked database password can exfiltrate every row in every table. The blast radius is enormous.
The average cost of a leaked secret in a public repository, according to GitGuardian's 2024 State of Secrets Sprawl report, is $1.2 million in remediation, downtime, and potential breach costs. For a developer who just wanted to unblock a teammate.
Why Developers Reach for the Wrong Tools
Slack is fast. You type, you paste, you hit enter. Your teammate has the key in two seconds. The problem is that Slack messages are permanent. Slack retains messages indefinitely unless an admin configures retention policies. Even then, the retention window is typically 30 days minimum. That API key is sitting there for a month.
Jira tickets are worse. A ticket describing a bug that requires a test API key to reproduce will sit in the project board forever. The key is buried in a comment. Nobody goes back to redact it. When the project is archived, the key goes with it.
Email is the original offender. A developer emails a database password to a contractor. The contractor's email provider scans incoming mail for security purposes. The password is now in three mail servers, two backup systems, and the contractor's local mail client.
The common thread: all of these tools store the credential permanently. The developer needed the credential to be shared exactly once, for a specific purpose, and then forgotten by everyone except the system that needs it.
One Time Secret for Developers: The Workflow
A one-time secret solves this. The workflow looks like this:
You have a production database password that a contractor needs for a migration. You paste the password into NovelCrypt. The service encrypts it and gives you a link. You send the link to the contractor in Slack. The contractor clicks the link, reads the password, and the server deletes the encrypted content. The Slack message now contains a dead link. Even if someone scrolls back through the channel history six months later, the link returns nothing.
This works for any credential type. AWS access keys. Stripe API tokens. JWT signing secrets. Database connection strings. SSH private keys. Anything that fits in a text field.
Sharing Specific Credential Types Safely
### AWS Access Keys
Format: AKIA followed by 16 characters. These keys are the most commonly leaked secret on GitHub. When you need to share one with a teammate, generate a temporary IAM access key through AWS STS with a 1-hour TTL. Share the temporary key through a one-time secret link. Even if the link is intercepted, the key expires in 60 minutes. For the permanent key, never share it. Use IAM roles and cross-account access instead.
### Stripe API Keys
Format: sk_live_ or sk_test_ followed by 24+ characters. A live Stripe key can move money. Never paste one into a chat tool. If a teammate needs to test against a live Stripe endpoint, create a restricted key with specific permissions (e.g., read-only for charges). Share the restricted key through a one-time secret. Rotate the key after the task is complete.
### Database Passwords
A PostgreSQL connection string looks like postgres://user:password@host:5432/dbname. The entire string contains the password in cleartext. When sharing database access with a contractor or new team member, extract the password from the connection string and share it separately through a self-destructing link. Share the host, port, and database name through a separate channel. This way, even if the one-time link is compromised, the attacker has only the password — not the full connection string.
### JWT Signing Secrets
These are long random strings used to sign authentication tokens. If an attacker obtains the signing secret, they can forge valid JWTs and impersonate any user. Share signing secrets through one-time links only, and rotate the secret immediately after any team member who needed it has completed their task.
Building a Culture of Traceless Secret Sharing
Tools alone do not fix the problem. The developer who pastes an AWS key into Slack is not being careless. They are being efficient. They have a problem to solve and they are solving it with the fastest tool available. The solution is to make the secure option faster than the insecure one.
Keep the NovelCrypt create page bookmarked. Make it faster to open that page and paste a key than it is to switch to Slack and paste it there. Train your team to default to one-time secrets for any credential that is not a permanent configuration value stored in a secrets manager.
For permanent secrets, use a proper secrets manager — AWS Secrets Manager, HashiCorp Vault, Doppler, or 1Password. One-time secrets are for the in-between moments. The contractor who needs a password for two hours. The teammate who needs to test an API key for a deploy. The moment when a credential needs to leave your hands and land in someone else's, briefly, and then cease to exist.
The Developer's Checklist for Sharing Secrets
Before you paste a credential into any communication tool, ask yourself:
- Does this tool store messages permanently? If yes, stop. - Does the recipient need this credential more than once? If no, use a one-time link. - Can I rotate this credential after the task is done? If yes, rotate it regardless of how you shared it. - Is there a less privileged version of this credential I can share instead? If yes, create and share the restricted version.
Secrets are not meant to be shared. They are meant to be used. When sharing is unavoidable, make it ephemeral.,