#mooncred

// The key is whatever signs. Here, HMAC over SHA-256.
let key = @jwt.mac(fn() {
  @hmac.Hmac::new(secret[:], fn() { @sha2.Hasher::new() })
})

let token = @jwt.sign(claims, HS256, key)

// The algorithm is the caller's, not the token's.
let got = @jwt.verify(token[:], HS256, key, now=now_seconds,
                      issuer=Some("moonbitstack"), audience=Some("moonapi"))

#Packages

#The algorithm is not the token's to choose

• alg: none. A token with an empty signature that a verifier accepts because the token said not to check. There is no none in the Alg type, so there is nothing to accept.
• Algorithm confusion. A token signed with HMAC, keyed on the RSA public key that everybody has, offered to a verifier that reads alg from the header and obliges. Here the caller has already decided; the header must agree with it.

#Configuration precedence

@jwt.policy        <        the policy you pass        <        the arguments you pass

• wins turns the last two layers around. Base makes the policy authoritative and the arguments advisory.
• clash decides what happens when a setting is given twice: Ignore merges quietly, Panic refuses, and Handle(f) gives your function the base and the merged result and takes whichever it returns.

// A policy for the deployment, assembled once.
let ours = @jwt.Policy::new(issuer=Some("moonbitstack"), audience=["moonapi"])
// The same thing written as a record update.
let ours : @jwt.Policy = { ..@jwt.policy, issuer: Some("moonbitstack") }

// Used as it is, and used with one thing changed for this call.
@jwt.verify(token[:], HS256, key, now=At(seconds), policy=ours)
@jwt.verify(token[:], HS256, key, now=At(seconds), policy=ours, leeway=60L)

// Reading a token without asking whether it has expired.
@jwt.verify(token[:], HS256, key, now=Ignored)

#Keys are contracts, not implementations

match key.material() {
  Okp(x~, ..) => @ed25519.PublicKey::new(x[:])
  _ => …
}

#When a setting takes a bare value and when it takes Some

@jwt.Policy::new(issuer="https://issuer.example", leeway=30)
@jwt.verify(token[:], HS256, key, now=At(seconds), issuer="https://issuer.example")

@jwt.sign(claims, HS256, key)                      // typ: "JWT"
@jwt.sign(claims, HS256, key, typ=Some("at+jwt"))  // typ: "at+jwt"
@jwt.sign(claims, HS256, key, typ=None)            // no typ header

#Certificates

// Build one a TLS server can present. Self-signed, P-256, ES256.
let der = @x509.self_signed(key, serial, "example.test", "260101000000Z", "270101000000Z")

// Read one a peer sent.
let cert = @x509.parse(der[:])
cert.subject.cn()                 // Some("example.test")
cert.valid_at(now)                // both ends inclusive, as RFC 5280 gives them
cert.matches("a.example.test")    // RFC 6125 §6.4.3, wildcards included
cert.signed_by(issuer_key)        // raises rather than answering false for an
                                  // algorithm it did not check

#What is checked

#What is not here yet

#Install

moon add moonbitstack/mooncred

#Licence