Identity and access

import { createHmac, timingSafeEqual } from "node:crypto";

const ISSUER = "https://login.example.com", AUDIENCE = "orders-api", NOW = 1_000_000, SKEW = 60;
const SECRET = "demo-secret-not-for-production"; // HS256 shares one secret; providers usually sign with RS256 or ES256 keys from a JWKS URL

type Claims = { iss: string; aud: string; sub: string; exp: number; scope: string };

const b64url = (data: string | Buffer) => Buffer.from(data).toString("base64url");
const unb64url = (text: string) => Buffer.from(text, "base64url").toString();
const sign = (headerB64: string, payloadB64: string) => createHmac("sha256", SECRET).update(`${headerB64}.${payloadB64}`).digest("base64url");

function issue(overrides: Partial<Claims> = {}): string {
  const claims: Claims = { iss: ISSUER, aud: AUDIENCE, sub: "user-42", exp: NOW + 900, scope: "orders:read", ...overrides };
  const header = b64url(JSON.stringify({ alg: "HS256", typ: "JWT" }));
  const payload = b64url(JSON.stringify(claims));
  return `${header}.${payload}.${sign(header, payload)}`;
}

// The checks every API must make, in this order, before trusting a bearer token.
function check(token: string, needed: string): string {
  const [headerB64, payloadB64, signature] = token.split(".");
  if (JSON.parse(unb64url(headerB64)).alg !== "HS256") return "401 unexpected algorithm"; // never accept "none" or an algorithm you didn't choose
  const expected = Buffer.from(sign(headerB64, payloadB64)), given = Buffer.from(signature);
  if (expected.length !== given.length || !timingSafeEqual(expected, given)) return "401 bad signature (token was changed or not issued by us)";
  const c: Claims = JSON.parse(unb64url(payloadB64));
  if (c.iss !== ISSUER) return "401 wrong issuer";
  if (c.aud !== AUDIENCE) return `401 token is for ${c.aud}, not ${AUDIENCE}`;
  if (c.exp + SKEW < NOW) return `401 expired ${NOW - c.exp} s ago`;
  if (!c.scope.split(" ").includes(needed)) return `403 missing scope ${needed}`;
  return `200 ok, acting as ${c.sub}`;
}

const valid = issue();
console.log("token:", valid.slice(0, 60) + "...");
console.log("signature:", valid.split(".")[2]);
const [headerB64, payloadB64, sig] = valid.split(".");
const edited = { ...JSON.parse(unb64url(payloadB64)), scope: "orders:read orders:write" }; // the caller edits the claims and keeps the old signature
const tampered = `${headerB64}.${b64url(JSON.stringify(edited))}.${sig}`;

