Index

Modules: jose, jose/algs, jose/b64, jose/errors, jose/jwe, jose/jwk, jose/jws, jose/jwt, jose/kdf, jose/kw.

API symbols

A128CBC_HS256:

• algs: JweEnc.A128CBC_HS256

A128GCM:

• algs: JweEnc.A128GCM

A128GCMKW:

• algs: JweAlg.A128GCMKW

A128KW:

• algs: JweAlg.A128KW

A192CBC_HS384:

• algs: JweEnc.A192CBC_HS384

A192GCM:

• algs: JweEnc.A192GCM

A192GCMKW:

• algs: JweAlg.A192GCMKW

A192KW:

• algs: JweAlg.A192KW

A256CBC_HS512:

• algs: JweEnc.A256CBC_HS512

A256GCM:

• algs: JweEnc.A256GCM

A256GCMKW:

• algs: JweAlg.A256GCMKW

A256KW:

• algs: JweAlg.A256KW

aesKwUnwrap:

• kw: proc aesKwUnwrap(kek, wrapped: openArray[byte]): seq[byte]

aesKwWrap:

• kw: proc aesKwWrap(kek, keyData: openArray[byte]): seq[byte]

aud:

• jwt: proc aud(b: var JwtBuilder; v: string)

b64urlDecode:

• b64: proc b64urlDecode(s: string): seq[byte]

b64urlDecodeStr:

• b64: proc b64urlDecodeStr(s: string): string

b64urlEncode:

• b64: proc b64urlEncode(data: openArray[byte]): string
• b64: proc b64urlEncode(s: string): string

b64urlEncodeInt:

• b64: proc b64urlEncodeInt(v: openArray[byte]): string

C20P:

• algs: JweEnc.C20P

checkClaims:

• jwt: proc checkClaims(c: JwtChecker; claims: JsonNode): JsonNode

claim:

• jwt: proc claim(b: var JwtBuilder; name: string; value: bool)
• jwt: proc claim(b: var JwtBuilder; name: string; value: int64)
• jwt: proc claim(b: var JwtBuilder; name: string; value: JsonNode)
• jwt: proc claim(b: var JwtBuilder; name, value: string)

concatKdf:

• kdf: proc concatKdf(z: openArray[byte]; keyLenBits: int; algorithmId: string; apu: openArray[byte] = []; apv: openArray[byte] = []): seq[byte]

Dir:

• algs: JweAlg.Dir

ecCrvFromCurve:

• jwk: proc ecCrvFromCurve(c: EcCurve): string

ecCurveFromCrv:

• jwk: proc ecCurveFromCrv(s: string): EcCurve

ECDH_ES:

• algs: JweAlg.ECDH_ES

ECDH_ES_A128KW:

• algs: JweAlg.ECDH_ES_A128KW

ECDH_ES_A192KW:

• algs: JweAlg.ECDH_ES_A192KW

ECDH_ES_A256KW:

• algs: JweAlg.ECDH_ES_A256KW

EcdhKwAlgs:

• jwe: const EcdhKwAlgs

EdDSA:

• algs: JwsAlg.EdDSA

ES256:

• algs: JwsAlg.ES256

ES256K:

• algs: JwsAlg.ES256K

ES384:

• algs: JwsAlg.ES384

ES512:

• algs: JwsAlg.ES512

EsAlgs:

• jws: const EsAlgs

exp:

• jwt: proc exp(b: var JwtBuilder; v: int64)

hasPrivate:

• jwk: proc hasPrivate(key: Jwk): bool

HS256:

• algs: JwsAlg.HS256

HS384:

• algs: JwsAlg.HS384

HS512:

• algs: JwsAlg.HS512

HsAlgs:

• jws: const HsAlgs

iat:

• jwt: proc iat(b: var JwtBuilder; v: int64)

initJwtBuilder:

• jwt: proc initJwtBuilder(): JwtBuilder

initJwtChecker:

