spec

https://github.com/fernet/spec/blob/master/Spec.md It's just a simple format specification using standard crypto primitives. > AES in CBC mode with a 128-bit key for encryption; using PKCS7 padding. > HMAC using SHA256 for authentication.

See also Fernet and Branca: https://github.com/fernet/spec/blob/master/Spec.md https://branca.io/

Fernet [0] was just as close to being a suitable and secure JWT replacement. But the specification wasn't really updated in a while so a simpler and another secure alternative to JWT and Fernet would be Branca [1] tokens that uses the same cryptography as PASETO v2.local [2]. Here's some trivia, the name comes from an italian drink from the 19th century named Fernet-Branca [3]. [0] - https://github.com/fernet/spec/blob/master/Spec.md [1] - https://branca.io [2] - https://github.com/paragonie/paseto/tree/master/docs/01-Prot... [3] - https://en.wikipedia.org/wiki/Fernet-Branca

Honestly, I find that PASETO [0] is a better candidate to replace JWTs since it supports encrypting these tokens and doesn't have multiple ciphers to choose from, unlike JWTs. They can be used just like them for signing, etc just without the weak cryptography in the token. Fernet [1] was close to being an alternative but I've seen that even Branca [2] tokens look much more like a saner alternative for replacing JWTs. [0] - https://paseto.io [1] - https://github.com/fernet/spec [2] - https://branca.io

> Their docs also cover how not to store a JWT as well. Well, it tells you something about that JWTs allow more ways to misuse the token spec which already makes it a bad standard. alg = none is still in the standard, no encryption by default and there is no sane cryptographic choice to sign/encrypt the JWT, which allows developers to shoot themselves in the foot as what we have here with using it with sessions. Fernet [0] was the closest to being a successor of a better standard, but I believe PASETO [1] or even Branca [2] tokens look much more better alternative for JWTs. If not, then the good old session cookie may suffice even. [0] - https://github.com/fernet/spec [1] - https://paseto.io [2] - https://branca.io

After reading the pitfalls and mitigations section, I'm starting to wonder why JWTs/JWEs/etc are even adopted despite these attacks demonstrated by many cryptographers mentioned in this book. Since JWTs allow for a choice of algorithms (algorithm agility) to sign/verify the tokens, it allows room for many developers to shoot themselves in the foot in securing these tokens, hence the multiple vulnerabilities documented in this book. It's worth looking at better alternatives that are more cryptographically secure and have sane defaults than JWTs these days. I'd rather use either PASETO [0], Branca [1] or Fernet [2] Tokens at this point. [0] https://paseto.io/ [1] https://branca.io/ [2] https://github.com/fernet/spec/

Depending on your situation, you've got only 3 reliable options, as far as I'm concerned. 1. You could just generate random session IDs (UUIDs or 128-bit base64 strings) and store them in your database or in a persistent cache like Redis. Most OAuth middleware offer this functionality already. Drawback: Scalability - but in most cases you don't need it. 2. Use an alternative format that doesn't provide all the features of JWT, but provides better security: Fernet or Macaroons. https://github.com/fernet/spec/blob/master/Spec.md https://github.com/rescrv/libmacaroons You'll need to implement claim validation and expiry validation all by yourself. Fernet is probably better for you if you don't need the killer feature of macaroon (stacking caveats). The payload can be anything, but if you really like JWT you can always stick a JSON-encoded JW

Sure: use Fernet. https://github.com/fernet/spec/blob/master/Spec.md It's an informal standard, like Noise, or WireGuard, or Curve25519, or Nacl. It's also so simple that JWT nerds will likely believe it's missing something. It is: the JWT/JOSE vulnerabilities. It used to be that we got things working and then standardized them. Now we build cryptosystems de novo in standards committees and spend the next 10 years writing papers about the resulting flaws. Ok, it didn't used to be that way, and we've always been writing papers about flaws in crypto standards. I don't know what to say about this, except "stop, somehow".

Or just use Fernet: https://github.com/fernet/spec/blob/master/Spec.md Fernet was written originally for Python but there's a Ruby implementation, a Golang implementation, and a Clojure implementation. I believe that for at least 80% of applications considering JWT, Fernet provides exactly the right amount of functionality, and does so far more safely than JWT.