const cases: [string, string, string][] = [
  ["valid token, reading orders", valid, "orders:read"],
  ["expired an hour ago", issue({ exp: NOW - 3600 }), "orders:read"],
  ["token meant for another API", issue({ aud: "billing-api" }), "orders:read"],
  ["valid token, but writing", valid, "orders:write"],
  ["scope edited by the caller", tampered, "orders:write"],
];
for (const [name, token, needed] of cases) console.log(`${name.padEnd(30)} -> ${check(token, needed)}`);

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.*;
import java.util.regex.*;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class Main {
    static final String ISSUER = "https://login.example.com", AUDIENCE = "orders-api";
    static final long NOW = 1_000_000, SKEW = 60;
    static final byte[] SECRET = "demo-secret-not-for-production".getBytes(StandardCharsets.UTF_8); // HS256 shares one secret; providers usually sign with RS256 or ES256 keys from a JWKS URL

    static String b64url(byte[] data) { return Base64.getUrlEncoder().withoutPadding().encodeToString(data); }
    static String b64url(String text) { return b64url(text.getBytes(StandardCharsets.UTF_8)); }
    static String unb64url(String text) { return new String(Base64.getUrlDecoder().decode(text), StandardCharsets.UTF_8); }

    static String sign(String headerB64, String payloadB64) {
        try {
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(new SecretKeySpec(SECRET, "HmacSHA256"));
            return b64url(mac.doFinal((headerB64 + "." + payloadB64).getBytes(StandardCharsets.UTF_8)));
        } catch (Exception e) { throw new IllegalStateException(e); }
    }

    // Claims are written as compact JSON in a fixed order, matching the Python and TypeScript output byte for byte.
    static String json(Map<String, Object> m) {
        StringJoiner j = new StringJoiner(",", "{", "}");
        m.forEach((k, v) -> j.add("\"" + k + "\":" + (v instanceof String ? "\"" + v + "\"" : v)));
        return j.toString();
    }

    // A tiny reader for flat JSON objects of strings and integers; real code uses a JSON library and a JWT library.
    static Map<String, String> parse(String text) {
        Map<String, String> m = new LinkedHashMap<>();
        Matcher x = Pattern.compile("\"(\\w+)\":(?:\"([^\"]*)\"|(-?\\d+))").matcher(text);
        while (x.find()) m.put(x.group(1), x.group(2) != null ? x.group(2) : x.group(3));
        return m;
    }

    static Map<String, Object> claims() {
        Map<String, Object> c = new LinkedHashMap<>();
        c.put("iss", ISSUER); c.put("aud", AUDIENCE); c.put("sub", "user-42"); c.put("exp", NOW + 900); c.put("scope", "orders:read");
        return c;
    }

    static String issue(Map<String, Object> c) {
        Map<String, Object> h = new LinkedHashMap<>();
        h.put("alg", "HS256"); h.put("typ", "JWT");
        String header = b64url(json(h)), payload = b64url(json(c));
        return header + "." + payload + "." + sign(header, payload);
    }

    // The checks every API must make, in this order, before trusting a bearer token.
    static String check(String token, String needed) {
        String[] p = token.split("\\.");
        if (!"HS256".equals(parse(unb64url(p[0])).get("alg"))) return "401 unexpected algorithm"; // never accept "none" or an algorithm you didn't choose
        if (!MessageDigest.isEqual(sign(p[0], p[1]).getBytes(StandardCharsets.UTF_8), p[2].getBytes(StandardCharsets.UTF_8)))
            return "401 bad signature (token was changed or not issued by us)";
        Map<String, String> c = parse(unb64url(p[1]));
        if (!c.get("iss").equals(ISSUER)) return "401 wrong issuer";
        if (!c.get("aud").equals(AUDIENCE)) return "401 token is for " + c.get("aud") + ", not " + AUDIENCE;
        long exp = Long.parseLong(c.get("exp"));
        if (exp + SKEW < NOW) return "401 expired " + (NOW - exp) + " s ago";
        if (!Arrays.asList(c.get("scope").split(" ")).contains(needed)) return "403 missing scope " + needed;
        return "200 ok, acting as " + c.get("sub");
    }

    public static void main(String[] args) {
        String valid = issue(claims());
        System.out.println("token: " + valid.substring(0, 60) + "...");
        System.out.println("signature: " + valid.split("\\.")[2]);
        String[] p = valid.split("\\.");
        Map<String, Object> edited = claims();
        edited.put("scope", "orders:read orders:write"); // the caller edits the claims and keeps the old signature
        String tampered = p[0] + "." + b64url(json(edited)) + "." + p[2];

        Map<String, Object> expired = claims(); expired.put("exp", NOW - 3600);
        Map<String, Object> other = claims(); other.put("aud", "billing-api");
        String[][] cases = {
            {"valid token, reading orders", valid, "orders:read"},
            {"expired an hour ago", issue(expired), "orders:read"},
            {"token meant for another API", issue(other), "orders:read"},
            {"valid token, but writing", valid, "orders:write"},
            {"scope edited by the caller", tampered, "orders:write"},
        };
        for (String[] k : cases) System.out.printf("%-30s -> %s%n", k[0], check(k[1], k[2]));
    }
}