• jwt: proc initJwtChecker(leewaySeconds = 60'i64; issuer = ""; audience: seq[string] = @[]; requireExp = false; requireIat = false; required: seq[string] = @[]): JwtChecker

iss:

• jwt: proc iss(b: var JwtBuilder; v: string)

JoseError:

• errors: object JoseError

joseFail:

• errors: template joseFail(msg: string)

jti:

• jwt: proc jti(b: var JwtBuilder; v: string)

JweAlg:

• algs: enum JweAlg

jweDecrypt:

• jwe: proc jweDecrypt(token: string; key: Jwk; allowAlgs: openArray[JweAlg] = []; allowEncs: openArray[JweEnc] = []): JweDecrypted

JweDecrypted:

• jwe: object JweDecrypted

jweDecryptStr:

• jwe: proc jweDecryptStr(token: string; key: Jwk; allowAlgs: openArray[JweAlg] = []; allowEncs: openArray[JweEnc] = []): string

JweEnc:

• algs: enum JweEnc

jweEncrypt:

• jwe: proc jweEncrypt(alg: JweAlg; enc: JweEnc; key: Jwk; plaintext: openArray[byte]; protectedExtra: JsonNode = nil; apu: openArray[byte] = []; apv: openArray[byte] = []; p2c = 100000): string

Jwk:

• jwk: object Jwk

jwkEC:

• jwk: JwkKind.jwkEC

jwkEc:

• jwk: proc jwkEc(curve: EcCurve; x, y: BigInt; kid = ""): Jwk

jwkEcGenerate:

• jwk: proc jwkEcGenerate(curve: EcCurve; kid = ""): Jwk

jwkEcPrivate:

• jwk: proc jwkEcPrivate(curve: EcCurve; d: BigInt; kid = ""): Jwk

jwkEd25519Generate:

• jwk: proc jwkEd25519Generate(kid = ""): Jwk

jwkFromJson:

• jwk: proc jwkFromJson(node: JsonNode): Jwk

jwkFromJsonStr:

• jwk: proc jwkFromJsonStr(s: string): Jwk

JwkKind:

• jwk: enum JwkKind

jwkOct:

• jwk: JwkKind.jwkOct

jwkOctGenerate:

• jwk: proc jwkOctGenerate(bits = 256; kid = ""): Jwk

jwkOctKey:

• jwk: proc jwkOctKey(raw: openArray[byte]; kid = ""): Jwk

jwkOKP:

• jwk: JwkKind.jwkOKP

jwkOkpFromPub:

• jwk: proc jwkOkpFromPub(pub: array[32, byte]; kid = ""): Jwk

jwkOkpFromSeed:

• jwk: proc jwkOkpFromSeed(seed: array[32, byte]; kid = ""): Jwk

jwkOkpGenerate:

• jwk: proc jwkOkpGenerate(crv = "Ed25519"; kid = ""): Jwk

jwkPassword:

• jwk: proc jwkPassword(raw: openArray[byte]; kid = ""): Jwk

jwkRSA:

• jwk: JwkKind.jwkRSA

jwkRsa:

• jwk: proc jwkRsa(n, e: BigInt; kid = ""): Jwk

jwkRsaGenerate:

• jwk: proc jwkRsaGenerate(bits = 2048; kid = ""): Jwk

jwkRsaPrivate:

• jwk: proc jwkRsaPrivate(n, e, d, p, q: BigInt; kid = ""): Jwk

jwkRsaPrivateBare:

• jwk: proc jwkRsaPrivateBare(n, e, d: BigInt; kid = ""): Jwk

jwksFind:

• jwk: proc jwksFind(keys: openArray[Jwk]; kid: string): Jwk

jwksFromJson:

• jwk: proc jwksFromJson(node: JsonNode): seq[Jwk]

jwkThumbprint:

• jwk: proc jwkThumbprint(key: Jwk): string

jwkToJson:

• jwk: proc jwkToJson(key: Jwk; includePrivate = false): JsonNode

jwkToPublic:

• jwk: proc jwkToPublic(key: Jwk): Jwk

jwkX25519FromPub:

• jwk: proc jwkX25519FromPub(pub: array[32, byte]; kid = ""): Jwk

jwkX25519FromSeed:

• jwk: proc jwkX25519FromSeed(seed: array[32, byte]; kid = ""): Jwk

jwkX25519Generate:

• jwk: proc jwkX25519Generate(kid = ""): Jwk

JwsAlg:

• algs: enum JwsAlg

jwsSign:

• jws: proc jwsSign(alg: JwsAlg; key: Jwk; payload: openArray[byte]; protectedExtra: JsonNode = nil): string
• jws: proc jwsSign(alg: JwsAlg; key: Jwk; payload: string; protectedExtra: JsonNode = nil): string

JwsVerified:

• jws: object JwsVerified

jwsVerify:

• jws: proc jwsVerify(token: string; key: Jwk; allowAlgs: openArray[JwsAlg] = []; allowNone = false): JwsVerified

jwsVerifyStr:

• jws: proc jwsVerifyStr(token: string; key: Jwk; allowAlgs: openArray[JwsAlg] = []; allowNone = false): string

JwtBuilder:

• jwt: object JwtBuilder

JwtChecker:

• jwt: object JwtChecker

jwtDecrypt:

• jwt: proc jwtDecrypt(token: string; key: Jwk; c: JwtChecker; allowAlgs: openArray[JweAlg] = []; allowEncs: openArray[JweEnc] = []): JsonNode

jwtEncrypt:

• jwt: proc jwtEncrypt(b: JwtBuilder; alg: JweAlg; enc: JweEnc; key: Jwk; protectedExtra: JsonNode = nil; apu: openArray[byte] = []; apv: openArray[byte] = []; p2c = 100000): string

jwtSign:

• jwt: proc jwtSign(b: JwtBuilder; alg: JwsAlg; key: Jwk; protectedExtra: JsonNode = nil): string

jwtVerify:

• jwt: proc jwtVerify(token: string; key: Jwk; c: JwtChecker; allowAlgs: openArray[JwsAlg] = []): JsonNode

KwAlgs:

• jwe: const KwAlgs

nbf:

• jwt: proc nbf(b: var JwtBuilder; v: int64)

parseJweAlg:

• algs: proc parseJweAlg(s: string): JweAlg

parseJweEnc:

• algs: proc parseJweEnc(s: string): JweEnc

parseJwsAlg:

• algs: proc parseJwsAlg(s: string): JwsAlg

pbes2Derive:

• kdf: proc pbes2Derive(password: openArray[byte]; alg: JweAlg; p2s: openArray[byte]; p2c: int; hashBits: int; kekLen: int): seq[byte]

pbes2HashBits:

• kdf: proc pbes2HashBits(alg: JweAlg): int

PBES2_HS256_A128KW:

• algs: JweAlg.PBES2_HS256_A128KW

PBES2_HS384_A192KW:

• algs: JweAlg.PBES2_HS384_A192KW

PBES2_HS512_A256KW:

• algs: JweAlg.PBES2_HS512_A256KW

pbes2Salt:

• kdf: proc pbes2Salt(alg: JweAlg; p2s: openArray[byte]): seq[byte]

PS256:

• algs: JwsAlg.PS256

PS384:

• algs: JwsAlg.PS384

PS512:

• algs: JwsAlg.PS512

PsAlgs:

• jws: const PsAlgs

requireRsaCrt:

• jwk: proc requireRsaCrt(key: Jwk)

RS256:

• algs: JwsAlg.RS256

RS384:

• algs: JwsAlg.RS384

RS512:

• algs: JwsAlg.RS512

RSA1_5:

• algs: JweAlg.RSA1_5

RsAlgs:

• jws: const RsAlgs

RSA_OAEP:

• algs: JweAlg.RSA_OAEP

RSA_OAEP_256:

• algs: JweAlg.RSA_OAEP_256

sub:

• jwt: proc sub(b: var JwtBuilder; v: string)