bend-kit-jwt Releases (14): 0.11.0.1 0x9ed0050acb7e380a471cbeb97c648c0e indexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.11.0.1 0.11.0.0 0xb450b112042c48bd0240210f062e61ac unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.11.0.0 0.10.0.0 0x116830fb77dd76b072a61277c32996d7 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.10.0.0 0.9.0.0 0xd6c0f0d8546404e14222c2fbf45e11ef unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.9.0.0 0.8.0.0 0x4f813b5cac8b46c9fe87b9609af6451c unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.8.0.0 0.7.1.0 0x01311e71c862efd59bf9884b77a5a867 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.7.1.0 0.7.0.0 0xd9bc3294f13f4f9928909c2bd9dc9674 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.7.0.0 0.6.0.0 0x3b8a16391b1ced409a6951a5894a7469 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.6.0.0 0.5.0.0 0x6b8fdfb90f5c486171091b907e0b3a08 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.5.0.0 0.4.0.0 0x96c85ccdc5e58cdfb6b6577b2ac996d0 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.4.0.0 0.3.0.1 0xc4de8c229f311dba4a977dd20e5388ac unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.3.0.1 0.3.0.0 0x6d4c334fd9896a11004241bec804c46e unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.3.0.0 0.2.0.0 0x876da6c7de4c45f59dadc9ba6c66b8a2 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.2.0.0 0.1.0.0 0x636ea893a9783fd58cf8c992361342a7 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-jwt@0.1.0.0 Definitions (122, 1 to 100 shown): Jwt.Alg (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=Alg) type Alg is Data: HS256{} HS384{} HS512{} RS256{} ES256{} Jwt.Key (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=Key) # Hmac: the shared secret, at least the digest's size (RFC 7518 §3.2). # Pem: a PEM "PUBLIC KEY" to verify, or an unencrypted PEM private key to sign. # Rsa, Ec: JWK public key parts as big-endian octets (RFC 7518 §6.3, §6.2 on P-256). type Key is Type: Hmac{secret: Bytes.Bytes} Pem{pem: Bytes.Bytes} Rsa{n: Bytes.Bytes, e: Bytes.Bytes} Ec{x: Bytes.Bytes, y: Bytes.Bytes} Jwt.Err (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=Err) type Err is Data: Malformed{} AlgMismatch{} Crit{} KeyType{} WeakKey{} BadSig{} BadClaim{} Expired{} NotYet{} Future{} … Jwt.Policy (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=Policy) # What verify accepts: the one alg, the issuer and audience when Some, and leeway seconds of clock skew. type Policy is Data: Policy{alg: Alg, iss: Maybe<&2, String>, aud: Maybe<&2, String>, leeway: U32} Jwt.policy (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=policy) def policy(a: Alg) -> Policy: Jwt.iss (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=iss) def iss(p: Policy, s: String) -> Policy: Jwt.aud (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=aud) def aud(p: Policy, s: String) -> Policy: Jwt.leeway (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=leeway) def leeway(p: Policy, +n: U32) -> Policy: Jwt.policy.alg (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=policy.alg) def policy.alg(p: Policy) -> Alg: Jwt.alg.name (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=alg.name) def alg.name(a: Alg) -> String: Jwt.b64u.push (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=b64u.push) def b64u.push(+c: U32, acc: String) -> String: Jwt.b64u.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=b64u.go) def b64u.go(s: String, acc: String) -> String: Jwt.b64u (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=b64u) def b64u(b: Bytes.Bytes) -> String: Jwt.unb64u.c (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=unb64u.c) # The standard alphabet's char for c. '+', '/', '=' and NUL become NUL, which no decoder accepts. def unb64u.c(+c: U32) -> U32: Jwt.unb64u.pad (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=unb64u.pad) # Padding for n mod 4 chars; 1 is never a whole group, so it gets a NUL. def unb64u.pad(+r: U32, acc: String) -> String: Jwt.unb64u.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=unb64u.go) def unb64u.go(s: String, acc: String, +n: U32) -> String: Jwt.unb64u.same (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=unb64u.same) def unb64u.same(+s: String, r: Bytes.Bytes & Bytes.Bytes) -> Maybe<&1, Bytes.Bytes>: Jwt.unb64u.canon (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=unb64u.canon) def unb64u.canon(+s: String, m: Maybe<&1, Bytes.Bytes>) -> Maybe<&1, Bytes.Bytes>: Jwt.unb64u (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=unb64u) # Strict: only the URL-safe alphabet, no '=', and only the canonical text of its octets, so pad bits are 0. def unb64u(+s: String) -> Maybe<&1, Bytes.Bytes>: Jwt.Lit (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=Lit) # A NumericDate (RFC 7519 §2) rounded up to whole seconds and capped at the U32 top, or None when it is # negative or has an exponent. Up is exact against a whole now: now >= t iff now >= ceil(t). type Lit is Data: LStr{s: String} LNum{t: Maybe<&2, U32>} LStrs{xs: Maybe<&2, List<&2, String>>} LOther{} Jwt.Field (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=Field) # One member: its name as octets, and what the checks need of its value. type Field is Data: Field{name: String, val: Lit} Jwt.secs.digit (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=secs.digit) def secs.digit(+acc: U32, +d: U32) -> U32: Jwt.secs.up (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=secs.up) def secs.up(+acc: U32, frac: Bool) -> U32: Jwt.secs.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=secs.go) # The JSON parser has checked the grammar, so only digits and one '.' need telling apart. def secs.go(s: String, +acc: U32, +frac: Bool, +point: Bool, +ok: Bool) -> Maybe<&2, U32>: Jwt.secs (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=secs) def secs(s: String) -> Maybe<&2, U32>: Jwt.str.of (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=str.of) def str.of(v: Json.Val) -> Maybe<&2, String>: Jwt.strs.push (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=strs.push) def strs.push(s: Maybe<&2, String>, acc: Maybe<&2, List<&2, String>>) -> Maybe<&2, List<&2, String>>: Jwt.strs (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=strs) def strs(xs: List<&1, Json.Val>, acc: Maybe<&2, List<&2, String>>) -> Maybe<&2, List<&2, String>>: Jwt.lit (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=lit) def lit(v: Json.Val) -> Lit: Jwt.fields (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=fields) # An object's members, names as octets, last first. def fields(kvs: List<&1, Bytes.Bytes & Json.Val>, acc: List<&2, Field>) -> List<&2, Field>: Jwt.field (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=field) def field(l: List<&2, Field>, +k: String) -> Maybe<&2, Lit>: Jwt.has (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=has) def has(l: List<&2, Field>, +k: String) -> Bool: Jwt.str (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=str) def str(m: Maybe<&2, Lit>) -> Maybe<&2, String>: Jwt.Parts (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=Parts) # A compact JWS: the header and claim members, the claims, the signing input, and the signature. type Parts is Type: Parts{head: List<&2, Field>, facts: List<&2, Field>, claims: Json.Val, input: Bytes.Bytes, sig: Bytes.Bytes} Jwt.parse.json (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=parse.json) # RFC 7515 §5.2 allows rejecting repeated names; a second "alg" is how parsers come to disagree. # parse.claims rejects them at every depth with Json.unique.parsed before members get here. def parse.json(h: Maybe<&1, Json.Val>, f: Maybe<&1, Json.Val>, c: Maybe<&1, Json.Val>, input: Bytes.Bytes, sig: Bytes.Bytes) -> Result<&1, &1, Err, Parts>: Jwt.parse.claims (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=parse.claims) def parse.claims(hb: Bytes.Bytes, r: Bytes.Bytes & Bytes.Bytes, input: Bytes.Bytes, sig: Bytes.Bytes) -> Result<&1, &1, Err, Parts>: Jwt.parse.segs (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=parse.segs) def parse.segs(h: Maybe<&1, Bytes.Bytes>, c: Maybe<&1, Bytes.Bytes>, s: Maybe<&1, Bytes.Bytes>, input: Bytes.Bytes) -> Result<&1, &1, Err, Parts>: Jwt.parse.split (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=parse.split) def parse.split(xs: List<&2, String>) -> Result<&1, &1, Err, Parts>: Jwt.parse (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=parse) # Three strict base64url segments, the first two JSON objects with no repeated names. def parse(token: String) -> Result<&1, &1, Err, Parts>: Jwt.fail.if (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=fail.if) def fail.if(bad: Bool, +e: Err) -> Result<&1, &1, Err, Unit>: Jwt.head.alg (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=head.alg) def head.alg(m: Maybe<&2, Lit>) -> Result<&1, &1, Err, String>: Jwt.head.check (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=head.check) # The header's alg is exactly the pinned one, and it asks for no extension: crit (RFC 7515 §4.1.11) and # b64 (RFC 7797) change how the token must be read, and neither is implemented. def head.check(+a: Alg, +h: List<&2, Field>) -> Result<&1, &1, Err, Unit>: Jwt.when (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=when) def when(m: Maybe<&2, Lit>) -> Result<&1, &1, Err, Maybe<&2, U32>>: Jwt.text (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=text) def text(m: Maybe<&2, Lit>) -> Result<&1, &1, Err, Maybe<&2, String>>: Jwt.auds (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=auds) # RFC 7519 §4.1.3: aud is one string or an array of them. def auds(m: Maybe<&2, Lit>) -> Result<&1, &1, Err, Maybe<&2, List<&2, String>>>: Jwt.late (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=late) # exp (RFC 7519 §4.1.4): now must be before it; late by at least leeway fails. def late(+now: U32, +lw: U32, m: Maybe<&2, U32>) -> Bool: Jwt.early (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=early) # nbf and iat: at most leeway seconds in the future. def early(+now: U32, +lw: U32, m: Maybe<&2, U32>) -> Bool: Jwt.octets (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=octets) def octets(s: String) -> String: Jwt.iss.bad (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=iss.bad) def iss.bad(want: Maybe<&2, String>, got: Maybe<&2, String>) -> Bool: Jwt.aud.has (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=aud.has) def aud.has(l: List<&2, String>, +a: String) -> Bool: Jwt.aud.bad (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=aud.bad) # RFC 7519 §4.1.3: a token with an aud that does not name us fails, as does one without aud when we want one. def aud.bad(want: Maybe<&2, String>, got: Maybe<&2, List<&2, String>>) -> Bool: Jwt.claims.check (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=claims.check) # The registered claims of c at unix time now. def claims.check(p: Policy, +now: U32, +c: List<&2, Field>) -> Result<&1, &1, Err, Unit>: Jwt.inspect.parts (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=inspect.parts) def inspect.parts(+p: Policy, +now: U32, r: Result<&1, &1, Err, Parts>) -> Result<&1, &1, Err, Unit>: Jwt.inspect (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=inspect) # The header and claims of token, without its signature: the pure half of verify. def inspect(p: Policy, token: String, +now: U32) -> Result<&1, &1, Err, Unit>: Jwt.crypto.bytes (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=crypto.bytes) def crypto.bytes(r: Result<&1, &1, U32 & String, U32 & Array>) -> Result<&1, &1, Err, Bytes.Bytes>: Jwt.crypto.ok (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=crypto.ok) def crypto.ok(r: Result<&1, &1, U32 & String, Bool>) -> Result<&1, &1, Err, Bool>: Jwt.mac.if (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=mac.if) def mac.if(weak: Bool, +alg: String, +kn: U32, kb: Array, +dn: U32, db: Array) -> IO(Result<&1, &1, Err, Bytes.Bytes>): Jwt.mac (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=mac) def mac(+alg: String, +min: U32, k: Bytes.Bytes, input: Bytes.Bytes) -> IO(Result<&1, &1, Err, Bytes.Bytes>): Jwt.mac.cmp (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=mac.cmp) def mac.cmp(m: Result<&1, &1, Err, Bytes.Bytes>, sig: Bytes.Bytes) -> IO(Result<&1, &1, Err, Bool>): Jwt.mac.check (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=mac.check) # The MAC compares in constant time. def mac.check(+alg: String, +min: U32, k: Bytes.Bytes, input: Bytes.Bytes, sig: Bytes.Bytes) -> IO(Result<&1, &1, Err, Bool>): Jwt.rsa.pem (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=rsa.pem) def rsa.pem(p: Bytes.Bytes, input: Bytes.Bytes, sig: Bytes.Bytes) -> IO(Result<&1, &1, Err, Bool>): Jwt.rsa.jwk (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=rsa.jwk) def rsa.jwk(n: Bytes.Bytes, e: Bytes.Bytes, input: Bytes.Bytes, sig: Bytes.Bytes) -> IO(Result<&1, &1, Err, Bool>): Jwt.ec.pem (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=ec.pem) def ec.pem(p: Bytes.Bytes, input: Bytes.Bytes, sig: Bytes.Bytes) -> IO(Result<&1, &1, Err, Bool>): Jwt.ec.jwk (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=ec.jwk) def ec.jwk(x: Bytes.Bytes, y: Bytes.Bytes, input: Bytes.Bytes, sig: Bytes.Bytes) -> IO(Result<&1, &1, Err, Bool>): Jwt.sig.check (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=sig.check) # Does sig sign input under key for alg? A key of the wrong kind fails with KeyType before any crypto. def sig.check(a: Alg, key: Key, input: Bytes.Bytes, sig: Bytes.Bytes) -> IO(Result<&1, &1, Err, Bool>): Jwt.rsa.sign (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=rsa.sign) def rsa.sign(p: Bytes.Bytes, input: Bytes.Bytes) -> IO(Result<&1, &1, Err, Bytes.Bytes>): Jwt.ec.sign (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=ec.sign) def ec.sign(p: Bytes.Bytes, input: Bytes.Bytes) -> IO(Result<&1, &1, Err, Bytes.Bytes>): Jwt.sig.make (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=sig.make) # The signature of input under key for alg. RS256 and ES256 sign with a PEM private key. def sig.make(a: Alg, key: Key, input: Bytes.Bytes) -> IO(Result<&1, &1, Err, Bytes.Bytes>): Jwt.header.kid (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=header.kid) def header.kid(m: Maybe<&2, String>) -> List<&1, Bytes.Bytes & Json.Val>: Jwt.header (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=header) # {"alg":..,"typ":"JWT"}, then "kid" when given. def header(a: Alg, kid: Maybe<&2, String>) -> Json.Val: Jwt.signing.input (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=signing.input) # header.body in base64url, body being the compact JSON claims: the text the signature covers. def signing.input(a: Alg, kid: Maybe<&2, String>, body: Bytes.Bytes) -> String: Jwt.sign.done (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=sign.done) def sign.done(+input: String, s: Result<&1, &1, Err, Bytes.Bytes>) -> Result<&1, &1, Err, String>: Jwt.sign.obj (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=sign.obj) # verify accepts only an object with no repeated names, so sign makes no other kind. def sign.obj(m: Maybe<&1, Json.Val>) -> Bool: Jwt.sign.if (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=sign.if) def sign.if(ok: Bool, +a: Alg, key: Key, kid: Maybe<&2, String>, body: Bytes.Bytes) -> IO(Result<&1, &1, Err, String>): Jwt.sign.body (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=sign.body) def sign.body(+a: Alg, key: Key, kid: Maybe<&2, String>, r: Bytes.Bytes & Bytes.Bytes) -> IO(Result<&1, &1, Err, String>): Jwt.sign (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=sign) # A compact token of claims signed with key for a; kid names the key in the header. Claims that are not # an object, or repeat a name, fail with BadClaim. def sign(+a: Alg, key: Key, kid: Maybe<&2, String>, claims: Json.Val) -> IO(Result<&1, &1, Err, String>): Jwt.claims.done (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=claims.done) def claims.done(r: Result<&1, &1, Err, Unit>, v: Json.Val) -> Result<&1, &1, Err, Json.Val>: Jwt.check.sig (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=check.sig) def check.sig(ok: Bool, +p: Policy, +now: U32, +f: List<&2, Field>, v: Json.Val) -> Result<&1, &1, Err, Json.Val>: Jwt.check.done (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=check.done) def check.done(s: Result<&1, &1, Err, Bool>, +p: Policy, +now: U32, +f: List<&2, Field>, v: Json.Val) -> Result<&1, &1, Err, Json.Val>: Jwt.check.pinned (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=check.pinned) def check.pinned(ok: Result<&1, &1, Err, Unit>, +p: Policy, key: Key, +now: U32, +f: List<&2, Field>, v: Json.Val, input: Bytes.Bytes, sig: Bytes.Bytes) -> IO(Result<&1, &1, Err, Json.Val>): Jwt.check (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=check) # The pinned alg, then the signature, then the claims. def check(+p: Policy, key: Key, +now: U32, parts: Parts) -> IO(Result<&1, &1, Err, Json.Val>): Jwt.verify.parsed (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=verify.parsed) def verify.parsed(+p: Policy, key: Key, +now: U32, r: Result<&1, &1, Err, Parts>) -> IO(Result<&1, &1, Err, Json.Val>): Jwt.verify (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=verify) # The claims of token when it is signed by key under p's alg and its claims hold at unix time now. def verify(+p: Policy, key: Key, token: String, +now: U32) -> IO(Result<&1, &1, Err, Json.Val>): Jwt.Jwk (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=Jwk) # A usable public key from a set: its kid, RSA or EC P-256, its alg ("" when the set gives none), and its # two base64url parts (n and e, or x and y). type Jwk is Data: Jwk{kid: String, rsa: Bool, alg: String, a: String, b: String} Jwt.jwk.two (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwk.two) def jwk.two(+rsa: Bool, +kid: String, +alg: String, a: Maybe<&2, String>, b: Maybe<&2, String>) -> Maybe<&2, Jwk>: Jwt.jwk.alg (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwk.alg) # An alg member that is not a string can match no pinned alg. def jwk.alg(m: Maybe<&2, Lit>) -> String: Jwt.jwk.use (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwk.use) def jwk.use(m: Maybe<&2, Lit>) -> Maybe<&2, Unit>: Jwt.jwk.kty (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwk.kty) def jwk.kty(+kty: String, +kid: String, +f: List<&2, Field>) -> Maybe<&2, Jwk>: Jwt.jwk.fields (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwk.fields) def jwk.fields(+f: List<&2, Field>) -> Maybe<&2, Jwk>: Jwt.jwk.obj (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwk.obj) def jwk.obj(m: Maybe<&1, Json.Val>) -> Maybe<&2, Jwk>: Jwt.jwk.of (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwk.of) # A key whose members repeat a name, at any depth, is skipped. def jwk.of(v: Json.Val) -> Maybe<&2, Jwk>: Jwt.jwk.push (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwk.push) def jwk.push(m: Maybe<&2, Jwk>, acc: List<&2, Jwk>) -> List<&2, Jwk>: Jwt.jwks.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwks.go) def jwks.go(xs: List<&1, Json.Val>, acc: List<&2, Jwk>) -> List<&2, Jwk>: Jwt.jwks.arr (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwks.arr) def jwks.arr(m: Maybe<&1, Json.Val>) -> Maybe<&2, List<&2, Jwk>>: Jwt.jwks.doc (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwks.doc) def jwks.doc(m: Maybe<&1, Json.Val>) -> Maybe<&2, List<&2, Jwk>>: Jwt.jwks.parse (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwks.parse) # The signing keys of a JWK Set document; members it cannot use (enc keys, other curves, oct) are skipped. # None when the document is not {"keys": [...]}. def jwks.parse(b: Bytes.Bytes) -> Maybe<&2, List<&2, Jwk>>: Jwt.fam (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=fam) def fam(a: Alg) -> U32: Jwt.jwk.fits (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwk.fits) def jwk.fits(k: Jwk, +kid: String, +a: Alg) -> Bool: Jwt.jwk.pick (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwk.pick) # The first key named kid that can check alg a. RFC 7515 §4.1.4 leaves kid matching to exact comparison. def jwk.pick(ks: List<&2, Jwk>, +kid: String, +a: Alg) -> Maybe<&2, Jwk>: Jwt.jwk.key.of (https://jend.leeeet.dev/definition.txt?path=bend-kit-jwt@0.11.0.1/jwt.bend&name=jwk.key.of) def jwk.key.of(rsa: Bool, a: Maybe<&1, Bytes.Bytes>, b: Maybe<&1, Bytes.Bytes>) -> Result<&1, &1, Err, Key>: More: https://jend.leeeet.dev/packages/bend-kit-jwt.txt?definitions_offset=100