Biscuit tokens make offline attenuation auditable, not automatically safe
Biscuit is an authorization token format built around public-key signatures and a chain of append-only blocks. The issuer creates an authority block, and a holder can add a block that restricts the token without contacting the issuer. A verifier evaluates the resulting facts, checks, and policies against the request context. The design addresses a real distributed authorization problem: how to delegate narrower rights while keeping every service able to verify the chain.
The Biscuit specification describes the authority block as the part created by the token emitter. Later blocks can be added during offline attenuation. Each block is linked cryptographically, so a verifier can determine whether the token was modified and whether an external party signed a third-party block. This is similar in spirit to macaroon attenuation, with a public-key model and a logic language for policy.
Verification is a policy execution
A valid signature does not mean the token is authorized. The verifier must supply trusted facts about the request, load the token facts, evaluate every check, and apply the local policy. If the resource server accepts a token merely because its signature chain verifies, it has skipped the authorization decision.
The policy language also creates an execution surface. Limit token size, block count, term count, and evaluation time. A verifier should reject malformed facts and policies rather than continue with partial state. When multiple services use Biscuit, agree on the policy version and the meaning of resource identifiers so a token cannot be evaluated differently by two components.
Attenuation needs an owner
Offline attenuation lets an intermediate party add restrictions without asking the issuer, which is useful for gateways, job runners, and delegated tools. It also means the issuer must define which parties may attenuate, what information they may add, and how the resulting token is stored. A downstream service that accepts an attenuated token should record the complete block chain identity and the policy result.
Third-party blocks add an external signature. A verifier needs to know which keys are trusted for which third-party relationships. A block signed by an unrelated key should not satisfy a policy simply because the signature is mathematically valid. The trust store and the policy must agree on the authorized signer for each context.
Revocation and expiry need explicit state
Biscuit supports revocation identifiers at the application level, but the token format does not remove the need to operate a revocation service or a short lifetime policy. The verifier must decide whether a missing revocation check is a failure. If the token contains an expiry fact, the resource server still needs a trusted clock and a rule for clock skew.
The token chain can be larger than a simple bearer token. Store the exact token used for a request, the verification result, and the policy version without exposing secrets in logs. If an incident requires replaying a decision, an audit record that says only "valid Biscuit" is not enough.
Start with a narrow policy
A first deployment should use a small set of facts, a small verifier policy, and a clear owner for the issuer key. Test attenuation by a party that should be allowed to narrow rights, by a party that should not, and with a resource name that differs only by case or delimiter. Test an expired token, a revoked token, an oversized token, a broken signature chain, and an unknown third-party key.
Biscuit is useful when offline delegation is a real requirement and every verifier can execute the same policy. It is not a shortcut for authorization governance. The token format makes the delegation chain visible; the organization still has to decide what the chain means, who can extend it, and when the result is no longer valid.
Top comments (0)