Obsigil

cargo add obsigil               # AES-SIV (code 0); add --features gcm-siv for AES-GCM-SIV (code 1)
cargo add serde --features derive

pip install obsigil

go get obsigil.org/go/obsigil

// Fresh 64-byte key from the OS CSPRNG (zeroized on drop):
let key = obsigil::generate_key();        // or MandateKey::generate()

// Or wrap bytes you loaded from secure storage:
let key = MandateKey::from_bytes([42u8; 64])?;

import obsigil

# Fresh 64-byte key from the OS CSPRNG; provision the same
# bytes to issuer and verifier. The example below pins demo
# bytes instead.
key = obsigil.generate_key()

// 64-byte mandate key from the OS CSPRNG; provision the same bytes to
// issuer and verifier. The example below pins demo bytes instead.
key, err := obsigil.GenerateKey() // ([]byte, error), len 64

use obsigil::{claims, Claims, Clauses, Issuer, MandateKey, Verifier};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct ClauseData { scope: String }   // authoritative mandate clauses (app data)

#[derive(Serialize, Deserialize)]
struct ClaimData { name: String }  // advisory manifest claims (app data)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // The 64-byte shared secret, provisioned to issuer and verifier
    // alike. In production create it once with `obsigil::generate_key()`
    // and load the same bytes on each side; pinned here for a
    // reproducible example.
    let secret = [42u8; 64];

    // --- Issuer: mint a token (AES-SIV + base64 are the defaults) ---
    let token = Issuer::new(MandateKey::from_bytes(secret)?)
        .clauses(&ClauseData { scope: "read:invoices".into() }) // sealed, binding
        .exp(4_000_000_000)                  // REQUIRED absolute expiry
        .subject("user-42")                  // optional sub clause
        .audience(["invoice-api"])           // optional aud clause
        .manifest("auth.example",  // public advisory half
                  &ClaimData { name: "Ada".into() })
        .mint()?;                            // tid: fresh UUIDv7
    println!("{token}");

    // --- Front end: read the public manifest, no secret (advisory) ---
    let advisory: Claims<ClaimData> = claims(&token).expect("manifest present");
    assert_eq!(advisory.issuer(), "auth.example");
    assert_eq!(advisory.app().name, "Ada");

    // --- Backend: authenticate the mandate and read its clauses ---
    let verify_key = MandateKey::from_bytes(secret)?;
    let clauses: Clauses<ClauseData> = Verifier::new()
        .key(&verify_key)
        .audience("invoice-api")
        .now(1_000_000_000) // pin "now"; omit to read the system clock
        .clauses(&token)?;  // checks exp, aud, UUIDv7 tid; opaque Error on failure

    assert_eq!(clauses.subject(), Some("user-42"));
    println!("scope = {}", clauses.app().scope); // -> scope = read:invoices
    Ok(())
}

import obsigil
from obsigil import Obsigil

secret = bytes([42] * 64)

# --- Issuer: mint a token (AES-SIV + base64 are the defaults) ---
token = Obsigil.mint(
    clauses={"scope": "read:invoices"},      # sealed, binding mandate clauses
    mandate_key=secret,
    exp=4_000_000_000,                       # REQUIRED absolute expiry
    sub="user-42",                           # optional sub clause
    aud=["invoice-api"],                     # optional aud clause
    manifest={                               # public advisory half
        "iss": "auth.example",     # manifest iss is REQUIRED
        "claims": {"name": "Ada"},
    },
).token()                                    # tid: fresh UUIDv7
print(token)

# --- Front end: read the public manifest, no secret (advisory only) ---
advisory = obsigil.claims(token)             # dict | None — never raises
assert advisory is not None                  # manifest present
assert advisory["iss"] == "auth.example"
assert advisory["name"] == "Ada"

# --- Backend: authenticate the mandate and read its clauses ---
verifier = Obsigil(
    token,
    keys=secret,
    audience="invoice-api",
    now=1_000_000_000,                       # pin "now"; omit to read the system clock
)
clauses = verifier.clauses()                 # checks exp, aud, UUIDv7 tid; one opaque ObsigilError
assert clauses["sub"] == "user-42"
print(f"scope = {clauses['scope']}")         # -> scope = read:invoices

import (
	"fmt"
	"log"

	"obsigil.org/go/obsigil"
)

func main() {
	secret := make([]byte, 64)
	for i := range secret {
		secret[i] = 42
	}

	// --- Issuer: mint a token (AES-SIV + base64 are the defaults) ---
	token, err := obsigil.Mint(obsigil.MintInput{
		Clauses:    map[string]any{"scope": "read:invoices"}, // sealed, binding
		MandateKey: secret,
		Exp:        4_000_000_000,           // REQUIRED absolute expiry
		Sub:        "user-42",               // optional sub clause
		Aud:        []string{"invoice-api"}, // optional aud clause
		Manifest: &obsigil.ManifestSpec{ // public advisory half
			Iss:    "auth.example",
			Claims: map[string]any{"name": "Ada"},
		},
		// Tid defaults to a fresh UUIDv7.
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(token)

	// --- Front end: read the public manifest, no secret (advisory only) ---
	advisory, ok := obsigil.Claims(token)
	if !ok {
		log.Fatal("manifest present")
	}
	if iss, _ := obsigil.Iss(advisory); iss != "auth.example" {
		log.Fatalf("issuer = %q", iss)
	}
	_ = advisory["name"] // advisory app claim, "Ada"

	// --- Backend: authenticate the mandate and read its clauses ---
	clauses, err := obsigil.Clauses(token, obsigil.VerifyPolicy{
		Keys:     [][]byte{secret},
		Audience: "invoice-api",
		Now:      1_000_000_000, // pin "now"; 0 reads the system clock
	}) // checks exp, aud, UUIDv7 tid; one opaque *Error on failure
	if err != nil {
		log.Fatal(err)
	}

	if sub, _ := obsigil.Sub(clauses); sub != "user-42" {
		log.Fatalf("subject = %q", sub)
	}
	fmt.Printf("scope = %s\n", clauses["scope"]) // -> scope = read:invoices
}