stasher-dev

Nice one! I was the author of the original post and got roasted. Lol

Even if no one uses my project as a result of this guys work. I am pleased it's generated a safer outcome for everyone and from a more trustworthy source.

Your skepticism is valid and if your flow already includes: A secure messaging tool (e.g. Signal), a GPG workflow or local encryption or a team that uses shared password vaults. Then to be fair Stasher might not be better.

I built Stasher for me. I wanted an easy, CLI-first way to share one-time secrets without worrying about accounts, apps, or trust. If Signal or GPG works better for you that’s totally cool.

Stasher exists to make casual, secure sharing simpler not to replace tools you already trust.

Thanks for your feedback 'I tried to use of the shelf stuff for the crypto and utilised what I believe to be battle tested.

CLI uses node.js built-in crypto module only -randomBytes - createDecipheriv - createCipheriv.

Web app uses Web Crypto API only.

I'll send Filippo a Postcard and see if he will review it :-P

Yes, that's a fair comment technically speaking: Cloudflare Workers + KV + Durable Objects is a backend. I was trying to imply No user accounts, no persistent database, no stateful sessions etc I will reword - thanks for the feedback

Yes, you are understanding it correctly, the server (Cloudflare Worker + Durable Object + KV) in Stasher is only needed to enforce the burn-after-read behaviour

zero setup, burn after read, no key exchange required, GPG is ideal for persistent trust relationships (e.g., signing emails), Stasher is purpose-built for temporary relationships. To me GPG is overkill for sharing simple shares. Defo not trying to replace GPG, just a different use case.

It means the releases are cryptographically signed using GitHub OIDC, with SLSA v1 provenance and entries in the Rekor transparency log.

That means:You can verify every artifact against its source code i.e I have not tampered with the code post deployment. for example part of the build is a dry-run on the worker build, this is stored as part of the build so you can see / confirm the exact code that was uploaded and this code is signed.

So the ten minute thing is a trust issue?

Stasher enforces expiry in two layers:

Reactive expiry — When someone tries to retrieve a stash (destash), the Durable Object checks the creation timestamp before serving. If it's older than 10 minutes, it refuses the request.

Proactive cleanup — Every stash’s Durable Object sets a scheduled alarm to self-destruct after 10 minutes. This removes the coordinating DO and ensures the encrypted blob in KV expires (via TTL).

So even if someone tries to cheat the system, or access after the 10-minute window, they’ll get an error — the stash is gone.

This is part of what makes it “burn-after-read, or expire-after-time”. No guessing, no timers in memory or cron job workers.

How are salts handled?

Stasher uses AES-256-GCM, which does not require a traditional salt like in password hashing (e.g. PBKDF2, bcrypt). Instead, it uses an IV (initialization vector).

With a fresh 96-bit IV is generated for every encryption

AES-GCM uses that IV as part of the encryption process, ensuring non-deterministic ciphertext. The IV is not secret, and is uploaded alongside the ciphertext and GCM tag

On decryption, the IV is used to reconstruct the exact same cipher context

So in short: No static salts and no reused IVs

Everything you need to decrypt is bundled with the encrypted stash, except the key, which stays with the user (as part of the uuid:base64key token)

I get it. An 'anonymous' author is a deal breaker for some. I respect that.

The repo is public. The releases are signed. The attestations are published. Nothing hidden.

If that’s not enough — totally fair and I am sure many others would agree. Appreciate your point of view and taking time to give feedback.

When you run:

npx enstash "my secret"

Stasher performs everything locally:

Generates a random 256-bit encryption key

Encrypts your secret using AES-256-GCM

Sends only:

the ciphertext

the IV (initialization vector)

the auth tag

a randomly generated UUID

The encryption key is never sent to the server. It never leaves your machine.

You are then shown a single string:

uuid:base64key

The uuid points to the encrypted stash on the server

The base64key is the encryption key you just generated

Only the person who has both parts can decrypt the secret

How You Share the Secret

You send the full uuid:base64key token to your recipient — over any channel you like slack or whatever.

When they run:

npx destash "uuid:base64key" on the token

Stasher:

Fetches the encrypted stash using the uuid

Deletes it immediately (burn-after-read)

Decrypts it locally using the base64key

Shows the secret

The server never sees the key. Not during upload or during retrieval.

Thanks for raising these concerns — totally fair in the context of security tools.

I’m not anonymous, just cautious. I’m a solo builder, and this is a focused identity for the project. In fact, that's why I implemented full supply chain transparency from day one: signed releases, SLSA attestations, SBOMs, and Rekor logs. You don't need to trust me you can see the code for your self.

Ultimately, you're right — if you can't verify it, you shouldn't trust it.

That’s the whole point of the system: zero trust and verifiable cryptographic guarantees.

Appreciate the scrutiny

Exactly. Once it's read it's gone. If it's not read within 10 minutes... It's gone.

Hey. Only the ciphertext is stored on the server; the key never leaves your machine. The uuid:key format is just a pointer to the encrypted payload. Without the key, the server’s stash is useless. Zero-knowledge by design

Great point — I’m planning to add a --stdin option explicitly for cases like this. Thanks for raising it. I will add to the readme in the meanwhile.