From aa9b70483cbc5084cd8277b2d44fb9d830bb982e Mon Sep 17 00:00:00 2001 From: Juanra Dikal Date: Tue, 30 Nov 2021 23:25:07 +0100 Subject: [PATCH] added missing files --- .gitignore | 3 + .vscode/settings.json | 3 + CODE_OF_CONDUCT.md | 134 ++ build/rollup-plugin-dts.js | 42 + dist/bundles/esm.js | 2130 ++++++++++++++++++++++++++++++++ dist/bundles/esm.min.js | 1 + dist/bundles/iife.js | 1 + dist/bundles/umd.js | 1 + docs/interfaces/PoO.md | 64 + docs/interfaces/PoR.md | 58 + types/createProofs.d.ts | 43 + types/createProofs.d.ts.map | 1 + types/index.d.ts | 13 + types/index.d.ts.map | 1 + types/proofInterfaces.d.ts | 62 + types/proofInterfaces.d.ts.map | 1 + types/sha.d.ts | 4 + types/sha.d.ts.map | 1 + types/validateProofs.d.ts | 32 + types/validateProofs.d.ts.map | 1 + 20 files changed, 2596 insertions(+) create mode 100644 .vscode/settings.json create mode 100644 CODE_OF_CONDUCT.md create mode 100644 build/rollup-plugin-dts.js create mode 100644 dist/bundles/esm.js create mode 100644 dist/bundles/esm.min.js create mode 100644 dist/bundles/iife.js create mode 100644 dist/bundles/umd.js create mode 100644 docs/interfaces/PoO.md create mode 100644 docs/interfaces/PoR.md create mode 100644 types/createProofs.d.ts create mode 100644 types/createProofs.d.ts.map create mode 100644 types/index.d.ts create mode 100644 types/index.d.ts.map create mode 100644 types/proofInterfaces.d.ts create mode 100644 types/proofInterfaces.d.ts.map create mode 100644 types/sha.d.ts create mode 100644 types/sha.d.ts.map create mode 100644 types/validateProofs.d.ts create mode 100644 types/validateProofs.d.ts.map diff --git a/.gitignore b/.gitignore index f9daa2f..31e08cb 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,6 @@ coverage # Test temporal files .mocha-ts + +# docs temporal files +.nojekyll diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..3662b37 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "typescript.tsdk": "node_modules/typescript/lib" +} \ No newline at end of file diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..d33878e --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,134 @@ + +# Contributor Covenant Code of Conduct + +## Our Pledge + +We as members, contributors, and leaders pledge to make participation in our +community a harassment-free experience for everyone, regardless of age, body +size, visible or invisible disability, ethnicity, sex characteristics, gender +identity and expression, level of experience, education, socio-economic status, +nationality, personal appearance, race, caste, color, religion, or sexual +identity and orientation. + +We pledge to act and interact in ways that contribute to an open, welcoming, +diverse, inclusive, and healthy community. + +## Our Standards + +Examples of behavior that contributes to a positive environment for our +community include: + +* Demonstrating empathy and kindness toward other people +* Being respectful of differing opinions, viewpoints, and experiences +* Giving and gracefully accepting constructive feedback +* Accepting responsibility and apologizing to those affected by our mistakes, + and learning from the experience +* Focusing on what is best not just for us as individuals, but for the overall + community + +Examples of unacceptable behavior include: + +* The use of sexualized language or imagery, and sexual attention or advances of + any kind +* Trolling, insulting or derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or email address, + without their explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Enforcement Responsibilities + +Community leaders are responsible for clarifying and enforcing our standards of +acceptable behavior and will take appropriate and fair corrective action in +response to any behavior that they deem inappropriate, threatening, offensive, +or harmful. + +Community leaders have the right and responsibility to remove, edit, or reject +comments, commits, code, wiki edits, issues, and other contributions that are +not aligned to this Code of Conduct, and will communicate reasons for moderation +decisions when appropriate. + +## Scope + +This Code of Conduct applies within all community spaces, and also applies when +an individual is officially representing the community in public spaces. +Examples of representing our community include using an official e-mail address, +posting via an official social media account, or acting as an appointed +representative at an online or offline event. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported to the community leaders responsible for enforcement at +[INSERT CONTACT METHOD]. +All complaints will be reviewed and investigated promptly and fairly. + +All community leaders are obligated to respect the privacy and security of the +reporter of any incident. + +## Enforcement Guidelines + +Community leaders will follow these Community Impact Guidelines in determining +the consequences for any action they deem in violation of this Code of Conduct: + +### 1. Correction + +**Community Impact**: Use of inappropriate language or other behavior deemed +unprofessional or unwelcome in the community. + +**Consequence**: A private, written warning from community leaders, providing +clarity around the nature of the violation and an explanation of why the +behavior was inappropriate. A public apology may be requested. + +### 2. Warning + +**Community Impact**: A violation through a single incident or series of +actions. + +**Consequence**: A warning with consequences for continued behavior. No +interaction with the people involved, including unsolicited interaction with +those enforcing the Code of Conduct, for a specified period of time. This +includes avoiding interactions in community spaces as well as external channels +like social media. Violating these terms may lead to a temporary or permanent +ban. + +### 3. Temporary Ban + +**Community Impact**: A serious violation of community standards, including +sustained inappropriate behavior. + +**Consequence**: A temporary ban from any sort of interaction or public +communication with the community for a specified period of time. No public or +private interaction with the people involved, including unsolicited interaction +with those enforcing the Code of Conduct, is allowed during this period. +Violating these terms may lead to a permanent ban. + +### 4. Permanent Ban + +**Community Impact**: Demonstrating a pattern of violation of community +standards, including sustained inappropriate behavior, harassment of an +individual, or aggression toward or disparagement of classes of individuals. + +**Consequence**: A permanent ban from any sort of public interaction within the +community. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], +version 2.1, available at +[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1]. + +Community Impact Guidelines were inspired by +[Mozilla's code of conduct enforcement ladder][Mozilla CoC]. + +For answers to common questions about this code of conduct, see the FAQ at +[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at +[https://www.contributor-covenant.org/translations][translations]. + +[homepage]: https://www.contributor-covenant.org +[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html +[Mozilla CoC]: https://github.com/mozilla/diversity +[FAQ]: https://www.contributor-covenant.org/faq +[translations]: https://www.contributor-covenant.org/translations + diff --git a/build/rollup-plugin-dts.js b/build/rollup-plugin-dts.js new file mode 100644 index 0000000..e9583cf --- /dev/null +++ b/build/rollup-plugin-dts.js @@ -0,0 +1,42 @@ +import { mkdirSync, readFileSync, writeFileSync } from 'fs' +import ts from 'typescript' +import { join, dirname } from 'path' +import { sync } from 'rimraf' + +const { readJsonConfigFile, sys, parseJsonSourceFileConfigFileContent, createCompilerHost, createProgram } = ts + +const rootDir = join(__dirname, '..') +const pkgJson = JSON.parse(readFileSync(join(rootDir, 'package.json'))) +const srcFile = join(rootDir, 'src/ts/index.ts') +const outDir = dirname(join(rootDir, pkgJson.types)) + +const tsConfigPath = join(rootDir, 'tsconfig.json') + +const configFile = readJsonConfigFile(tsConfigPath, (file) => { + return sys.readFile(file) +}) + +const tsConfig = parseJsonSourceFileConfigFileContent(configFile, sys, dirname(tsConfigPath)) + +const compilerOptions = { + ...tsConfig.options, + declaration: true, + declarationMap: true, + emitDeclarationOnly: true, + outDir +} + +const host = createCompilerHost(compilerOptions) + +host.writeFile = (fileName, contents) => { + mkdirSync(dirname(fileName), { recursive: true }) + writeFileSync(fileName, contents) +} + +export const compile = () => { + // Clear the types dir + sync(outDir) + // Prepare and emit the d.ts files + const program = createProgram([srcFile], compilerOptions, host) + program.emit() +} diff --git a/dist/bundles/esm.js b/dist/bundles/esm.js new file mode 100644 index 0000000..160cb2b --- /dev/null +++ b/dist/bundles/esm.js @@ -0,0 +1,2130 @@ +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); +const MAX_INT32 = 2 ** 32; +function concat(...buffers) { + const size = buffers.reduce((acc, { length }) => acc + length, 0); + const buf = new Uint8Array(size); + let i = 0; + buffers.forEach((buffer) => { + buf.set(buffer, i); + i += buffer.length; + }); + return buf; +} +function p2s(alg, p2sInput) { + return concat(encoder.encode(alg), new Uint8Array([0]), p2sInput); +} +function writeUInt32BE(buf, value, offset) { + if (value < 0 || value >= MAX_INT32) { + throw new RangeError(`value must be >= 0 and <= ${MAX_INT32 - 1}. Received ${value}`); + } + buf.set([value >>> 24, value >>> 16, value >>> 8, value & 0xff], offset); +} +function uint64be(value) { + const high = Math.floor(value / MAX_INT32); + const low = value % MAX_INT32; + const buf = new Uint8Array(8); + writeUInt32BE(buf, high, 0); + writeUInt32BE(buf, low, 4); + return buf; +} +function uint32be(value) { + const buf = new Uint8Array(4); + writeUInt32BE(buf, value); + return buf; +} +function lengthAndInput(input) { + return concat(uint32be(input.length), input); +} +async function concatKdf(digest, secret, bits, value) { + const iterations = Math.ceil((bits >> 3) / 32); + let res; + for (let iter = 1; iter <= iterations; iter++) { + const buf = new Uint8Array(4 + secret.length + value.length); + buf.set(uint32be(iter)); + buf.set(secret, 4); + buf.set(value, 4 + secret.length); + if (!res) { + res = await digest('sha256', buf); + } + else { + res = concat(res, await digest('sha256', buf)); + } + } + res = res.slice(0, bits >> 3); + return res; +} + +const encodeBase64 = (input) => { + let unencoded = input; + if (typeof unencoded === 'string') { + unencoded = encoder.encode(unencoded); + } + const CHUNK_SIZE = 0x8000; + const arr = []; + for (let i = 0; i < unencoded.length; i += CHUNK_SIZE) { + arr.push(String.fromCharCode.apply(null, unencoded.subarray(i, i + CHUNK_SIZE))); + } + return btoa(arr.join('')); +}; +const encode = (input) => { + return encodeBase64(input).replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_'); +}; +const decodeBase64 = (encoded) => { + return new Uint8Array(atob(encoded) + .split('') + .map((c) => c.charCodeAt(0))); +}; +const decode = (input) => { + let encoded = input; + if (encoded instanceof Uint8Array) { + encoded = decoder.decode(encoded); + } + encoded = encoded.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, ''); + try { + return decodeBase64(encoded); + } + catch (_a) { + throw new TypeError('The input to be decoded is not correctly encoded.'); + } +}; + +class JOSEError extends Error { + constructor(message) { + var _a; + super(message); + this.code = 'ERR_JOSE_GENERIC'; + this.name = this.constructor.name; + (_a = Error.captureStackTrace) === null || _a === void 0 ? void 0 : _a.call(Error, this, this.constructor); + } + static get code() { + return 'ERR_JOSE_GENERIC'; + } +} +class JOSEAlgNotAllowed extends JOSEError { + constructor() { + super(...arguments); + this.code = 'ERR_JOSE_ALG_NOT_ALLOWED'; + } + static get code() { + return 'ERR_JOSE_ALG_NOT_ALLOWED'; + } +} +class JOSENotSupported extends JOSEError { + constructor() { + super(...arguments); + this.code = 'ERR_JOSE_NOT_SUPPORTED'; + } + static get code() { + return 'ERR_JOSE_NOT_SUPPORTED'; + } +} +class JWEDecryptionFailed extends JOSEError { + constructor() { + super(...arguments); + this.code = 'ERR_JWE_DECRYPTION_FAILED'; + this.message = 'decryption operation failed'; + } + static get code() { + return 'ERR_JWE_DECRYPTION_FAILED'; + } +} +class JWEInvalid extends JOSEError { + constructor() { + super(...arguments); + this.code = 'ERR_JWE_INVALID'; + } + static get code() { + return 'ERR_JWE_INVALID'; + } +} +class JWSInvalid extends JOSEError { + constructor() { + super(...arguments); + this.code = 'ERR_JWS_INVALID'; + } + static get code() { + return 'ERR_JWS_INVALID'; + } +} +class JWKInvalid extends JOSEError { + constructor() { + super(...arguments); + this.code = 'ERR_JWK_INVALID'; + } + static get code() { + return 'ERR_JWK_INVALID'; + } +} +class JWSSignatureVerificationFailed extends JOSEError { + constructor() { + super(...arguments); + this.code = 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED'; + this.message = 'signature verification failed'; + } + static get code() { + return 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED'; + } +} + +var crypto$1 = crypto; +function isCryptoKey(key) { + try { + return (key != null && + typeof key.extractable === 'boolean' && + typeof key.algorithm.name === 'string' && + typeof key.type === 'string'); + } + catch (_a) { + return false; + } +} + +var random = crypto$1.getRandomValues.bind(crypto$1); + +function bitLength$1(alg) { + switch (alg) { + case 'A128GCM': + case 'A128GCMKW': + case 'A192GCM': + case 'A192GCMKW': + case 'A256GCM': + case 'A256GCMKW': + return 96; + case 'A128CBC-HS256': + case 'A192CBC-HS384': + case 'A256CBC-HS512': + return 128; + default: + throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`); + } +} +var generateIv = (alg) => random(new Uint8Array(bitLength$1(alg) >> 3)); + +const checkIvLength = (enc, iv) => { + if (iv.length << 3 !== bitLength$1(enc)) { + throw new JWEInvalid('Invalid Initialization Vector length'); + } +}; + +const checkCekLength = (cek, expected) => { + if (cek.length << 3 !== expected) { + throw new JWEInvalid('Invalid Content Encryption Key length'); + } +}; + +const timingSafeEqual = (a, b) => { + if (!(a instanceof Uint8Array)) { + throw new TypeError('First argument must be a buffer'); + } + if (!(b instanceof Uint8Array)) { + throw new TypeError('Second argument must be a buffer'); + } + if (a.length !== b.length) { + throw new TypeError('Input buffers must have the same length'); + } + const len = a.length; + let out = 0; + let i = -1; + while (++i < len) { + out |= a[i] ^ b[i]; + } + return out === 0; +}; + +function isCloudflareWorkers() { + return typeof WebSocketPair === 'function'; +} +function isNodeJs() { + try { + return process.versions.node !== undefined; + } + catch (_a) { + return false; + } +} + +function unusable(name, prop = 'algorithm.name') { + return new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`); +} +function isAlgorithm(algorithm, name) { + return algorithm.name === name; +} +function getHashLength(hash) { + return parseInt(hash.name.substr(4), 10); +} +function getNamedCurve(alg) { + switch (alg) { + case 'ES256': + return 'P-256'; + case 'ES384': + return 'P-384'; + case 'ES512': + return 'P-521'; + default: + throw new Error('unreachable'); + } +} +function checkUsage(key, usages) { + if (usages.length && !usages.some((expected) => key.usages.includes(expected))) { + let msg = 'CryptoKey does not support this operation, its usages must include '; + if (usages.length > 2) { + const last = usages.pop(); + msg += `one of ${usages.join(', ')}, or ${last}.`; + } + else if (usages.length === 2) { + msg += `one of ${usages[0]} or ${usages[1]}.`; + } + else { + msg += `${usages[0]}.`; + } + throw new TypeError(msg); + } +} +function checkSigCryptoKey(key, alg, ...usages) { + switch (alg) { + case 'HS256': + case 'HS384': + case 'HS512': { + if (!isAlgorithm(key.algorithm, 'HMAC')) + throw unusable('HMAC'); + const expected = parseInt(alg.substr(2), 10); + const actual = getHashLength(key.algorithm.hash); + if (actual !== expected) + throw unusable(`SHA-${expected}`, 'algorithm.hash'); + break; + } + case 'RS256': + case 'RS384': + case 'RS512': { + if (!isAlgorithm(key.algorithm, 'RSASSA-PKCS1-v1_5')) + throw unusable('RSASSA-PKCS1-v1_5'); + const expected = parseInt(alg.substr(2), 10); + const actual = getHashLength(key.algorithm.hash); + if (actual !== expected) + throw unusable(`SHA-${expected}`, 'algorithm.hash'); + break; + } + case 'PS256': + case 'PS384': + case 'PS512': { + if (!isAlgorithm(key.algorithm, 'RSA-PSS')) + throw unusable('RSA-PSS'); + const expected = parseInt(alg.substr(2), 10); + const actual = getHashLength(key.algorithm.hash); + if (actual !== expected) + throw unusable(`SHA-${expected}`, 'algorithm.hash'); + break; + } + case isNodeJs() && 'EdDSA': { + if (key.algorithm.name !== 'NODE-ED25519' && key.algorithm.name !== 'NODE-ED448') + throw unusable('NODE-ED25519 or NODE-ED448'); + break; + } + case isCloudflareWorkers() && 'EdDSA': { + if (!isAlgorithm(key.algorithm, 'NODE-ED25519')) + throw unusable('NODE-ED25519'); + break; + } + case 'ES256': + case 'ES384': + case 'ES512': { + if (!isAlgorithm(key.algorithm, 'ECDSA')) + throw unusable('ECDSA'); + const expected = getNamedCurve(alg); + const actual = key.algorithm.namedCurve; + if (actual !== expected) + throw unusable(expected, 'algorithm.namedCurve'); + break; + } + default: + throw new TypeError('CryptoKey does not support this operation'); + } + checkUsage(key, usages); +} +function checkEncCryptoKey(key, alg, ...usages) { + switch (alg) { + case 'A128GCM': + case 'A192GCM': + case 'A256GCM': { + if (!isAlgorithm(key.algorithm, 'AES-GCM')) + throw unusable('AES-GCM'); + const expected = parseInt(alg.substr(1, 3), 10); + const actual = key.algorithm.length; + if (actual !== expected) + throw unusable(expected, 'algorithm.length'); + break; + } + case 'A128KW': + case 'A192KW': + case 'A256KW': { + if (!isAlgorithm(key.algorithm, 'AES-KW')) + throw unusable('AES-KW'); + const expected = parseInt(alg.substr(1, 3), 10); + const actual = key.algorithm.length; + if (actual !== expected) + throw unusable(expected, 'algorithm.length'); + break; + } + case 'ECDH-ES': + if (!isAlgorithm(key.algorithm, 'ECDH')) + throw unusable('ECDH'); + break; + case 'PBES2-HS256+A128KW': + case 'PBES2-HS384+A192KW': + case 'PBES2-HS512+A256KW': + if (!isAlgorithm(key.algorithm, 'PBKDF2')) + throw unusable('PBKDF2'); + break; + case 'RSA-OAEP': + case 'RSA-OAEP-256': + case 'RSA-OAEP-384': + case 'RSA-OAEP-512': { + if (!isAlgorithm(key.algorithm, 'RSA-OAEP')) + throw unusable('RSA-OAEP'); + const expected = parseInt(alg.substr(9), 10) || 1; + const actual = getHashLength(key.algorithm.hash); + if (actual !== expected) + throw unusable(`SHA-${expected}`, 'algorithm.hash'); + break; + } + default: + throw new TypeError('CryptoKey does not support this operation'); + } + checkUsage(key, usages); +} + +var invalidKeyInput = (actual, ...types) => { + let msg = 'Key must be '; + if (types.length > 2) { + const last = types.pop(); + msg += `one of type ${types.join(', ')}, or ${last}.`; + } + else if (types.length === 2) { + msg += `one of type ${types[0]} or ${types[1]}.`; + } + else { + msg += `of type ${types[0]}.`; + } + if (actual == null) { + msg += ` Received ${actual}`; + } + else if (typeof actual === 'function' && actual.name) { + msg += ` Received function ${actual.name}`; + } + else if (typeof actual === 'object' && actual != null) { + if (actual.constructor && actual.constructor.name) { + msg += ` Received an instance of ${actual.constructor.name}`; + } + } + return msg; +}; + +var isKeyLike = (key) => { + return isCryptoKey(key); +}; +const types = ['CryptoKey']; + +async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) { + if (!(cek instanceof Uint8Array)) { + throw new TypeError(invalidKeyInput(cek, 'Uint8Array')); + } + const keySize = parseInt(enc.substr(1, 3), 10); + const encKey = await crypto$1.subtle.importKey('raw', cek.subarray(keySize >> 3), 'AES-CBC', false, ['decrypt']); + const macKey = await crypto$1.subtle.importKey('raw', cek.subarray(0, keySize >> 3), { + hash: `SHA-${keySize << 1}`, + name: 'HMAC', + }, false, ['sign']); + const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3)); + const expectedTag = new Uint8Array((await crypto$1.subtle.sign('HMAC', macKey, macData)).slice(0, keySize >> 3)); + let macCheckPassed; + try { + macCheckPassed = timingSafeEqual(tag, expectedTag); + } + catch (_a) { + } + if (!macCheckPassed) { + throw new JWEDecryptionFailed(); + } + let plaintext; + try { + plaintext = new Uint8Array(await crypto$1.subtle.decrypt({ iv, name: 'AES-CBC' }, encKey, ciphertext)); + } + catch (_b) { + } + if (!plaintext) { + throw new JWEDecryptionFailed(); + } + return plaintext; +} +async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) { + let encKey; + if (cek instanceof Uint8Array) { + encKey = await crypto$1.subtle.importKey('raw', cek, 'AES-GCM', false, ['decrypt']); + } + else { + checkEncCryptoKey(cek, enc, 'decrypt'); + encKey = cek; + } + try { + return new Uint8Array(await crypto$1.subtle.decrypt({ + additionalData: aad, + iv, + name: 'AES-GCM', + tagLength: 128, + }, encKey, concat(ciphertext, tag))); + } + catch (_a) { + throw new JWEDecryptionFailed(); + } +} +const decrypt$2 = async (enc, cek, ciphertext, iv, tag, aad) => { + if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) { + throw new TypeError(invalidKeyInput(cek, ...types, 'Uint8Array')); + } + checkIvLength(enc, iv); + switch (enc) { + case 'A128CBC-HS256': + case 'A192CBC-HS384': + case 'A256CBC-HS512': + if (cek instanceof Uint8Array) + checkCekLength(cek, parseInt(enc.substr(-3), 10)); + return cbcDecrypt(enc, cek, ciphertext, iv, tag, aad); + case 'A128GCM': + case 'A192GCM': + case 'A256GCM': + if (cek instanceof Uint8Array) + checkCekLength(cek, parseInt(enc.substr(1, 3), 10)); + return gcmDecrypt(enc, cek, ciphertext, iv, tag, aad); + default: + throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm'); + } +}; + +const inflate = async () => { + throw new JOSENotSupported('JWE "zip" (Compression Algorithm) Header Parameter is not supported by your javascript runtime. You need to use the `inflateRaw` decrypt option to provide Inflate Raw implementation.'); +}; +const deflate = async () => { + throw new JOSENotSupported('JWE "zip" (Compression Algorithm) Header Parameter is not supported by your javascript runtime. You need to use the `deflateRaw` encrypt option to provide Deflate Raw implementation.'); +}; + +const isDisjoint = (...headers) => { + const sources = headers.filter(Boolean); + if (sources.length === 0 || sources.length === 1) { + return true; + } + let acc; + for (const header of sources) { + const parameters = Object.keys(header); + if (!acc || acc.size === 0) { + acc = new Set(parameters); + continue; + } + for (const parameter of parameters) { + if (acc.has(parameter)) { + return false; + } + acc.add(parameter); + } + } + return true; +}; + +function isObjectLike(value) { + return typeof value === 'object' && value !== null; +} +function isObject(input) { + if (!isObjectLike(input) || Object.prototype.toString.call(input) !== '[object Object]') { + return false; + } + if (Object.getPrototypeOf(input) === null) { + return true; + } + let proto = input; + while (Object.getPrototypeOf(proto) !== null) { + proto = Object.getPrototypeOf(proto); + } + return Object.getPrototypeOf(input) === proto; +} + +const bogusWebCrypto = [ + { hash: 'SHA-256', name: 'HMAC' }, + true, + ['sign'], +]; + +function checkKeySize(key, alg) { + if (key.algorithm.length !== parseInt(alg.substr(1, 3), 10)) { + throw new TypeError(`Invalid key size for alg: ${alg}`); + } +} +function getCryptoKey$2(key, alg, usage) { + if (isCryptoKey(key)) { + checkEncCryptoKey(key, alg, usage); + return key; + } + if (key instanceof Uint8Array) { + return crypto$1.subtle.importKey('raw', key, 'AES-KW', true, [usage]); + } + throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array')); +} +const wrap$1 = async (alg, key, cek) => { + const cryptoKey = await getCryptoKey$2(key, alg, 'wrapKey'); + checkKeySize(cryptoKey, alg); + const cryptoKeyCek = await crypto$1.subtle.importKey('raw', cek, ...bogusWebCrypto); + return new Uint8Array(await crypto$1.subtle.wrapKey('raw', cryptoKeyCek, cryptoKey, 'AES-KW')); +}; +const unwrap$1 = async (alg, key, encryptedKey) => { + const cryptoKey = await getCryptoKey$2(key, alg, 'unwrapKey'); + checkKeySize(cryptoKey, alg); + const cryptoKeyCek = await crypto$1.subtle.unwrapKey('raw', encryptedKey, cryptoKey, 'AES-KW', ...bogusWebCrypto); + return new Uint8Array(await crypto$1.subtle.exportKey('raw', cryptoKeyCek)); +}; + +const digest = async (algorithm, data) => { + const subtleDigest = `SHA-${algorithm.substr(-3)}`; + return new Uint8Array(await crypto$1.subtle.digest(subtleDigest, data)); +}; + +const deriveKey$1 = async (publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) => { + if (!isCryptoKey(publicKey)) { + throw new TypeError(invalidKeyInput(publicKey, ...types)); + } + checkEncCryptoKey(publicKey, 'ECDH-ES'); + if (!isCryptoKey(privateKey)) { + throw new TypeError(invalidKeyInput(privateKey, ...types)); + } + checkEncCryptoKey(privateKey, 'ECDH-ES', 'deriveBits', 'deriveKey'); + const value = concat(lengthAndInput(encoder.encode(algorithm)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyLength)); + if (!privateKey.usages.includes('deriveBits')) { + throw new TypeError('ECDH-ES private key "usages" must include "deriveBits"'); + } + const sharedSecret = new Uint8Array(await crypto$1.subtle.deriveBits({ + name: 'ECDH', + public: publicKey, + }, privateKey, Math.ceil(parseInt(privateKey.algorithm.namedCurve.substr(-3), 10) / 8) << + 3)); + return concatKdf(digest, sharedSecret, keyLength, value); +}; +const generateEpk = async (key) => { + if (!isCryptoKey(key)) { + throw new TypeError(invalidKeyInput(key, ...types)); + } + return (await crypto$1.subtle.generateKey({ name: 'ECDH', namedCurve: key.algorithm.namedCurve }, true, ['deriveBits'])).privateKey; +}; +const ecdhAllowed = (key) => { + if (!isCryptoKey(key)) { + throw new TypeError(invalidKeyInput(key, ...types)); + } + return ['P-256', 'P-384', 'P-521'].includes(key.algorithm.namedCurve); +}; + +function checkP2s(p2s) { + if (!(p2s instanceof Uint8Array) || p2s.length < 8) { + throw new JWEInvalid('PBES2 Salt Input must be 8 or more octets'); + } +} + +function getCryptoKey$1(key, alg) { + if (key instanceof Uint8Array) { + return crypto$1.subtle.importKey('raw', key, 'PBKDF2', false, ['deriveBits']); + } + if (isCryptoKey(key)) { + checkEncCryptoKey(key, alg, 'deriveBits', 'deriveKey'); + return key; + } + throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array')); +} +async function deriveKey(p2s$1, alg, p2c, key) { + checkP2s(p2s$1); + const salt = p2s(alg, p2s$1); + const keylen = parseInt(alg.substr(13, 3), 10); + const subtleAlg = { + hash: `SHA-${alg.substr(8, 3)}`, + iterations: p2c, + name: 'PBKDF2', + salt, + }; + const wrapAlg = { + length: keylen, + name: 'AES-KW', + }; + const cryptoKey = await getCryptoKey$1(key, alg); + if (cryptoKey.usages.includes('deriveBits')) { + return new Uint8Array(await crypto$1.subtle.deriveBits(subtleAlg, cryptoKey, keylen)); + } + if (cryptoKey.usages.includes('deriveKey')) { + return crypto$1.subtle.deriveKey(subtleAlg, cryptoKey, wrapAlg, false, ['wrapKey', 'unwrapKey']); + } + throw new TypeError('PBKDF2 key "usages" must include "deriveBits" or "deriveKey"'); +} +const encrypt$2 = async (alg, key, cek, p2c = Math.floor(Math.random() * 2049) + 2048, p2s = random(new Uint8Array(16))) => { + const derived = await deriveKey(p2s, alg, p2c, key); + const encryptedKey = await wrap$1(alg.substr(-6), derived, cek); + return { encryptedKey, p2c, p2s: encode(p2s) }; +}; +const decrypt$1 = async (alg, key, encryptedKey, p2c, p2s) => { + const derived = await deriveKey(p2s, alg, p2c, key); + return unwrap$1(alg.substr(-6), derived, encryptedKey); +}; + +function subtleRsaEs(alg) { + switch (alg) { + case 'RSA-OAEP': + case 'RSA-OAEP-256': + case 'RSA-OAEP-384': + case 'RSA-OAEP-512': + return 'RSA-OAEP'; + default: + throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`); + } +} + +var checkKeyLength = (alg, key) => { + if (alg.startsWith('RS') || alg.startsWith('PS')) { + const { modulusLength } = key.algorithm; + if (typeof modulusLength !== 'number' || modulusLength < 2048) { + throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`); + } + } +}; + +const encrypt$1 = async (alg, key, cek) => { + if (!isCryptoKey(key)) { + throw new TypeError(invalidKeyInput(key, ...types)); + } + checkEncCryptoKey(key, alg, 'encrypt', 'wrapKey'); + checkKeyLength(alg, key); + if (key.usages.includes('encrypt')) { + return new Uint8Array(await crypto$1.subtle.encrypt(subtleRsaEs(alg), key, cek)); + } + if (key.usages.includes('wrapKey')) { + const cryptoKeyCek = await crypto$1.subtle.importKey('raw', cek, ...bogusWebCrypto); + return new Uint8Array(await crypto$1.subtle.wrapKey('raw', cryptoKeyCek, key, subtleRsaEs(alg))); + } + throw new TypeError('RSA-OAEP key "usages" must include "encrypt" or "wrapKey" for this operation'); +}; +const decrypt = async (alg, key, encryptedKey) => { + if (!isCryptoKey(key)) { + throw new TypeError(invalidKeyInput(key, ...types)); + } + checkEncCryptoKey(key, alg, 'decrypt', 'unwrapKey'); + checkKeyLength(alg, key); + if (key.usages.includes('decrypt')) { + return new Uint8Array(await crypto$1.subtle.decrypt(subtleRsaEs(alg), key, encryptedKey)); + } + if (key.usages.includes('unwrapKey')) { + const cryptoKeyCek = await crypto$1.subtle.unwrapKey('raw', encryptedKey, key, subtleRsaEs(alg), ...bogusWebCrypto); + return new Uint8Array(await crypto$1.subtle.exportKey('raw', cryptoKeyCek)); + } + throw new TypeError('RSA-OAEP key "usages" must include "decrypt" or "unwrapKey" for this operation'); +}; + +function bitLength(alg) { + switch (alg) { + case 'A128GCM': + return 128; + case 'A192GCM': + return 192; + case 'A256GCM': + case 'A128CBC-HS256': + return 256; + case 'A192CBC-HS384': + return 384; + case 'A256CBC-HS512': + return 512; + default: + throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`); + } +} +var generateCek = (alg) => random(new Uint8Array(bitLength(alg) >> 3)); + +function subtleMapping(jwk) { + let algorithm; + let keyUsages; + switch (jwk.kty) { + case 'oct': { + switch (jwk.alg) { + case 'HS256': + case 'HS384': + case 'HS512': + algorithm = { name: 'HMAC', hash: `SHA-${jwk.alg.substr(-3)}` }; + keyUsages = ['sign', 'verify']; + break; + case 'A128CBC-HS256': + case 'A192CBC-HS384': + case 'A256CBC-HS512': + throw new JOSENotSupported(`${jwk.alg} keys cannot be imported as CryptoKey instances`); + case 'A128GCM': + case 'A192GCM': + case 'A256GCM': + case 'A128GCMKW': + case 'A192GCMKW': + case 'A256GCMKW': + algorithm = { name: 'AES-GCM' }; + keyUsages = ['encrypt', 'decrypt']; + break; + case 'A128KW': + case 'A192KW': + case 'A256KW': + algorithm = { name: 'AES-KW' }; + keyUsages = ['wrapKey', 'unwrapKey']; + break; + case 'PBES2-HS256+A128KW': + case 'PBES2-HS384+A192KW': + case 'PBES2-HS512+A256KW': + algorithm = { name: 'PBKDF2' }; + keyUsages = ['deriveBits']; + break; + default: + throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value'); + } + break; + } + case 'RSA': { + switch (jwk.alg) { + case 'PS256': + case 'PS384': + case 'PS512': + algorithm = { name: 'RSA-PSS', hash: `SHA-${jwk.alg.substr(-3)}` }; + keyUsages = jwk.d ? ['sign'] : ['verify']; + break; + case 'RS256': + case 'RS384': + case 'RS512': + algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: `SHA-${jwk.alg.substr(-3)}` }; + keyUsages = jwk.d ? ['sign'] : ['verify']; + break; + case 'RSA-OAEP': + case 'RSA-OAEP-256': + case 'RSA-OAEP-384': + case 'RSA-OAEP-512': + algorithm = { + name: 'RSA-OAEP', + hash: `SHA-${parseInt(jwk.alg.substr(-3), 10) || 1}`, + }; + keyUsages = jwk.d ? ['decrypt', 'unwrapKey'] : ['encrypt', 'wrapKey']; + break; + default: + throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value'); + } + break; + } + case 'EC': { + switch (jwk.alg) { + case 'ES256': + algorithm = { name: 'ECDSA', namedCurve: 'P-256' }; + keyUsages = jwk.d ? ['sign'] : ['verify']; + break; + case 'ES384': + algorithm = { name: 'ECDSA', namedCurve: 'P-384' }; + keyUsages = jwk.d ? ['sign'] : ['verify']; + break; + case 'ES512': + algorithm = { name: 'ECDSA', namedCurve: 'P-521' }; + keyUsages = jwk.d ? ['sign'] : ['verify']; + break; + case 'ECDH-ES': + case 'ECDH-ES+A128KW': + case 'ECDH-ES+A192KW': + case 'ECDH-ES+A256KW': + algorithm = { name: 'ECDH', namedCurve: jwk.crv }; + keyUsages = jwk.d ? ['deriveBits'] : []; + break; + default: + throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value'); + } + break; + } + case (isCloudflareWorkers() || isNodeJs()) && 'OKP': + if (jwk.alg !== 'EdDSA') { + throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value'); + } + switch (jwk.crv) { + case 'Ed25519': + algorithm = { name: 'NODE-ED25519', namedCurve: 'NODE-ED25519' }; + keyUsages = jwk.d ? ['sign'] : ['verify']; + break; + case isNodeJs() && 'Ed448': + algorithm = { name: 'NODE-ED448', namedCurve: 'NODE-ED448' }; + keyUsages = jwk.d ? ['sign'] : ['verify']; + break; + default: + throw new JOSENotSupported('Invalid or unsupported JWK "crv" (Subtype of Key Pair) Parameter value'); + } + break; + default: + throw new JOSENotSupported('Invalid or unsupported JWK "kty" (Key Type) Parameter value'); + } + return { algorithm, keyUsages }; +} +const parse = async (jwk) => { + var _a, _b; + const { algorithm, keyUsages } = subtleMapping(jwk); + const rest = [ + algorithm, + (_a = jwk.ext) !== null && _a !== void 0 ? _a : false, + (_b = jwk.key_ops) !== null && _b !== void 0 ? _b : keyUsages, + ]; + if (algorithm.name === 'PBKDF2') { + return crypto$1.subtle.importKey('raw', decode(jwk.k), ...rest); + } + const keyData = { ...jwk }; + delete keyData.alg; + return crypto$1.subtle.importKey('jwk', keyData, ...rest); +}; +var asKeyObject = parse; + +async function importJWK(jwk, alg, octAsKeyObject) { + if (!isObject(jwk)) { + throw new TypeError('JWK must be an object'); + } + alg || (alg = jwk.alg); + if (typeof alg !== 'string' || !alg) { + throw new TypeError('"alg" argument is required when "jwk.alg" is not present'); + } + switch (jwk.kty) { + case 'oct': + if (typeof jwk.k !== 'string' || !jwk.k) { + throw new TypeError('missing "k" (Key Value) Parameter value'); + } + octAsKeyObject !== null && octAsKeyObject !== void 0 ? octAsKeyObject : (octAsKeyObject = jwk.ext !== true); + if (octAsKeyObject) { + return asKeyObject({ ...jwk, alg, ext: false }); + } + return decode(jwk.k); + case 'RSA': + if (jwk.oth !== undefined) { + throw new JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported'); + } + case 'EC': + case 'OKP': + return asKeyObject({ ...jwk, alg }); + default: + throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value'); + } +} + +const symmetricTypeCheck = (key) => { + if (key instanceof Uint8Array) + return; + if (!isKeyLike(key)) { + throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array')); + } + if (key.type !== 'secret') { + throw new TypeError(`${types.join(' or ')} instances for symmetric algorithms must be of type "secret"`); + } +}; +const asymmetricTypeCheck = (key, usage) => { + if (!isKeyLike(key)) { + throw new TypeError(invalidKeyInput(key, ...types)); + } + if (key.type === 'secret') { + throw new TypeError(`${types.join(' or ')} instances for asymmetric algorithms must not be of type "secret"`); + } + if (usage === 'sign' && key.type === 'public') { + throw new TypeError(`${types.join(' or ')} instances for asymmetric algorithm signing must be of type "private"`); + } + if (usage === 'decrypt' && key.type === 'public') { + throw new TypeError(`${types.join(' or ')} instances for asymmetric algorithm decryption must be of type "private"`); + } + if (key.algorithm && usage === 'verify' && key.type === 'private') { + throw new TypeError(`${types.join(' or ')} instances for asymmetric algorithm verifying must be of type "public"`); + } + if (key.algorithm && usage === 'encrypt' && key.type === 'private') { + throw new TypeError(`${types.join(' or ')} instances for asymmetric algorithm encryption must be of type "public"`); + } +}; +const checkKeyType = (alg, key, usage) => { + const symmetric = alg.startsWith('HS') || + alg === 'dir' || + alg.startsWith('PBES2') || + /^A\d{3}(?:GCM)?KW$/.test(alg); + if (symmetric) { + symmetricTypeCheck(key); + } + else { + asymmetricTypeCheck(key, usage); + } +}; + +async function cbcEncrypt(enc, plaintext, cek, iv, aad) { + if (!(cek instanceof Uint8Array)) { + throw new TypeError(invalidKeyInput(cek, 'Uint8Array')); + } + const keySize = parseInt(enc.substr(1, 3), 10); + const encKey = await crypto$1.subtle.importKey('raw', cek.subarray(keySize >> 3), 'AES-CBC', false, ['encrypt']); + const macKey = await crypto$1.subtle.importKey('raw', cek.subarray(0, keySize >> 3), { + hash: `SHA-${keySize << 1}`, + name: 'HMAC', + }, false, ['sign']); + const ciphertext = new Uint8Array(await crypto$1.subtle.encrypt({ + iv, + name: 'AES-CBC', + }, encKey, plaintext)); + const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3)); + const tag = new Uint8Array((await crypto$1.subtle.sign('HMAC', macKey, macData)).slice(0, keySize >> 3)); + return { ciphertext, tag }; +} +async function gcmEncrypt(enc, plaintext, cek, iv, aad) { + let encKey; + if (cek instanceof Uint8Array) { + encKey = await crypto$1.subtle.importKey('raw', cek, 'AES-GCM', false, ['encrypt']); + } + else { + checkEncCryptoKey(cek, enc, 'encrypt'); + encKey = cek; + } + const encrypted = new Uint8Array(await crypto$1.subtle.encrypt({ + additionalData: aad, + iv, + name: 'AES-GCM', + tagLength: 128, + }, encKey, plaintext)); + const tag = encrypted.slice(-16); + const ciphertext = encrypted.slice(0, -16); + return { ciphertext, tag }; +} +const encrypt = async (enc, plaintext, cek, iv, aad) => { + if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) { + throw new TypeError(invalidKeyInput(cek, ...types, 'Uint8Array')); + } + checkIvLength(enc, iv); + switch (enc) { + case 'A128CBC-HS256': + case 'A192CBC-HS384': + case 'A256CBC-HS512': + if (cek instanceof Uint8Array) + checkCekLength(cek, parseInt(enc.substr(-3), 10)); + return cbcEncrypt(enc, plaintext, cek, iv, aad); + case 'A128GCM': + case 'A192GCM': + case 'A256GCM': + if (cek instanceof Uint8Array) + checkCekLength(cek, parseInt(enc.substr(1, 3), 10)); + return gcmEncrypt(enc, plaintext, cek, iv, aad); + default: + throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm'); + } +}; + +async function wrap(alg, key, cek, iv) { + const jweAlgorithm = alg.substr(0, 7); + iv || (iv = generateIv(jweAlgorithm)); + const { ciphertext: encryptedKey, tag } = await encrypt(jweAlgorithm, cek, key, iv, new Uint8Array(0)); + return { encryptedKey, iv: encode(iv), tag: encode(tag) }; +} +async function unwrap(alg, key, encryptedKey, iv, tag) { + const jweAlgorithm = alg.substr(0, 7); + return decrypt$2(jweAlgorithm, key, encryptedKey, iv, tag, new Uint8Array(0)); +} + +async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) { + checkKeyType(alg, key, 'decrypt'); + switch (alg) { + case 'dir': { + if (encryptedKey !== undefined) + throw new JWEInvalid('Encountered unexpected JWE Encrypted Key'); + return key; + } + case 'ECDH-ES': + if (encryptedKey !== undefined) + throw new JWEInvalid('Encountered unexpected JWE Encrypted Key'); + case 'ECDH-ES+A128KW': + case 'ECDH-ES+A192KW': + case 'ECDH-ES+A256KW': { + if (!isObject(joseHeader.epk)) + throw new JWEInvalid(`JOSE Header "epk" (Ephemeral Public Key) missing or invalid`); + if (!ecdhAllowed(key)) + throw new JOSENotSupported('ECDH-ES with the provided key is not allowed or not supported by your javascript runtime'); + const epk = await importJWK(joseHeader.epk, alg); + let partyUInfo; + let partyVInfo; + if (joseHeader.apu !== undefined) { + if (typeof joseHeader.apu !== 'string') + throw new JWEInvalid(`JOSE Header "apu" (Agreement PartyUInfo) invalid`); + partyUInfo = decode(joseHeader.apu); + } + if (joseHeader.apv !== undefined) { + if (typeof joseHeader.apv !== 'string') + throw new JWEInvalid(`JOSE Header "apv" (Agreement PartyVInfo) invalid`); + partyVInfo = decode(joseHeader.apv); + } + const sharedSecret = await deriveKey$1(epk, key, alg === 'ECDH-ES' ? joseHeader.enc : alg, alg === 'ECDH-ES' ? bitLength(joseHeader.enc) : parseInt(alg.substr(-5, 3), 10), partyUInfo, partyVInfo); + if (alg === 'ECDH-ES') + return sharedSecret; + if (encryptedKey === undefined) + throw new JWEInvalid('JWE Encrypted Key missing'); + return unwrap$1(alg.substr(-6), sharedSecret, encryptedKey); + } + case 'RSA1_5': + case 'RSA-OAEP': + case 'RSA-OAEP-256': + case 'RSA-OAEP-384': + case 'RSA-OAEP-512': { + if (encryptedKey === undefined) + throw new JWEInvalid('JWE Encrypted Key missing'); + return decrypt(alg, key, encryptedKey); + } + case 'PBES2-HS256+A128KW': + case 'PBES2-HS384+A192KW': + case 'PBES2-HS512+A256KW': { + if (encryptedKey === undefined) + throw new JWEInvalid('JWE Encrypted Key missing'); + if (typeof joseHeader.p2c !== 'number') + throw new JWEInvalid(`JOSE Header "p2c" (PBES2 Count) missing or invalid`); + if (typeof joseHeader.p2s !== 'string') + throw new JWEInvalid(`JOSE Header "p2s" (PBES2 Salt) missing or invalid`); + return decrypt$1(alg, key, encryptedKey, joseHeader.p2c, decode(joseHeader.p2s)); + } + case 'A128KW': + case 'A192KW': + case 'A256KW': { + if (encryptedKey === undefined) + throw new JWEInvalid('JWE Encrypted Key missing'); + return unwrap$1(alg, key, encryptedKey); + } + case 'A128GCMKW': + case 'A192GCMKW': + case 'A256GCMKW': { + if (encryptedKey === undefined) + throw new JWEInvalid('JWE Encrypted Key missing'); + if (typeof joseHeader.iv !== 'string') + throw new JWEInvalid(`JOSE Header "iv" (Initialization Vector) missing or invalid`); + if (typeof joseHeader.tag !== 'string') + throw new JWEInvalid(`JOSE Header "tag" (Authentication Tag) missing or invalid`); + const iv = decode(joseHeader.iv); + const tag = decode(joseHeader.tag); + return unwrap(alg, key, encryptedKey, iv, tag); + } + default: { + throw new JOSENotSupported('Invalid or unsupported "alg" (JWE Algorithm) header value'); + } + } +} + +function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) { + if (joseHeader.crit !== undefined && protectedHeader.crit === undefined) { + throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected'); + } + if (!protectedHeader || protectedHeader.crit === undefined) { + return new Set(); + } + if (!Array.isArray(protectedHeader.crit) || + protectedHeader.crit.length === 0 || + protectedHeader.crit.some((input) => typeof input !== 'string' || input.length === 0)) { + throw new Err('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present'); + } + let recognized; + if (recognizedOption !== undefined) { + recognized = new Map([...Object.entries(recognizedOption), ...recognizedDefault.entries()]); + } + else { + recognized = recognizedDefault; + } + for (const parameter of protectedHeader.crit) { + if (!recognized.has(parameter)) { + throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`); + } + if (joseHeader[parameter] === undefined) { + throw new Err(`Extension Header Parameter "${parameter}" is missing`); + } + else if (recognized.get(parameter) && protectedHeader[parameter] === undefined) { + throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`); + } + } + return new Set(protectedHeader.crit); +} + +const validateAlgorithms = (option, algorithms) => { + if (algorithms !== undefined && + (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== 'string'))) { + throw new TypeError(`"${option}" option must be an array of strings`); + } + if (!algorithms) { + return undefined; + } + return new Set(algorithms); +}; + +async function flattenedDecrypt(jwe, key, options) { + var _a; + if (!isObject(jwe)) { + throw new JWEInvalid('Flattened JWE must be an object'); + } + if (jwe.protected === undefined && jwe.header === undefined && jwe.unprotected === undefined) { + throw new JWEInvalid('JOSE Header missing'); + } + if (typeof jwe.iv !== 'string') { + throw new JWEInvalid('JWE Initialization Vector missing or incorrect type'); + } + if (typeof jwe.ciphertext !== 'string') { + throw new JWEInvalid('JWE Ciphertext missing or incorrect type'); + } + if (typeof jwe.tag !== 'string') { + throw new JWEInvalid('JWE Authentication Tag missing or incorrect type'); + } + if (jwe.protected !== undefined && typeof jwe.protected !== 'string') { + throw new JWEInvalid('JWE Protected Header incorrect type'); + } + if (jwe.encrypted_key !== undefined && typeof jwe.encrypted_key !== 'string') { + throw new JWEInvalid('JWE Encrypted Key incorrect type'); + } + if (jwe.aad !== undefined && typeof jwe.aad !== 'string') { + throw new JWEInvalid('JWE AAD incorrect type'); + } + if (jwe.header !== undefined && !isObject(jwe.header)) { + throw new JWEInvalid('JWE Shared Unprotected Header incorrect type'); + } + if (jwe.unprotected !== undefined && !isObject(jwe.unprotected)) { + throw new JWEInvalid('JWE Per-Recipient Unprotected Header incorrect type'); + } + let parsedProt; + if (jwe.protected) { + const protectedHeader = decode(jwe.protected); + try { + parsedProt = JSON.parse(decoder.decode(protectedHeader)); + } + catch (_b) { + throw new JWEInvalid('JWE Protected Header is invalid'); + } + } + if (!isDisjoint(parsedProt, jwe.header, jwe.unprotected)) { + throw new JWEInvalid('JWE Protected, JWE Unprotected Header, and JWE Per-Recipient Unprotected Header Parameter names must be disjoint'); + } + const joseHeader = { + ...parsedProt, + ...jwe.header, + ...jwe.unprotected, + }; + validateCrit(JWEInvalid, new Map(), options === null || options === void 0 ? void 0 : options.crit, parsedProt, joseHeader); + if (joseHeader.zip !== undefined) { + if (!parsedProt || !parsedProt.zip) { + throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header MUST be integrity protected'); + } + if (joseHeader.zip !== 'DEF') { + throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value'); + } + } + const { alg, enc } = joseHeader; + if (typeof alg !== 'string' || !alg) { + throw new JWEInvalid('missing JWE Algorithm (alg) in JWE Header'); + } + if (typeof enc !== 'string' || !enc) { + throw new JWEInvalid('missing JWE Encryption Algorithm (enc) in JWE Header'); + } + const keyManagementAlgorithms = options && validateAlgorithms('keyManagementAlgorithms', options.keyManagementAlgorithms); + const contentEncryptionAlgorithms = options && + validateAlgorithms('contentEncryptionAlgorithms', options.contentEncryptionAlgorithms); + if (keyManagementAlgorithms && !keyManagementAlgorithms.has(alg)) { + throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter not allowed'); + } + if (contentEncryptionAlgorithms && !contentEncryptionAlgorithms.has(enc)) { + throw new JOSEAlgNotAllowed('"enc" (Encryption Algorithm) Header Parameter not allowed'); + } + let encryptedKey; + if (jwe.encrypted_key !== undefined) { + encryptedKey = decode(jwe.encrypted_key); + } + let resolvedKey = false; + if (typeof key === 'function') { + key = await key(parsedProt, jwe); + resolvedKey = true; + } + let cek; + try { + cek = await decryptKeyManagement(alg, key, encryptedKey, joseHeader); + } + catch (err) { + if (err instanceof TypeError) { + throw err; + } + cek = generateCek(enc); + } + const iv = decode(jwe.iv); + const tag = decode(jwe.tag); + const protectedHeader = encoder.encode((_a = jwe.protected) !== null && _a !== void 0 ? _a : ''); + let additionalData; + if (jwe.aad !== undefined) { + additionalData = concat(protectedHeader, encoder.encode('.'), encoder.encode(jwe.aad)); + } + else { + additionalData = protectedHeader; + } + let plaintext = await decrypt$2(enc, cek, decode(jwe.ciphertext), iv, tag, additionalData); + if (joseHeader.zip === 'DEF') { + plaintext = await ((options === null || options === void 0 ? void 0 : options.inflateRaw) || inflate)(plaintext); + } + const result = { plaintext }; + if (jwe.protected !== undefined) { + result.protectedHeader = parsedProt; + } + if (jwe.aad !== undefined) { + result.additionalAuthenticatedData = decode(jwe.aad); + } + if (jwe.unprotected !== undefined) { + result.sharedUnprotectedHeader = jwe.unprotected; + } + if (jwe.header !== undefined) { + result.unprotectedHeader = jwe.header; + } + if (resolvedKey) { + return { ...result, key }; + } + return result; +} + +async function compactDecrypt(jwe, key, options) { + if (jwe instanceof Uint8Array) { + jwe = decoder.decode(jwe); + } + if (typeof jwe !== 'string') { + throw new JWEInvalid('Compact JWE must be a string or Uint8Array'); + } + const { 0: protectedHeader, 1: encryptedKey, 2: iv, 3: ciphertext, 4: tag, length, } = jwe.split('.'); + if (length !== 5) { + throw new JWEInvalid('Invalid Compact JWE'); + } + const decrypted = await flattenedDecrypt({ + ciphertext: (ciphertext || undefined), + iv: (iv || undefined), + protected: protectedHeader || undefined, + tag: (tag || undefined), + encrypted_key: encryptedKey || undefined, + }, key, options); + const result = { plaintext: decrypted.plaintext, protectedHeader: decrypted.protectedHeader }; + if (typeof key === 'function') { + return { ...result, key: decrypted.key }; + } + return result; +} + +const keyToJWK = async (key) => { + if (key instanceof Uint8Array) { + return { + kty: 'oct', + k: encode(key), + }; + } + if (!isCryptoKey(key)) { + throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array')); + } + if (!key.extractable) { + throw new TypeError('non-extractable CryptoKey cannot be exported as a JWK'); + } + const { ext, key_ops, alg, use, ...jwk } = await crypto$1.subtle.exportKey('jwk', key); + return jwk; +}; +var keyToJWK$1 = keyToJWK; + +async function exportJWK(key) { + return keyToJWK$1(key); +} + +async function encryptKeyManagement(alg, enc, key, providedCek, providedParameters = {}) { + let encryptedKey; + let parameters; + let cek; + checkKeyType(alg, key, 'encrypt'); + switch (alg) { + case 'dir': { + cek = key; + break; + } + case 'ECDH-ES': + case 'ECDH-ES+A128KW': + case 'ECDH-ES+A192KW': + case 'ECDH-ES+A256KW': { + if (!ecdhAllowed(key)) { + throw new JOSENotSupported('ECDH-ES with the provided key is not allowed or not supported by your javascript runtime'); + } + const { apu, apv } = providedParameters; + let { epk: ephemeralKey } = providedParameters; + ephemeralKey || (ephemeralKey = await generateEpk(key)); + const { x, y, crv, kty } = await exportJWK(ephemeralKey); + const sharedSecret = await deriveKey$1(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, alg === 'ECDH-ES' ? bitLength(enc) : parseInt(alg.substr(-5, 3), 10), apu, apv); + parameters = { epk: { x, y, crv, kty } }; + if (apu) + parameters.apu = encode(apu); + if (apv) + parameters.apv = encode(apv); + if (alg === 'ECDH-ES') { + cek = sharedSecret; + break; + } + cek = providedCek || generateCek(enc); + const kwAlg = alg.substr(-6); + encryptedKey = await wrap$1(kwAlg, sharedSecret, cek); + break; + } + case 'RSA1_5': + case 'RSA-OAEP': + case 'RSA-OAEP-256': + case 'RSA-OAEP-384': + case 'RSA-OAEP-512': { + cek = providedCek || generateCek(enc); + encryptedKey = await encrypt$1(alg, key, cek); + break; + } + case 'PBES2-HS256+A128KW': + case 'PBES2-HS384+A192KW': + case 'PBES2-HS512+A256KW': { + cek = providedCek || generateCek(enc); + const { p2c, p2s } = providedParameters; + ({ encryptedKey, ...parameters } = await encrypt$2(alg, key, cek, p2c, p2s)); + break; + } + case 'A128KW': + case 'A192KW': + case 'A256KW': { + cek = providedCek || generateCek(enc); + encryptedKey = await wrap$1(alg, key, cek); + break; + } + case 'A128GCMKW': + case 'A192GCMKW': + case 'A256GCMKW': { + cek = providedCek || generateCek(enc); + const { iv } = providedParameters; + ({ encryptedKey, ...parameters } = await wrap(alg, key, cek, iv)); + break; + } + default: { + throw new JOSENotSupported('Invalid or unsupported "alg" (JWE Algorithm) header value'); + } + } + return { cek, encryptedKey, parameters }; +} + +const unprotected = Symbol(); +class FlattenedEncrypt { + constructor(plaintext) { + if (!(plaintext instanceof Uint8Array)) { + throw new TypeError('plaintext must be an instance of Uint8Array'); + } + this._plaintext = plaintext; + } + setKeyManagementParameters(parameters) { + if (this._keyManagementParameters) { + throw new TypeError('setKeyManagementParameters can only be called once'); + } + this._keyManagementParameters = parameters; + return this; + } + setProtectedHeader(protectedHeader) { + if (this._protectedHeader) { + throw new TypeError('setProtectedHeader can only be called once'); + } + this._protectedHeader = protectedHeader; + return this; + } + setSharedUnprotectedHeader(sharedUnprotectedHeader) { + if (this._sharedUnprotectedHeader) { + throw new TypeError('setSharedUnprotectedHeader can only be called once'); + } + this._sharedUnprotectedHeader = sharedUnprotectedHeader; + return this; + } + setUnprotectedHeader(unprotectedHeader) { + if (this._unprotectedHeader) { + throw new TypeError('setUnprotectedHeader can only be called once'); + } + this._unprotectedHeader = unprotectedHeader; + return this; + } + setAdditionalAuthenticatedData(aad) { + this._aad = aad; + return this; + } + setContentEncryptionKey(cek) { + if (this._cek) { + throw new TypeError('setContentEncryptionKey can only be called once'); + } + this._cek = cek; + return this; + } + setInitializationVector(iv) { + if (this._iv) { + throw new TypeError('setInitializationVector can only be called once'); + } + this._iv = iv; + return this; + } + async encrypt(key, options) { + if (!this._protectedHeader && !this._unprotectedHeader && !this._sharedUnprotectedHeader) { + throw new JWEInvalid('either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()'); + } + if (!isDisjoint(this._protectedHeader, this._unprotectedHeader, this._sharedUnprotectedHeader)) { + throw new JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint'); + } + const joseHeader = { + ...this._protectedHeader, + ...this._unprotectedHeader, + ...this._sharedUnprotectedHeader, + }; + validateCrit(JWEInvalid, new Map(), options === null || options === void 0 ? void 0 : options.crit, this._protectedHeader, joseHeader); + if (joseHeader.zip !== undefined) { + if (!this._protectedHeader || !this._protectedHeader.zip) { + throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header MUST be integrity protected'); + } + if (joseHeader.zip !== 'DEF') { + throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value'); + } + } + const { alg, enc } = joseHeader; + if (typeof alg !== 'string' || !alg) { + throw new JWEInvalid('JWE "alg" (Algorithm) Header Parameter missing or invalid'); + } + if (typeof enc !== 'string' || !enc) { + throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid'); + } + let encryptedKey; + if (alg === 'dir') { + if (this._cek) { + throw new TypeError('setContentEncryptionKey cannot be called when using Direct Encryption'); + } + } + else if (alg === 'ECDH-ES') { + if (this._cek) { + throw new TypeError('setContentEncryptionKey cannot be called when using Direct Key Agreement'); + } + } + let cek; + { + let parameters; + ({ cek, encryptedKey, parameters } = await encryptKeyManagement(alg, enc, key, this._cek, this._keyManagementParameters)); + if (parameters) { + if (options && unprotected in options) { + if (!this._unprotectedHeader) { + this.setUnprotectedHeader(parameters); + } + else { + this._unprotectedHeader = { ...this._unprotectedHeader, ...parameters }; + } + } + else { + if (!this._protectedHeader) { + this.setProtectedHeader(parameters); + } + else { + this._protectedHeader = { ...this._protectedHeader, ...parameters }; + } + } + } + } + this._iv || (this._iv = generateIv(enc)); + let additionalData; + let protectedHeader; + let aadMember; + if (this._protectedHeader) { + protectedHeader = encoder.encode(encode(JSON.stringify(this._protectedHeader))); + } + else { + protectedHeader = encoder.encode(''); + } + if (this._aad) { + aadMember = encode(this._aad); + additionalData = concat(protectedHeader, encoder.encode('.'), encoder.encode(aadMember)); + } + else { + additionalData = protectedHeader; + } + let ciphertext; + let tag; + if (joseHeader.zip === 'DEF') { + const deflated = await ((options === null || options === void 0 ? void 0 : options.deflateRaw) || deflate)(this._plaintext); + ({ ciphertext, tag } = await encrypt(enc, deflated, cek, this._iv, additionalData)); + } + else { + ({ ciphertext, tag } = await encrypt(enc, this._plaintext, cek, this._iv, additionalData)); + } + const jwe = { + ciphertext: encode(ciphertext), + iv: encode(this._iv), + tag: encode(tag), + }; + if (encryptedKey) { + jwe.encrypted_key = encode(encryptedKey); + } + if (aadMember) { + jwe.aad = aadMember; + } + if (this._protectedHeader) { + jwe.protected = decoder.decode(protectedHeader); + } + if (this._sharedUnprotectedHeader) { + jwe.unprotected = this._sharedUnprotectedHeader; + } + if (this._unprotectedHeader) { + jwe.header = this._unprotectedHeader; + } + return jwe; + } +} + +function subtleDsa(alg, namedCurve) { + const length = parseInt(alg.substr(-3), 10); + switch (alg) { + case 'HS256': + case 'HS384': + case 'HS512': + return { hash: `SHA-${length}`, name: 'HMAC' }; + case 'PS256': + case 'PS384': + case 'PS512': + return { hash: `SHA-${length}`, name: 'RSA-PSS', saltLength: length >> 3 }; + case 'RS256': + case 'RS384': + case 'RS512': + return { hash: `SHA-${length}`, name: 'RSASSA-PKCS1-v1_5' }; + case 'ES256': + case 'ES384': + case 'ES512': + return { hash: `SHA-${length}`, name: 'ECDSA', namedCurve }; + case (isCloudflareWorkers() || isNodeJs()) && 'EdDSA': + return { name: namedCurve, namedCurve }; + default: + throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`); + } +} + +function getCryptoKey(alg, key, usage) { + if (isCryptoKey(key)) { + checkSigCryptoKey(key, alg, usage); + return key; + } + if (key instanceof Uint8Array) { + if (!alg.startsWith('HS')) { + throw new TypeError(invalidKeyInput(key, ...types)); + } + return crypto$1.subtle.importKey('raw', key, { hash: `SHA-${alg.substr(-3)}`, name: 'HMAC' }, false, [usage]); + } + throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array')); +} + +const verify = async (alg, key, signature, data) => { + const cryptoKey = await getCryptoKey(alg, key, 'verify'); + checkKeyLength(alg, cryptoKey); + const algorithm = subtleDsa(alg, cryptoKey.algorithm.namedCurve); + try { + return await crypto$1.subtle.verify(algorithm, cryptoKey, signature, data); + } + catch (_a) { + return false; + } +}; + +async function flattenedVerify(jws, key, options) { + var _a; + if (!isObject(jws)) { + throw new JWSInvalid('Flattened JWS must be an object'); + } + if (jws.protected === undefined && jws.header === undefined) { + throw new JWSInvalid('Flattened JWS must have either of the "protected" or "header" members'); + } + if (jws.protected !== undefined && typeof jws.protected !== 'string') { + throw new JWSInvalid('JWS Protected Header incorrect type'); + } + if (jws.payload === undefined) { + throw new JWSInvalid('JWS Payload missing'); + } + if (typeof jws.signature !== 'string') { + throw new JWSInvalid('JWS Signature missing or incorrect type'); + } + if (jws.header !== undefined && !isObject(jws.header)) { + throw new JWSInvalid('JWS Unprotected Header incorrect type'); + } + let parsedProt = {}; + if (jws.protected) { + const protectedHeader = decode(jws.protected); + try { + parsedProt = JSON.parse(decoder.decode(protectedHeader)); + } + catch (_b) { + throw new JWSInvalid('JWS Protected Header is invalid'); + } + } + if (!isDisjoint(parsedProt, jws.header)) { + throw new JWSInvalid('JWS Protected and JWS Unprotected Header Parameter names must be disjoint'); + } + const joseHeader = { + ...parsedProt, + ...jws.header, + }; + const extensions = validateCrit(JWSInvalid, new Map([['b64', true]]), options === null || options === void 0 ? void 0 : options.crit, parsedProt, joseHeader); + let b64 = true; + if (extensions.has('b64')) { + b64 = parsedProt.b64; + if (typeof b64 !== 'boolean') { + throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean'); + } + } + const { alg } = joseHeader; + if (typeof alg !== 'string' || !alg) { + throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid'); + } + const algorithms = options && validateAlgorithms('algorithms', options.algorithms); + if (algorithms && !algorithms.has(alg)) { + throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter not allowed'); + } + if (b64) { + if (typeof jws.payload !== 'string') { + throw new JWSInvalid('JWS Payload must be a string'); + } + } + else if (typeof jws.payload !== 'string' && !(jws.payload instanceof Uint8Array)) { + throw new JWSInvalid('JWS Payload must be a string or an Uint8Array instance'); + } + let resolvedKey = false; + if (typeof key === 'function') { + key = await key(parsedProt, jws); + resolvedKey = true; + } + checkKeyType(alg, key, 'verify'); + const data = concat(encoder.encode((_a = jws.protected) !== null && _a !== void 0 ? _a : ''), encoder.encode('.'), typeof jws.payload === 'string' ? encoder.encode(jws.payload) : jws.payload); + const signature = decode(jws.signature); + const verified = await verify(alg, key, signature, data); + if (!verified) { + throw new JWSSignatureVerificationFailed(); + } + let payload; + if (b64) { + payload = decode(jws.payload); + } + else if (typeof jws.payload === 'string') { + payload = encoder.encode(jws.payload); + } + else { + payload = jws.payload; + } + const result = { payload }; + if (jws.protected !== undefined) { + result.protectedHeader = parsedProt; + } + if (jws.header !== undefined) { + result.unprotectedHeader = jws.header; + } + if (resolvedKey) { + return { ...result, key }; + } + return result; +} + +async function compactVerify(jws, key, options) { + if (jws instanceof Uint8Array) { + jws = decoder.decode(jws); + } + if (typeof jws !== 'string') { + throw new JWSInvalid('Compact JWS must be a string or Uint8Array'); + } + const { 0: protectedHeader, 1: payload, 2: signature, length } = jws.split('.'); + if (length !== 3) { + throw new JWSInvalid('Invalid Compact JWS'); + } + const verified = await flattenedVerify({ payload, protected: protectedHeader, signature }, key, options); + const result = { payload: verified.payload, protectedHeader: verified.protectedHeader }; + if (typeof key === 'function') { + return { ...result, key: verified.key }; + } + return result; +} + +class CompactEncrypt { + constructor(plaintext) { + this._flattened = new FlattenedEncrypt(plaintext); + } + setContentEncryptionKey(cek) { + this._flattened.setContentEncryptionKey(cek); + return this; + } + setInitializationVector(iv) { + this._flattened.setInitializationVector(iv); + return this; + } + setProtectedHeader(protectedHeader) { + this._flattened.setProtectedHeader(protectedHeader); + return this; + } + setKeyManagementParameters(parameters) { + this._flattened.setKeyManagementParameters(parameters); + return this; + } + async encrypt(key, options) { + const jwe = await this._flattened.encrypt(key, options); + return [jwe.protected, jwe.encrypted_key, jwe.iv, jwe.ciphertext, jwe.tag].join('.'); + } +} + +const sign = async (alg, key, data) => { + const cryptoKey = await getCryptoKey(alg, key, 'sign'); + checkKeyLength(alg, cryptoKey); + const signature = await crypto$1.subtle.sign(subtleDsa(alg, cryptoKey.algorithm.namedCurve), cryptoKey, data); + return new Uint8Array(signature); +}; + +class FlattenedSign { + constructor(payload) { + if (!(payload instanceof Uint8Array)) { + throw new TypeError('payload must be an instance of Uint8Array'); + } + this._payload = payload; + } + setProtectedHeader(protectedHeader) { + if (this._protectedHeader) { + throw new TypeError('setProtectedHeader can only be called once'); + } + this._protectedHeader = protectedHeader; + return this; + } + setUnprotectedHeader(unprotectedHeader) { + if (this._unprotectedHeader) { + throw new TypeError('setUnprotectedHeader can only be called once'); + } + this._unprotectedHeader = unprotectedHeader; + return this; + } + async sign(key, options) { + if (!this._protectedHeader && !this._unprotectedHeader) { + throw new JWSInvalid('either setProtectedHeader or setUnprotectedHeader must be called before #sign()'); + } + if (!isDisjoint(this._protectedHeader, this._unprotectedHeader)) { + throw new JWSInvalid('JWS Protected and JWS Unprotected Header Parameter names must be disjoint'); + } + const joseHeader = { + ...this._protectedHeader, + ...this._unprotectedHeader, + }; + const extensions = validateCrit(JWSInvalid, new Map([['b64', true]]), options === null || options === void 0 ? void 0 : options.crit, this._protectedHeader, joseHeader); + let b64 = true; + if (extensions.has('b64')) { + b64 = this._protectedHeader.b64; + if (typeof b64 !== 'boolean') { + throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean'); + } + } + const { alg } = joseHeader; + if (typeof alg !== 'string' || !alg) { + throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid'); + } + checkKeyType(alg, key, 'sign'); + let payload = this._payload; + if (b64) { + payload = encoder.encode(encode(payload)); + } + let protectedHeader; + if (this._protectedHeader) { + protectedHeader = encoder.encode(encode(JSON.stringify(this._protectedHeader))); + } + else { + protectedHeader = encoder.encode(''); + } + const data = concat(protectedHeader, encoder.encode('.'), payload); + const signature = await sign(alg, key, data); + const jws = { + signature: encode(signature), + payload: '', + }; + if (b64) { + jws.payload = decoder.decode(payload); + } + if (this._unprotectedHeader) { + jws.header = this._unprotectedHeader; + } + if (this._protectedHeader) { + jws.protected = decoder.decode(protectedHeader); + } + return jws; + } +} + +class CompactSign { + constructor(payload) { + this._flattened = new FlattenedSign(payload); + } + setProtectedHeader(protectedHeader) { + this._flattened.setProtectedHeader(protectedHeader); + return this; + } + async sign(key, options) { + const jws = await this._flattened.sign(key, options); + if (jws.payload === undefined) { + throw new TypeError('use the flattened module for creating JWS with b64: false'); + } + return `${jws.protected}.${jws.payload}.${jws.signature}`; + } +} + +const check = (value, description) => { + if (typeof value !== 'string' || !value) { + throw new JWKInvalid(`${description} missing or invalid`); + } +}; +async function calculateJwkThumbprint(jwk, digestAlgorithm = 'sha256') { + if (!isObject(jwk)) { + throw new TypeError('JWK must be an object'); + } + let components; + switch (jwk.kty) { + case 'EC': + check(jwk.crv, '"crv" (Curve) Parameter'); + check(jwk.x, '"x" (X Coordinate) Parameter'); + check(jwk.y, '"y" (Y Coordinate) Parameter'); + components = { crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y }; + break; + case 'OKP': + check(jwk.crv, '"crv" (Subtype of Key Pair) Parameter'); + check(jwk.x, '"x" (Public Key) Parameter'); + components = { crv: jwk.crv, kty: jwk.kty, x: jwk.x }; + break; + case 'RSA': + check(jwk.e, '"e" (Exponent) Parameter'); + check(jwk.n, '"n" (Modulus) Parameter'); + components = { e: jwk.e, kty: jwk.kty, n: jwk.n }; + break; + case 'oct': + check(jwk.k, '"k" (Key Value) Parameter'); + components = { k: jwk.k, kty: jwk.kty }; + break; + default: + throw new JOSENotSupported('"kty" (Key Type) Parameter missing or unsupported'); + } + const data = encoder.encode(JSON.stringify(components)); + return encode(await digest(digestAlgorithm, data)); +} + +const sha = async function (input, algorithm = 'SHA-256') { + const algorithms = ['SHA-1', 'SHA-256', 'SHA-384', 'SHA-512']; + if (!algorithms.includes(algorithm)) { + throw new RangeError(`Valid hash algorith values are any of ${JSON.stringify(algorithms)}`); + } + const encoder = new TextEncoder(); + const hashInput = (typeof input === 'string') ? encoder.encode(input).buffer : input; + let digest = ''; + { + const buf = await crypto.subtle.digest(algorithm, hashInput); + const h = '0123456789abcdef'; + (new Uint8Array(buf)).forEach((v) => { + digest += h[v >> 4] + h[v & 15]; + }); + } + return digest; +}; + +// TODO decide a fixed delay for the protocol +const IAT_DELAY = 5000; +/** + * Validate Proof or Request using the Provider Public Key + */ +const validatePoR = async (publicKey, poR, poO) => { + const poRpayload = await decodePor(publicKey, poR); + const hashPooDgst = await sha(poO); + if (hashPooDgst !== poRpayload.exchange.poo_dgst) { + throw new Error('the hashed proof of origin received does not correspond to the poo_dgst parameter in the proof of origin'); + } + else if (Date.now() - poRpayload.iat > IAT_DELAY) { + throw new Error('timestamp error'); + } + else { + return true; + } +}; +/** + * Decode Proof of Reception with Consumer public key + */ +const decodePor = async (publicKey, poR) => { + const { payload } = await compactVerify(poR, publicKey).catch((e) => { + throw new Error(`PoR: ${String(e)}`); + }); + const decodedPoOPayload = JSON.parse(new TextDecoder().decode(payload).toString()); + return decodedPoOPayload; +}; +/** + * Validate Proof or Origin using the Consumer Public Key + */ +const validatePoO = async (publicKey, poO, cipherblock) => { + const poOpayload = await decodePoo(publicKey, poO); + const hashedCipherBlock = await sha(cipherblock); + if (poOpayload.exchange.cipherblock_dgst !== hashedCipherBlock) { + throw new Error('the cipherblock_dgst parameter in the proof of origin does not correspond to hash of the cipherblock received by the provider'); + } + else if (Date.now() - poOpayload.iat > IAT_DELAY) { + throw new Error('timestamp error'); + } + else { + return true; + } +}; +/** + * Decode Proof of Origin with Provider public key + */ +const decodePoo = async (publicKey, poO) => { + const { payload } = await compactVerify(poO, publicKey).catch((e) => { + throw new Error('PoO ' + String(e)); + }); + const decodedPoOPayload = JSON.parse(new TextDecoder().decode(payload).toString()); + return decodedPoOPayload; +}; +/** + * Validate Proof of Publication using the Backplain Public Key + */ +const validatePoP = (publicKeyBackplain, publicKeyProvider, poP, jwk, poO) => { + return new Promise((resolve, reject) => { + compactVerify(poP, publicKeyBackplain).catch((e) => { + reject(new Error('PoP ' + String(e))); + }); + decodePoo(publicKeyProvider, poO) + .then((poOPayload) => { + sha(JSON.stringify(jwk)) + .then(hashedJwk => { + if (poOPayload.exchange.key_commitment === hashedJwk) { + resolve(true); + } + else { + reject(new Error('hashed key not correspond to poO key_commitment parameter')); + } + }) + .catch(reason => reject(reason)); + }) + .catch(reason => reject(reason)); + }); +}; +/** + * Decrypt the cipherblock received + */ +const decryptCipherblock = async (chiperblock, jwk) => { + const decoder = new TextDecoder(); + const key = await importJWK(jwk, 'A256GCM'); // TODO: ENC_ALG + const { plaintext } = await compactDecrypt(chiperblock, key); + return decoder.decode(plaintext); +}; +/** + * Validate the cipherblock + */ +const validateCipherblock = async (publicKey, chiperblock, jwk, poO) => { + const decodedCipherBlock = await decryptCipherblock(chiperblock, jwk); + const hashedDecodedCipherBlock = await sha(decodedCipherBlock); + if (hashedDecodedCipherBlock === poO.exchange.block_commitment) { + // TODO check also block_description + return true; + } + else { + throw new Error('hashed CipherBlock not correspond to block_commitment parameter included in the proof of origin'); + } +}; + +const SIGNING_ALG = 'ES256'; +const ENC_ALG = 'AES-GCM'; +const ENC_ALG_KEY_LENGTH = 256; +/** + * + * Create Proof of Origin and sign with Provider private key + * + * @param privateKey - private key of the signer/issuer + * @param block - the blocks asdfsdfsd + * @param providerId + * @param consumerId + * @param exchangeId + * @param blockId + * @param jwk + * @returns + */ +const createPoO = async (privateKey, block, providerId, consumerId, exchangeId, blockId, jwk) => { + const input = (typeof block === 'string') ? (new TextEncoder()).encode(block) : new Uint8Array(block); + const key = await importJWK(jwk); + const cipherblock = await new CompactEncrypt(input) + .setProtectedHeader({ alg: 'dir', enc: 'A256GCM' }) + .encrypt(key); + const hashCipherblock = await sha(cipherblock); + const hashBlock = await sha(input); + const hashKey = await sha(JSON.stringify(jwk)); + const proof = { + iss: providerId, + sub: consumerId, + iat: Date.now(), + exchange: { + id: exchangeId, + orig: providerId, + dest: consumerId, + block_id: blockId, + block_desc: 'description', + hash_alg: 'sha256', + cipherblock_dgst: hashCipherblock, + block_commitment: hashBlock, + key_commitment: hashKey + } + }; + const signedProof = await signProof(privateKey, proof); + return { cipherblock: cipherblock, poO: signedProof }; +}; +/** + * Create a random (high entropy) symmetric JWK secret + * + * @returns a promise that resolves to a JWK + */ +const createJwk = async () => { + let key; + { + key = await window.crypto.subtle.generateKey({ + name: ENC_ALG, + length: ENC_ALG_KEY_LENGTH + }, true, ['encrypt', 'decrypt']); + } + const jwk = await exportJWK(key); + const thumbprint = await calculateJwkThumbprint(jwk); + jwk.kid = thumbprint; + jwk.alg = 'A256GCM'; + return jwk; +}; +/** + * Sign a proof with private key + */ +const signProof = async (privateKey, proof) => { + const jwt = new TextEncoder().encode(JSON.stringify(proof)); + const jws = await new CompactSign(jwt) + .setProtectedHeader({ alg: SIGNING_ALG }) + .sign(privateKey); + return jws; +}; +/** + * Create Proof of Receipt and sign with Consumer private key + */ +const createPoR = async (privateKey, poO, providerId, consumerId, exchangeId) => { + const hashPooDgst = await sha(poO); + const proof = { + iss: providerId, + sub: consumerId, + iat: Date.now(), + exchange: { + poo_dgst: hashPooDgst, + hash_alg: 'sha256', + exchangeId: exchangeId + } + }; + const signedProof = await signProof(privateKey, proof); + return signedProof; +}; +/** + * + * Prepare block to be send to the Backplain API + */ +const createBlockchainProof = async (publicKey, poO, poR, jwk) => { + const decodedPoO = await decodePoo(publicKey, poO); + const privateStorage = { + availability: 'privateStorage', + permissions: { + view: [decodedPoO.exchange.orig, decodedPoO.exchange.dest] + }, + type: 'dict', + id: decodedPoO.exchange.id, + content: { [decodedPoO.exchange.block_id]: { poO: poO, poR: poR } } + }; + const blockchain = { + availability: 'blockchain', + type: 'jwk', + content: { [jwk.kid]: jwk } // eslint-disable-line + }; + return { privateStorage, blockchain }; +}; + +export { SIGNING_ALG, createBlockchainProof, createJwk, createPoO, createPoR, decodePoo, decodePor, decryptCipherblock, sha, signProof, validateCipherblock, validatePoO, validatePoP, validatePoR }; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"esm.js","sources":["../../node_modules/jose/dist/browser/lib/buffer_utils.js","../../node_modules/jose/dist/browser/runtime/base64url.js","../../node_modules/jose/dist/browser/util/errors.js","../../node_modules/jose/dist/browser/runtime/webcrypto.js","../../node_modules/jose/dist/browser/runtime/random.js","../../node_modules/jose/dist/browser/lib/iv.js","../../node_modules/jose/dist/browser/lib/check_iv_length.js","../../node_modules/jose/dist/browser/runtime/check_cek_length.js","../../node_modules/jose/dist/browser/runtime/timing_safe_equal.js","../../node_modules/jose/dist/browser/runtime/env.js","../../node_modules/jose/dist/browser/lib/crypto_key.js","../../node_modules/jose/dist/browser/lib/invalid_key_input.js","../../node_modules/jose/dist/browser/runtime/is_key_like.js","../../node_modules/jose/dist/browser/runtime/decrypt.js","../../node_modules/jose/dist/browser/runtime/zlib.js","../../node_modules/jose/dist/browser/lib/is_disjoint.js","../../node_modules/jose/dist/browser/lib/is_object.js","../../node_modules/jose/dist/browser/runtime/bogus.js","../../node_modules/jose/dist/browser/runtime/aeskw.js","../../node_modules/jose/dist/browser/runtime/digest.js","../../node_modules/jose/dist/browser/runtime/ecdhes.js","../../node_modules/jose/dist/browser/lib/check_p2s.js","../../node_modules/jose/dist/browser/runtime/pbes2kw.js","../../node_modules/jose/dist/browser/runtime/subtle_rsaes.js","../../node_modules/jose/dist/browser/runtime/check_key_length.js","../../node_modules/jose/dist/browser/runtime/rsaes.js","../../node_modules/jose/dist/browser/lib/cek.js","../../node_modules/jose/dist/browser/runtime/jwk_to_key.js","../../node_modules/jose/dist/browser/key/import.js","../../node_modules/jose/dist/browser/lib/check_key_type.js","../../node_modules/jose/dist/browser/runtime/encrypt.js","../../node_modules/jose/dist/browser/lib/aesgcmkw.js","../../node_modules/jose/dist/browser/lib/decrypt_key_management.js","../../node_modules/jose/dist/browser/lib/validate_crit.js","../../node_modules/jose/dist/browser/lib/validate_algorithms.js","../../node_modules/jose/dist/browser/jwe/flattened/decrypt.js","../../node_modules/jose/dist/browser/jwe/compact/decrypt.js","../../node_modules/jose/dist/browser/runtime/key_to_jwk.js","../../node_modules/jose/dist/browser/key/export.js","../../node_modules/jose/dist/browser/lib/encrypt_key_management.js","../../node_modules/jose/dist/browser/jwe/flattened/encrypt.js","../../node_modules/jose/dist/browser/runtime/subtle_dsa.js","../../node_modules/jose/dist/browser/runtime/get_sign_verify_key.js","../../node_modules/jose/dist/browser/runtime/verify.js","../../node_modules/jose/dist/browser/jws/flattened/verify.js","../../node_modules/jose/dist/browser/jws/compact/verify.js","../../node_modules/jose/dist/browser/jwe/compact/encrypt.js","../../node_modules/jose/dist/browser/runtime/sign.js","../../node_modules/jose/dist/browser/jws/flattened/sign.js","../../node_modules/jose/dist/browser/jws/compact/sign.js","../../node_modules/jose/dist/browser/jwk/thumbprint.js","../../src/ts/sha.ts","../../src/ts/validateProofs.ts","../../src/ts/createProofs.ts"],"sourcesContent":null,"names":["crypto","bitLength","decrypt","getCryptoKey","wrap","unwrap","deriveKey","p2s","concatSalt","encrypt","base64url","subtleAlgorithm","decodeBase64URL","ECDH.ecdhAllowed","ECDH.deriveKey","cekLength","aesKw","rsaEs","pbes2Kw","aesGcmKw","keyToJWK","ECDH.generateEpk","getVerifyKey","getSignKey"],"mappings":"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"} diff --git a/dist/bundles/esm.min.js b/dist/bundles/esm.min.js new file mode 100644 index 0000000..206e4d1 --- /dev/null +++ b/dist/bundles/esm.min.js @@ -0,0 +1 @@ +const e=new TextEncoder,t=new TextDecoder;function r(...e){const t=e.reduce(((e,{length:t})=>e+t),0),r=new Uint8Array(t);let n=0;return e.forEach((e=>{r.set(e,n),n+=e.length})),r}function n(e,t,r){if(t<0||t>=4294967296)throw new RangeError(`value must be >= 0 and <= 4294967295. Received ${t}`);e.set([t>>>24,t>>>16,t>>>8,255&t],r)}function a(e){const t=Math.floor(e/4294967296),r=e%4294967296,a=new Uint8Array(8);return n(a,t,0),n(a,r,4),a}function o(e){const t=new Uint8Array(4);return n(t,e),t}function i(e){return r(o(e.length),e)}const s=t=>(t=>{let r=t;"string"==typeof r&&(r=e.encode(r));const n=[];for(let e=0;e{let r=e;r instanceof Uint8Array&&(r=t.decode(r)),r=r.replace(/-/g,"+").replace(/_/g,"/").replace(/\s/g,"");try{return(e=>new Uint8Array(atob(e).split("").map((e=>e.charCodeAt(0)))))(r)}catch(e){throw new TypeError("The input to be decoded is not correctly encoded.")}};class d extends Error{constructor(e){var t;super(e),this.code="ERR_JOSE_GENERIC",this.name=this.constructor.name,null===(t=Error.captureStackTrace)||void 0===t||t.call(Error,this,this.constructor)}static get code(){return"ERR_JOSE_GENERIC"}}class p extends d{constructor(){super(...arguments),this.code="ERR_JOSE_ALG_NOT_ALLOWED"}static get code(){return"ERR_JOSE_ALG_NOT_ALLOWED"}}class h extends d{constructor(){super(...arguments),this.code="ERR_JOSE_NOT_SUPPORTED"}static get code(){return"ERR_JOSE_NOT_SUPPORTED"}}class y extends d{constructor(){super(...arguments),this.code="ERR_JWE_DECRYPTION_FAILED",this.message="decryption operation failed"}static get code(){return"ERR_JWE_DECRYPTION_FAILED"}}class u extends d{constructor(){super(...arguments),this.code="ERR_JWE_INVALID"}static get code(){return"ERR_JWE_INVALID"}}class w extends d{constructor(){super(...arguments),this.code="ERR_JWS_INVALID"}static get code(){return"ERR_JWS_INVALID"}}class l extends d{constructor(){super(...arguments),this.code="ERR_JWK_INVALID"}static get code(){return"ERR_JWK_INVALID"}}class f extends d{constructor(){super(...arguments),this.code="ERR_JWS_SIGNATURE_VERIFICATION_FAILED",this.message="signature verification failed"}static get code(){return"ERR_JWS_SIGNATURE_VERIFICATION_FAILED"}}var g=crypto;function E(e){try{return null!=e&&"boolean"==typeof e.extractable&&"string"==typeof e.algorithm.name&&"string"==typeof e.type}catch(e){return!1}}var m=g.getRandomValues.bind(g);function A(e){switch(e){case"A128GCM":case"A128GCMKW":case"A192GCM":case"A192GCMKW":case"A256GCM":case"A256GCMKW":return 96;case"A128CBC-HS256":case"A192CBC-HS384":case"A256CBC-HS512":return 128;default:throw new h(`Unsupported JWE Algorithm: ${e}`)}}var S=e=>m(new Uint8Array(A(e)>>3));const b=(e,t)=>{if(t.length<<3!==A(e))throw new u("Invalid Initialization Vector length")},v=(e,t)=>{if(e.length<<3!==t)throw new u("Invalid Content Encryption Key length")};function H(){return"function"==typeof WebSocketPair}function C(){try{return void 0!==process.versions.node}catch(e){return!1}}function P(e,t="algorithm.name"){return new TypeError(`CryptoKey does not support this operation, its ${t} must be ${e}`)}function K(e,t){return e.name===t}function _(e){return parseInt(e.name.substr(4),10)}function W(e,t){if(t.length&&!t.some((t=>e.usages.includes(t)))){let e="CryptoKey does not support this operation, its usages must include ";if(t.length>2){const r=t.pop();e+=`one of ${t.join(", ")}, or ${r}.`}else 2===t.length?e+=`one of ${t[0]} or ${t[1]}.`:e+=`${t[0]}.`;throw new TypeError(e)}}function k(e,t,...r){switch(t){case"HS256":case"HS384":case"HS512":{if(!K(e.algorithm,"HMAC"))throw P("HMAC");const r=parseInt(t.substr(2),10);if(_(e.algorithm.hash)!==r)throw P(`SHA-${r}`,"algorithm.hash");break}case"RS256":case"RS384":case"RS512":{if(!K(e.algorithm,"RSASSA-PKCS1-v1_5"))throw P("RSASSA-PKCS1-v1_5");const r=parseInt(t.substr(2),10);if(_(e.algorithm.hash)!==r)throw P(`SHA-${r}`,"algorithm.hash");break}case"PS256":case"PS384":case"PS512":{if(!K(e.algorithm,"RSA-PSS"))throw P("RSA-PSS");const r=parseInt(t.substr(2),10);if(_(e.algorithm.hash)!==r)throw P(`SHA-${r}`,"algorithm.hash");break}case C()&&"EdDSA":if("NODE-ED25519"!==e.algorithm.name&&"NODE-ED448"!==e.algorithm.name)throw P("NODE-ED25519 or NODE-ED448");break;case H()&&"EdDSA":if(!K(e.algorithm,"NODE-ED25519"))throw P("NODE-ED25519");break;case"ES256":case"ES384":case"ES512":{if(!K(e.algorithm,"ECDSA"))throw P("ECDSA");const r=function(e){switch(e){case"ES256":return"P-256";case"ES384":return"P-384";case"ES512":return"P-521";default:throw new Error("unreachable")}}(t);if(e.algorithm.namedCurve!==r)throw P(r,"algorithm.namedCurve");break}default:throw new TypeError("CryptoKey does not support this operation")}W(e,r)}function U(e,t,...r){switch(t){case"A128GCM":case"A192GCM":case"A256GCM":{if(!K(e.algorithm,"AES-GCM"))throw P("AES-GCM");const r=parseInt(t.substr(1,3),10);if(e.algorithm.length!==r)throw P(r,"algorithm.length");break}case"A128KW":case"A192KW":case"A256KW":{if(!K(e.algorithm,"AES-KW"))throw P("AES-KW");const r=parseInt(t.substr(1,3),10);if(e.algorithm.length!==r)throw P(r,"algorithm.length");break}case"ECDH-ES":if(!K(e.algorithm,"ECDH"))throw P("ECDH");break;case"PBES2-HS256+A128KW":case"PBES2-HS384+A192KW":case"PBES2-HS512+A256KW":if(!K(e.algorithm,"PBKDF2"))throw P("PBKDF2");break;case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":{if(!K(e.algorithm,"RSA-OAEP"))throw P("RSA-OAEP");const r=parseInt(t.substr(9),10)||1;if(_(e.algorithm.hash)!==r)throw P(`SHA-${r}`,"algorithm.hash");break}default:throw new TypeError("CryptoKey does not support this operation")}W(e,r)}var R=(e,...t)=>{let r="Key must be ";if(t.length>2){const e=t.pop();r+=`one of type ${t.join(", ")}, or ${e}.`}else 2===t.length?r+=`one of type ${t[0]} or ${t[1]}.`:r+=`of type ${t[0]}.`;return null==e?r+=` Received ${e}`:"function"==typeof e&&e.name?r+=` Received function ${e.name}`:"object"==typeof e&&null!=e&&e.constructor&&e.constructor.name&&(r+=` Received an instance of ${e.constructor.name}`),r},J=e=>E(e);const D=["CryptoKey"];async function O(e,t,n,o,i,s){if(!(t instanceof Uint8Array))throw new TypeError(R(t,"Uint8Array"));const c=parseInt(e.substr(1,3),10),d=await g.subtle.importKey("raw",t.subarray(c>>3),"AES-CBC",!1,["decrypt"]),p=await g.subtle.importKey("raw",t.subarray(0,c>>3),{hash:"SHA-"+(c<<1),name:"HMAC"},!1,["sign"]),h=r(s,o,n,a(s.length<<3)),u=new Uint8Array((await g.subtle.sign("HMAC",p,h)).slice(0,c>>3));let w,l;try{w=((e,t)=>{if(!(e instanceof Uint8Array))throw new TypeError("First argument must be a buffer");if(!(t instanceof Uint8Array))throw new TypeError("Second argument must be a buffer");if(e.length!==t.length)throw new TypeError("Input buffers must have the same length");const r=e.length;let n=0,a=-1;for(;++a{if(!(E(t)||t instanceof Uint8Array))throw new TypeError(R(t,...D,"Uint8Array"));switch(b(e,a),e){case"A128CBC-HS256":case"A192CBC-HS384":case"A256CBC-HS512":return t instanceof Uint8Array&&v(t,parseInt(e.substr(-3),10)),O(e,t,n,a,o,i);case"A128GCM":case"A192GCM":case"A256GCM":return t instanceof Uint8Array&&v(t,parseInt(e.substr(1,3),10)),async function(e,t,n,a,o,i){let s;t instanceof Uint8Array?s=await g.subtle.importKey("raw",t,"AES-GCM",!1,["decrypt"]):(U(t,e,"decrypt"),s=t);try{return new Uint8Array(await g.subtle.decrypt({additionalData:i,iv:a,name:"AES-GCM",tagLength:128},s,r(n,o)))}catch(e){throw new y}}(e,t,n,a,o,i);default:throw new h("Unsupported JWE Content Encryption Algorithm")}},M=async()=>{throw new h('JWE "zip" (Compression Algorithm) Header Parameter is not supported by your javascript runtime. You need to use the `inflateRaw` decrypt option to provide Inflate Raw implementation.')},I=async()=>{throw new h('JWE "zip" (Compression Algorithm) Header Parameter is not supported by your javascript runtime. You need to use the `deflateRaw` encrypt option to provide Deflate Raw implementation.')},x=(...e)=>{const t=e.filter(Boolean);if(0===t.length||1===t.length)return!0;let r;for(const e of t){const t=Object.keys(e);if(r&&0!==r.size)for(const e of t){if(r.has(e))return!1;r.add(e)}else r=new Set(t)}return!0};function B(e){if("object"!=typeof(t=e)||null===t||"[object Object]"!==Object.prototype.toString.call(e))return!1;var t;if(null===Object.getPrototypeOf(e))return!0;let r=e;for(;null!==Object.getPrototypeOf(r);)r=Object.getPrototypeOf(r);return Object.getPrototypeOf(e)===r}const $=[{hash:"SHA-256",name:"HMAC"},!0,["sign"]];function G(e,t){if(e.algorithm.length!==parseInt(t.substr(1,3),10))throw new TypeError(`Invalid key size for alg: ${t}`)}function j(e,t,r){if(E(e))return U(e,t,r),e;if(e instanceof Uint8Array)return g.subtle.importKey("raw",e,"AES-KW",!0,[r]);throw new TypeError(R(e,...D,"Uint8Array"))}const N=async(e,t,r)=>{const n=await j(t,e,"wrapKey");G(n,e);const a=await g.subtle.importKey("raw",r,...$);return new Uint8Array(await g.subtle.wrapKey("raw",a,n,"AES-KW"))},z=async(e,t,r)=>{const n=await j(t,e,"unwrapKey");G(n,e);const a=await g.subtle.unwrapKey("raw",r,n,"AES-KW",...$);return new Uint8Array(await g.subtle.exportKey("raw",a))},F=async(e,t)=>{const r=`SHA-${e.substr(-3)}`;return new Uint8Array(await g.subtle.digest(r,t))},L=async(t,n,a,s,c=new Uint8Array(0),d=new Uint8Array(0))=>{if(!E(t))throw new TypeError(R(t,...D));if(U(t,"ECDH-ES"),!E(n))throw new TypeError(R(n,...D));U(n,"ECDH-ES","deriveBits","deriveKey");const p=r(i(e.encode(a)),i(c),i(d),o(s));if(!n.usages.includes("deriveBits"))throw new TypeError('ECDH-ES private key "usages" must include "deriveBits"');const h=new Uint8Array(await g.subtle.deriveBits({name:"ECDH",public:t},n,Math.ceil(parseInt(n.algorithm.namedCurve.substr(-3),10)/8)<<3));return async function(e,t,n,a){const i=Math.ceil((n>>3)/32);let s;for(let n=1;n<=i;n++){const i=new Uint8Array(4+t.length+a.length);i.set(o(n)),i.set(t,4),i.set(a,4+t.length),s=s?r(s,await e("sha256",i)):await e("sha256",i)}return s=s.slice(0,n>>3),s}(F,h,s,p)},V=e=>{if(!E(e))throw new TypeError(R(e,...D));return["P-256","P-384","P-521"].includes(e.algorithm.namedCurve)};async function Y(t,n,a,o){!function(e){if(!(e instanceof Uint8Array)||e.length<8)throw new u("PBES2 Salt Input must be 8 or more octets")}(t);const i=function(t,n){return r(e.encode(t),new Uint8Array([0]),n)}(n,t),s=parseInt(n.substr(13,3),10),c={hash:`SHA-${n.substr(8,3)}`,iterations:a,name:"PBKDF2",salt:i},d={length:s,name:"AES-KW"},p=await function(e,t){if(e instanceof Uint8Array)return g.subtle.importKey("raw",e,"PBKDF2",!1,["deriveBits"]);if(E(e))return U(e,t,"deriveBits","deriveKey"),e;throw new TypeError(R(e,...D,"Uint8Array"))}(o,n);if(p.usages.includes("deriveBits"))return new Uint8Array(await g.subtle.deriveBits(c,p,s));if(p.usages.includes("deriveKey"))return g.subtle.deriveKey(c,p,d,!1,["wrapKey","unwrapKey"]);throw new TypeError('PBKDF2 key "usages" must include "deriveBits" or "deriveKey"')}function q(e){switch(e){case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":return"RSA-OAEP";default:throw new h(`alg ${e} is not supported either by JOSE or your javascript runtime`)}}var X=(e,t)=>{if(e.startsWith("RS")||e.startsWith("PS")){const{modulusLength:r}=t.algorithm;if("number"!=typeof r||r<2048)throw new TypeError(`${e} requires key modulusLength to be 2048 bits or larger`)}};function Q(e){switch(e){case"A128GCM":return 128;case"A192GCM":return 192;case"A256GCM":case"A128CBC-HS256":return 256;case"A192CBC-HS384":return 384;case"A256CBC-HS512":return 512;default:throw new h(`Unsupported JWE Algorithm: ${e}`)}}var Z=e=>m(new Uint8Array(Q(e)>>3));var ee=async e=>{var t,r;const{algorithm:n,keyUsages:a}=function(e){let t,r;switch(e.kty){case"oct":switch(e.alg){case"HS256":case"HS384":case"HS512":t={name:"HMAC",hash:`SHA-${e.alg.substr(-3)}`},r=["sign","verify"];break;case"A128CBC-HS256":case"A192CBC-HS384":case"A256CBC-HS512":throw new h(`${e.alg} keys cannot be imported as CryptoKey instances`);case"A128GCM":case"A192GCM":case"A256GCM":case"A128GCMKW":case"A192GCMKW":case"A256GCMKW":t={name:"AES-GCM"},r=["encrypt","decrypt"];break;case"A128KW":case"A192KW":case"A256KW":t={name:"AES-KW"},r=["wrapKey","unwrapKey"];break;case"PBES2-HS256+A128KW":case"PBES2-HS384+A192KW":case"PBES2-HS512+A256KW":t={name:"PBKDF2"},r=["deriveBits"];break;default:throw new h('Invalid or unsupported JWK "alg" (Algorithm) Parameter value')}break;case"RSA":switch(e.alg){case"PS256":case"PS384":case"PS512":t={name:"RSA-PSS",hash:`SHA-${e.alg.substr(-3)}`},r=e.d?["sign"]:["verify"];break;case"RS256":case"RS384":case"RS512":t={name:"RSASSA-PKCS1-v1_5",hash:`SHA-${e.alg.substr(-3)}`},r=e.d?["sign"]:["verify"];break;case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":t={name:"RSA-OAEP",hash:`SHA-${parseInt(e.alg.substr(-3),10)||1}`},r=e.d?["decrypt","unwrapKey"]:["encrypt","wrapKey"];break;default:throw new h('Invalid or unsupported JWK "alg" (Algorithm) Parameter value')}break;case"EC":switch(e.alg){case"ES256":t={name:"ECDSA",namedCurve:"P-256"},r=e.d?["sign"]:["verify"];break;case"ES384":t={name:"ECDSA",namedCurve:"P-384"},r=e.d?["sign"]:["verify"];break;case"ES512":t={name:"ECDSA",namedCurve:"P-521"},r=e.d?["sign"]:["verify"];break;case"ECDH-ES":case"ECDH-ES+A128KW":case"ECDH-ES+A192KW":case"ECDH-ES+A256KW":t={name:"ECDH",namedCurve:e.crv},r=e.d?["deriveBits"]:[];break;default:throw new h('Invalid or unsupported JWK "alg" (Algorithm) Parameter value')}break;case(H()||C())&&"OKP":if("EdDSA"!==e.alg)throw new h('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');switch(e.crv){case"Ed25519":t={name:"NODE-ED25519",namedCurve:"NODE-ED25519"},r=e.d?["sign"]:["verify"];break;case C()&&"Ed448":t={name:"NODE-ED448",namedCurve:"NODE-ED448"},r=e.d?["sign"]:["verify"];break;default:throw new h('Invalid or unsupported JWK "crv" (Subtype of Key Pair) Parameter value')}break;default:throw new h('Invalid or unsupported JWK "kty" (Key Type) Parameter value')}return{algorithm:t,keyUsages:r}}(e),o=[n,null!==(t=e.ext)&&void 0!==t&&t,null!==(r=e.key_ops)&&void 0!==r?r:a];if("PBKDF2"===n.name)return g.subtle.importKey("raw",c(e.k),...o);const i={...e};return delete i.alg,g.subtle.importKey("jwk",i,...o)};async function te(e,t,r){if(!B(e))throw new TypeError("JWK must be an object");if(t||(t=e.alg),"string"!=typeof t||!t)throw new TypeError('"alg" argument is required when "jwk.alg" is not present');switch(e.kty){case"oct":if("string"!=typeof e.k||!e.k)throw new TypeError('missing "k" (Key Value) Parameter value');return null!=r||(r=!0!==e.ext),r?ee({...e,alg:t,ext:!1}):c(e.k);case"RSA":if(void 0!==e.oth)throw new h('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');case"EC":case"OKP":return ee({...e,alg:t});default:throw new h('Unsupported "kty" (Key Type) Parameter value')}}const re=(e,t,r)=>{e.startsWith("HS")||"dir"===e||e.startsWith("PBES2")||/^A\d{3}(?:GCM)?KW$/.test(e)?(e=>{if(!(e instanceof Uint8Array)){if(!J(e))throw new TypeError(R(e,...D,"Uint8Array"));if("secret"!==e.type)throw new TypeError(`${D.join(" or ")} instances for symmetric algorithms must be of type "secret"`)}})(t):((e,t)=>{if(!J(e))throw new TypeError(R(e,...D));if("secret"===e.type)throw new TypeError(`${D.join(" or ")} instances for asymmetric algorithms must not be of type "secret"`);if("sign"===t&&"public"===e.type)throw new TypeError(`${D.join(" or ")} instances for asymmetric algorithm signing must be of type "private"`);if("decrypt"===t&&"public"===e.type)throw new TypeError(`${D.join(" or ")} instances for asymmetric algorithm decryption must be of type "private"`);if(e.algorithm&&"verify"===t&&"private"===e.type)throw new TypeError(`${D.join(" or ")} instances for asymmetric algorithm verifying must be of type "public"`);if(e.algorithm&&"encrypt"===t&&"private"===e.type)throw new TypeError(`${D.join(" or ")} instances for asymmetric algorithm encryption must be of type "public"`)})(t,r)};const ne=async(e,t,n,o,i)=>{if(!(E(n)||n instanceof Uint8Array))throw new TypeError(R(n,...D,"Uint8Array"));switch(b(e,o),e){case"A128CBC-HS256":case"A192CBC-HS384":case"A256CBC-HS512":return n instanceof Uint8Array&&v(n,parseInt(e.substr(-3),10)),async function(e,t,n,o,i){if(!(n instanceof Uint8Array))throw new TypeError(R(n,"Uint8Array"));const s=parseInt(e.substr(1,3),10),c=await g.subtle.importKey("raw",n.subarray(s>>3),"AES-CBC",!1,["encrypt"]),d=await g.subtle.importKey("raw",n.subarray(0,s>>3),{hash:"SHA-"+(s<<1),name:"HMAC"},!1,["sign"]),p=new Uint8Array(await g.subtle.encrypt({iv:o,name:"AES-CBC"},c,t)),h=r(i,o,p,a(i.length<<3));return{ciphertext:p,tag:new Uint8Array((await g.subtle.sign("HMAC",d,h)).slice(0,s>>3))}}(e,t,n,o,i);case"A128GCM":case"A192GCM":case"A256GCM":return n instanceof Uint8Array&&v(n,parseInt(e.substr(1,3),10)),async function(e,t,r,n,a){let o;r instanceof Uint8Array?o=await g.subtle.importKey("raw",r,"AES-GCM",!1,["encrypt"]):(U(r,e,"encrypt"),o=r);const i=new Uint8Array(await g.subtle.encrypt({additionalData:a,iv:n,name:"AES-GCM",tagLength:128},o,t)),s=i.slice(-16);return{ciphertext:i.slice(0,-16),tag:s}}(e,t,n,o,i);default:throw new h("Unsupported JWE Content Encryption Algorithm")}};async function ae(e,t,r,n){switch(re(e,t,"decrypt"),e){case"dir":if(void 0!==r)throw new u("Encountered unexpected JWE Encrypted Key");return t;case"ECDH-ES":if(void 0!==r)throw new u("Encountered unexpected JWE Encrypted Key");case"ECDH-ES+A128KW":case"ECDH-ES+A192KW":case"ECDH-ES+A256KW":{if(!B(n.epk))throw new u('JOSE Header "epk" (Ephemeral Public Key) missing or invalid');if(!V(t))throw new h("ECDH-ES with the provided key is not allowed or not supported by your javascript runtime");const a=await te(n.epk,e);let o,i;if(void 0!==n.apu){if("string"!=typeof n.apu)throw new u('JOSE Header "apu" (Agreement PartyUInfo) invalid');o=c(n.apu)}if(void 0!==n.apv){if("string"!=typeof n.apv)throw new u('JOSE Header "apv" (Agreement PartyVInfo) invalid');i=c(n.apv)}const s=await L(a,t,"ECDH-ES"===e?n.enc:e,"ECDH-ES"===e?Q(n.enc):parseInt(e.substr(-5,3),10),o,i);if("ECDH-ES"===e)return s;if(void 0===r)throw new u("JWE Encrypted Key missing");return z(e.substr(-6),s,r)}case"RSA1_5":case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":if(void 0===r)throw new u("JWE Encrypted Key missing");return(async(e,t,r)=>{if(!E(t))throw new TypeError(R(t,...D));if(U(t,e,"decrypt","unwrapKey"),X(e,t),t.usages.includes("decrypt"))return new Uint8Array(await g.subtle.decrypt(q(e),t,r));if(t.usages.includes("unwrapKey")){const n=await g.subtle.unwrapKey("raw",r,t,q(e),...$);return new Uint8Array(await g.subtle.exportKey("raw",n))}throw new TypeError('RSA-OAEP key "usages" must include "decrypt" or "unwrapKey" for this operation')})(e,t,r);case"PBES2-HS256+A128KW":case"PBES2-HS384+A192KW":case"PBES2-HS512+A256KW":if(void 0===r)throw new u("JWE Encrypted Key missing");if("number"!=typeof n.p2c)throw new u('JOSE Header "p2c" (PBES2 Count) missing or invalid');if("string"!=typeof n.p2s)throw new u('JOSE Header "p2s" (PBES2 Salt) missing or invalid');return(async(e,t,r,n,a)=>{const o=await Y(a,e,n,t);return z(e.substr(-6),o,r)})(e,t,r,n.p2c,c(n.p2s));case"A128KW":case"A192KW":case"A256KW":if(void 0===r)throw new u("JWE Encrypted Key missing");return z(e,t,r);case"A128GCMKW":case"A192GCMKW":case"A256GCMKW":if(void 0===r)throw new u("JWE Encrypted Key missing");if("string"!=typeof n.iv)throw new u('JOSE Header "iv" (Initialization Vector) missing or invalid');if("string"!=typeof n.tag)throw new u('JOSE Header "tag" (Authentication Tag) missing or invalid');return async function(e,t,r,n,a){const o=e.substr(0,7);return T(o,t,r,n,a,new Uint8Array(0))}(e,t,r,c(n.iv),c(n.tag));default:throw new h('Invalid or unsupported "alg" (JWE Algorithm) header value')}}function oe(e,t,r,n,a){if(void 0!==a.crit&&void 0===n.crit)throw new e('"crit" (Critical) Header Parameter MUST be integrity protected');if(!n||void 0===n.crit)return new Set;if(!Array.isArray(n.crit)||0===n.crit.length||n.crit.some((e=>"string"!=typeof e||0===e.length)))throw new e('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');let o;o=void 0!==r?new Map([...Object.entries(r),...t.entries()]):t;for(const t of n.crit){if(!o.has(t))throw new h(`Extension Header Parameter "${t}" is not recognized`);if(void 0===a[t])throw new e(`Extension Header Parameter "${t}" is missing`);if(o.get(t)&&void 0===n[t])throw new e(`Extension Header Parameter "${t}" MUST be integrity protected`)}return new Set(n.crit)}const ie=(e,t)=>{if(void 0!==t&&(!Array.isArray(t)||t.some((e=>"string"!=typeof e))))throw new TypeError(`"${e}" option must be an array of strings`);if(t)return new Set(t)};async function se(n,a,o){var i;if(!B(n))throw new u("Flattened JWE must be an object");if(void 0===n.protected&&void 0===n.header&&void 0===n.unprotected)throw new u("JOSE Header missing");if("string"!=typeof n.iv)throw new u("JWE Initialization Vector missing or incorrect type");if("string"!=typeof n.ciphertext)throw new u("JWE Ciphertext missing or incorrect type");if("string"!=typeof n.tag)throw new u("JWE Authentication Tag missing or incorrect type");if(void 0!==n.protected&&"string"!=typeof n.protected)throw new u("JWE Protected Header incorrect type");if(void 0!==n.encrypted_key&&"string"!=typeof n.encrypted_key)throw new u("JWE Encrypted Key incorrect type");if(void 0!==n.aad&&"string"!=typeof n.aad)throw new u("JWE AAD incorrect type");if(void 0!==n.header&&!B(n.header))throw new u("JWE Shared Unprotected Header incorrect type");if(void 0!==n.unprotected&&!B(n.unprotected))throw new u("JWE Per-Recipient Unprotected Header incorrect type");let s;if(n.protected){const e=c(n.protected);try{s=JSON.parse(t.decode(e))}catch(e){throw new u("JWE Protected Header is invalid")}}if(!x(s,n.header,n.unprotected))throw new u("JWE Protected, JWE Unprotected Header, and JWE Per-Recipient Unprotected Header Parameter names must be disjoint");const d={...s,...n.header,...n.unprotected};if(oe(u,new Map,null==o?void 0:o.crit,s,d),void 0!==d.zip){if(!s||!s.zip)throw new u('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');if("DEF"!==d.zip)throw new h('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value')}const{alg:y,enc:w}=d;if("string"!=typeof y||!y)throw new u("missing JWE Algorithm (alg) in JWE Header");if("string"!=typeof w||!w)throw new u("missing JWE Encryption Algorithm (enc) in JWE Header");const l=o&&ie("keyManagementAlgorithms",o.keyManagementAlgorithms),f=o&&ie("contentEncryptionAlgorithms",o.contentEncryptionAlgorithms);if(l&&!l.has(y))throw new p('"alg" (Algorithm) Header Parameter not allowed');if(f&&!f.has(w))throw new p('"enc" (Encryption Algorithm) Header Parameter not allowed');let g;void 0!==n.encrypted_key&&(g=c(n.encrypted_key));let E,m=!1;"function"==typeof a&&(a=await a(s,n),m=!0);try{E=await ae(y,a,g,d)}catch(e){if(e instanceof TypeError)throw e;E=Z(w)}const A=c(n.iv),S=c(n.tag),b=e.encode(null!==(i=n.protected)&&void 0!==i?i:"");let v;v=void 0!==n.aad?r(b,e.encode("."),e.encode(n.aad)):b;let H=await T(w,E,c(n.ciphertext),A,S,v);"DEF"===d.zip&&(H=await((null==o?void 0:o.inflateRaw)||M)(H));const C={plaintext:H};return void 0!==n.protected&&(C.protectedHeader=s),void 0!==n.aad&&(C.additionalAuthenticatedData=c(n.aad)),void 0!==n.unprotected&&(C.sharedUnprotectedHeader=n.unprotected),void 0!==n.header&&(C.unprotectedHeader=n.header),m?{...C,key:a}:C}async function ce(e,r,n){if(e instanceof Uint8Array&&(e=t.decode(e)),"string"!=typeof e)throw new u("Compact JWE must be a string or Uint8Array");const{0:a,1:o,2:i,3:s,4:c,length:d}=e.split(".");if(5!==d)throw new u("Invalid Compact JWE");const p=await se({ciphertext:s||void 0,iv:i||void 0,protected:a||void 0,tag:c||void 0,encrypted_key:o||void 0},r,n),h={plaintext:p.plaintext,protectedHeader:p.protectedHeader};return"function"==typeof r?{...h,key:p.key}:h}var de=async e=>{if(e instanceof Uint8Array)return{kty:"oct",k:s(e)};if(!E(e))throw new TypeError(R(e,...D,"Uint8Array"));if(!e.extractable)throw new TypeError("non-extractable CryptoKey cannot be exported as a JWK");const{ext:t,key_ops:r,alg:n,use:a,...o}=await g.subtle.exportKey("jwk",e);return o};async function pe(e){return de(e)}async function he(e,t,r,n,a={}){let o,i,c;switch(re(e,r,"encrypt"),e){case"dir":c=r;break;case"ECDH-ES":case"ECDH-ES+A128KW":case"ECDH-ES+A192KW":case"ECDH-ES+A256KW":{if(!V(r))throw new h("ECDH-ES with the provided key is not allowed or not supported by your javascript runtime");const{apu:d,apv:p}=a;let{epk:y}=a;y||(y=await(async e=>{if(!E(e))throw new TypeError(R(e,...D));return(await g.subtle.generateKey({name:"ECDH",namedCurve:e.algorithm.namedCurve},!0,["deriveBits"])).privateKey})(r));const{x:u,y:w,crv:l,kty:f}=await pe(y),m=await L(r,y,"ECDH-ES"===e?t:e,"ECDH-ES"===e?Q(t):parseInt(e.substr(-5,3),10),d,p);if(i={epk:{x:u,y:w,crv:l,kty:f}},d&&(i.apu=s(d)),p&&(i.apv=s(p)),"ECDH-ES"===e){c=m;break}c=n||Z(t);const A=e.substr(-6);o=await N(A,m,c);break}case"RSA1_5":case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":c=n||Z(t),o=await(async(e,t,r)=>{if(!E(t))throw new TypeError(R(t,...D));if(U(t,e,"encrypt","wrapKey"),X(e,t),t.usages.includes("encrypt"))return new Uint8Array(await g.subtle.encrypt(q(e),t,r));if(t.usages.includes("wrapKey")){const n=await g.subtle.importKey("raw",r,...$);return new Uint8Array(await g.subtle.wrapKey("raw",n,t,q(e)))}throw new TypeError('RSA-OAEP key "usages" must include "encrypt" or "wrapKey" for this operation')})(e,r,c);break;case"PBES2-HS256+A128KW":case"PBES2-HS384+A192KW":case"PBES2-HS512+A256KW":{c=n||Z(t);const{p2c:d,p2s:p}=a;({encryptedKey:o,...i}=await(async(e,t,r,n=Math.floor(2049*Math.random())+2048,a=m(new Uint8Array(16)))=>{const o=await Y(a,e,n,t);return{encryptedKey:await N(e.substr(-6),o,r),p2c:n,p2s:s(a)}})(e,r,c,d,p));break}case"A128KW":case"A192KW":case"A256KW":c=n||Z(t),o=await N(e,r,c);break;case"A128GCMKW":case"A192GCMKW":case"A256GCMKW":{c=n||Z(t);const{iv:d}=a;({encryptedKey:o,...i}=await async function(e,t,r,n){const a=e.substr(0,7);n||(n=S(a));const{ciphertext:o,tag:i}=await ne(a,r,t,n,new Uint8Array(0));return{encryptedKey:o,iv:s(n),tag:s(i)}}(e,r,c,d));break}default:throw new h('Invalid or unsupported "alg" (JWE Algorithm) header value')}return{cek:c,encryptedKey:o,parameters:i}}const ye=Symbol();class ue{constructor(e){if(!(e instanceof Uint8Array))throw new TypeError("plaintext must be an instance of Uint8Array");this._plaintext=e}setKeyManagementParameters(e){if(this._keyManagementParameters)throw new TypeError("setKeyManagementParameters can only be called once");return this._keyManagementParameters=e,this}setProtectedHeader(e){if(this._protectedHeader)throw new TypeError("setProtectedHeader can only be called once");return this._protectedHeader=e,this}setSharedUnprotectedHeader(e){if(this._sharedUnprotectedHeader)throw new TypeError("setSharedUnprotectedHeader can only be called once");return this._sharedUnprotectedHeader=e,this}setUnprotectedHeader(e){if(this._unprotectedHeader)throw new TypeError("setUnprotectedHeader can only be called once");return this._unprotectedHeader=e,this}setAdditionalAuthenticatedData(e){return this._aad=e,this}setContentEncryptionKey(e){if(this._cek)throw new TypeError("setContentEncryptionKey can only be called once");return this._cek=e,this}setInitializationVector(e){if(this._iv)throw new TypeError("setInitializationVector can only be called once");return this._iv=e,this}async encrypt(n,a){if(!this._protectedHeader&&!this._unprotectedHeader&&!this._sharedUnprotectedHeader)throw new u("either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()");if(!x(this._protectedHeader,this._unprotectedHeader,this._sharedUnprotectedHeader))throw new u("JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint");const o={...this._protectedHeader,...this._unprotectedHeader,...this._sharedUnprotectedHeader};if(oe(u,new Map,null==a?void 0:a.crit,this._protectedHeader,o),void 0!==o.zip){if(!this._protectedHeader||!this._protectedHeader.zip)throw new u('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');if("DEF"!==o.zip)throw new h('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value')}const{alg:i,enc:c}=o;if("string"!=typeof i||!i)throw new u('JWE "alg" (Algorithm) Header Parameter missing or invalid');if("string"!=typeof c||!c)throw new u('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');let d,p,y,w,l,f,g;if("dir"===i){if(this._cek)throw new TypeError("setContentEncryptionKey cannot be called when using Direct Encryption")}else if("ECDH-ES"===i&&this._cek)throw new TypeError("setContentEncryptionKey cannot be called when using Direct Key Agreement");{let e;({cek:p,encryptedKey:d,parameters:e}=await he(i,c,n,this._cek,this._keyManagementParameters)),e&&(a&&ye in a?this._unprotectedHeader?this._unprotectedHeader={...this._unprotectedHeader,...e}:this.setUnprotectedHeader(e):this._protectedHeader?this._protectedHeader={...this._protectedHeader,...e}:this.setProtectedHeader(e))}if(this._iv||(this._iv=S(c)),w=this._protectedHeader?e.encode(s(JSON.stringify(this._protectedHeader))):e.encode(""),this._aad?(l=s(this._aad),y=r(w,e.encode("."),e.encode(l))):y=w,"DEF"===o.zip){const e=await((null==a?void 0:a.deflateRaw)||I)(this._plaintext);({ciphertext:f,tag:g}=await ne(c,e,p,this._iv,y))}else({ciphertext:f,tag:g}=await ne(c,this._plaintext,p,this._iv,y));const E={ciphertext:s(f),iv:s(this._iv),tag:s(g)};return d&&(E.encrypted_key=s(d)),l&&(E.aad=l),this._protectedHeader&&(E.protected=t.decode(w)),this._sharedUnprotectedHeader&&(E.unprotected=this._sharedUnprotectedHeader),this._unprotectedHeader&&(E.header=this._unprotectedHeader),E}}function we(e,t){const r=parseInt(e.substr(-3),10);switch(e){case"HS256":case"HS384":case"HS512":return{hash:`SHA-${r}`,name:"HMAC"};case"PS256":case"PS384":case"PS512":return{hash:`SHA-${r}`,name:"RSA-PSS",saltLength:r>>3};case"RS256":case"RS384":case"RS512":return{hash:`SHA-${r}`,name:"RSASSA-PKCS1-v1_5"};case"ES256":case"ES384":case"ES512":return{hash:`SHA-${r}`,name:"ECDSA",namedCurve:t};case(H()||C())&&"EdDSA":return{name:t,namedCurve:t};default:throw new h(`alg ${e} is not supported either by JOSE or your javascript runtime`)}}function le(e,t,r){if(E(t))return k(t,e,r),t;if(t instanceof Uint8Array){if(!e.startsWith("HS"))throw new TypeError(R(t,...D));return g.subtle.importKey("raw",t,{hash:`SHA-${e.substr(-3)}`,name:"HMAC"},!1,[r])}throw new TypeError(R(t,...D,"Uint8Array"))}async function fe(n,a,o){var i;if(!B(n))throw new w("Flattened JWS must be an object");if(void 0===n.protected&&void 0===n.header)throw new w('Flattened JWS must have either of the "protected" or "header" members');if(void 0!==n.protected&&"string"!=typeof n.protected)throw new w("JWS Protected Header incorrect type");if(void 0===n.payload)throw new w("JWS Payload missing");if("string"!=typeof n.signature)throw new w("JWS Signature missing or incorrect type");if(void 0!==n.header&&!B(n.header))throw new w("JWS Unprotected Header incorrect type");let s={};if(n.protected){const e=c(n.protected);try{s=JSON.parse(t.decode(e))}catch(e){throw new w("JWS Protected Header is invalid")}}if(!x(s,n.header))throw new w("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");const d={...s,...n.header};let h=!0;if(oe(w,new Map([["b64",!0]]),null==o?void 0:o.crit,s,d).has("b64")&&(h=s.b64,"boolean"!=typeof h))throw new w('The "b64" (base64url-encode payload) Header Parameter must be a boolean');const{alg:y}=d;if("string"!=typeof y||!y)throw new w('JWS "alg" (Algorithm) Header Parameter missing or invalid');const u=o&&ie("algorithms",o.algorithms);if(u&&!u.has(y))throw new p('"alg" (Algorithm) Header Parameter not allowed');if(h){if("string"!=typeof n.payload)throw new w("JWS Payload must be a string")}else if("string"!=typeof n.payload&&!(n.payload instanceof Uint8Array))throw new w("JWS Payload must be a string or an Uint8Array instance");let l=!1;"function"==typeof a&&(a=await a(s,n),l=!0),re(y,a,"verify");const E=r(e.encode(null!==(i=n.protected)&&void 0!==i?i:""),e.encode("."),"string"==typeof n.payload?e.encode(n.payload):n.payload),m=c(n.signature),A=await(async(e,t,r,n)=>{const a=await le(e,t,"verify");X(e,a);const o=we(e,a.algorithm.namedCurve);try{return await g.subtle.verify(o,a,r,n)}catch(e){return!1}})(y,a,m,E);if(!A)throw new f;let S;S=h?c(n.payload):"string"==typeof n.payload?e.encode(n.payload):n.payload;const b={payload:S};return void 0!==n.protected&&(b.protectedHeader=s),void 0!==n.header&&(b.unprotectedHeader=n.header),l?{...b,key:a}:b}async function ge(e,r,n){if(e instanceof Uint8Array&&(e=t.decode(e)),"string"!=typeof e)throw new w("Compact JWS must be a string or Uint8Array");const{0:a,1:o,2:i,length:s}=e.split(".");if(3!==s)throw new w("Invalid Compact JWS");const c=await fe({payload:o,protected:a,signature:i},r,n),d={payload:c.payload,protectedHeader:c.protectedHeader};return"function"==typeof r?{...d,key:c.key}:d}class Ee{constructor(e){this._flattened=new ue(e)}setContentEncryptionKey(e){return this._flattened.setContentEncryptionKey(e),this}setInitializationVector(e){return this._flattened.setInitializationVector(e),this}setProtectedHeader(e){return this._flattened.setProtectedHeader(e),this}setKeyManagementParameters(e){return this._flattened.setKeyManagementParameters(e),this}async encrypt(e,t){const r=await this._flattened.encrypt(e,t);return[r.protected,r.encrypted_key,r.iv,r.ciphertext,r.tag].join(".")}}class me{constructor(e){if(!(e instanceof Uint8Array))throw new TypeError("payload must be an instance of Uint8Array");this._payload=e}setProtectedHeader(e){if(this._protectedHeader)throw new TypeError("setProtectedHeader can only be called once");return this._protectedHeader=e,this}setUnprotectedHeader(e){if(this._unprotectedHeader)throw new TypeError("setUnprotectedHeader can only be called once");return this._unprotectedHeader=e,this}async sign(n,a){if(!this._protectedHeader&&!this._unprotectedHeader)throw new w("either setProtectedHeader or setUnprotectedHeader must be called before #sign()");if(!x(this._protectedHeader,this._unprotectedHeader))throw new w("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");const o={...this._protectedHeader,...this._unprotectedHeader};let i=!0;if(oe(w,new Map([["b64",!0]]),null==a?void 0:a.crit,this._protectedHeader,o).has("b64")&&(i=this._protectedHeader.b64,"boolean"!=typeof i))throw new w('The "b64" (base64url-encode payload) Header Parameter must be a boolean');const{alg:c}=o;if("string"!=typeof c||!c)throw new w('JWS "alg" (Algorithm) Header Parameter missing or invalid');re(c,n,"sign");let d,p=this._payload;i&&(p=e.encode(s(p))),d=this._protectedHeader?e.encode(s(JSON.stringify(this._protectedHeader))):e.encode("");const h=r(d,e.encode("."),p),y=await(async(e,t,r)=>{const n=await le(e,t,"sign");X(e,n);const a=await g.subtle.sign(we(e,n.algorithm.namedCurve),n,r);return new Uint8Array(a)})(c,n,h),u={signature:s(y),payload:""};return i&&(u.payload=t.decode(p)),this._unprotectedHeader&&(u.header=this._unprotectedHeader),this._protectedHeader&&(u.protected=t.decode(d)),u}}class Ae{constructor(e){this._flattened=new me(e)}setProtectedHeader(e){return this._flattened.setProtectedHeader(e),this}async sign(e,t){const r=await this._flattened.sign(e,t);if(void 0===r.payload)throw new TypeError("use the flattened module for creating JWS with b64: false");return`${r.protected}.${r.payload}.${r.signature}`}}const Se=(e,t)=>{if("string"!=typeof e||!e)throw new l(`${t} missing or invalid`)};const be=async function(e,t="SHA-256"){const r=["SHA-1","SHA-256","SHA-384","SHA-512"];if(!r.includes(t))throw new RangeError(`Valid hash algorith values are any of ${JSON.stringify(r)}`);const n=new TextEncoder,a="string"==typeof e?n.encode(e).buffer:e;let o="";{const e=await crypto.subtle.digest(t,a),r="0123456789abcdef";new Uint8Array(e).forEach((e=>{o+=r[e>>4]+r[15&e]}))}return o},ve=async(e,t,r)=>{const n=await He(e,t);if(await be(r)!==n.exchange.poo_dgst)throw new Error("the hashed proof of origin received does not correspond to the poo_dgst parameter in the proof of origin");if(Date.now()-n.iat>5e3)throw new Error("timestamp error");return!0},He=async(e,t)=>{const{payload:r}=await ge(t,e).catch((e=>{throw new Error(`PoR: ${String(e)}`)}));return JSON.parse((new TextDecoder).decode(r).toString())},Ce=async(e,t,r)=>{const n=await Pe(e,t),a=await be(r);if(n.exchange.cipherblock_dgst!==a)throw new Error("the cipherblock_dgst parameter in the proof of origin does not correspond to hash of the cipherblock received by the provider");if(Date.now()-n.iat>5e3)throw new Error("timestamp error");return!0},Pe=async(e,t)=>{const{payload:r}=await ge(t,e).catch((e=>{throw new Error("PoO "+String(e))}));return JSON.parse((new TextDecoder).decode(r).toString())},Ke=(e,t,r,n,a)=>new Promise(((o,i)=>{ge(r,e).catch((e=>{i(new Error("PoP "+String(e)))})),Pe(t,a).then((e=>{be(JSON.stringify(n)).then((t=>{e.exchange.key_commitment===t?o(!0):i(new Error("hashed key not correspond to poO key_commitment parameter"))})).catch((e=>i(e)))})).catch((e=>i(e)))})),_e=async(e,t)=>{const r=new TextDecoder,n=await te(t,"A256GCM"),{plaintext:a}=await ce(e,n);return r.decode(a)},We=async(e,t,r,n)=>{const a=await _e(t,r);if(await be(a)===n.exchange.block_commitment)return!0;throw new Error("hashed CipherBlock not correspond to block_commitment parameter included in the proof of origin")},ke="ES256",Ue=async(e,t,r,n,a,o,i)=>{const s="string"==typeof t?(new TextEncoder).encode(t):new Uint8Array(t),c=await te(i),d=await new Ee(s).setProtectedHeader({alg:"dir",enc:"A256GCM"}).encrypt(c),p=await be(d),h=await be(s),y=await be(JSON.stringify(i)),u={iss:r,sub:n,iat:Date.now(),exchange:{id:a,orig:r,dest:n,block_id:o,block_desc:"description",hash_alg:"sha256",cipherblock_dgst:p,block_commitment:h,key_commitment:y}};return{cipherblock:d,poO:await Je(e,u)}},Re=async()=>{let t;t=await window.crypto.subtle.generateKey({name:"AES-GCM",length:256},!0,["encrypt","decrypt"]);const r=await pe(t),n=await async function(t,r="sha256"){if(!B(t))throw new TypeError("JWK must be an object");let n;switch(t.kty){case"EC":Se(t.crv,'"crv" (Curve) Parameter'),Se(t.x,'"x" (X Coordinate) Parameter'),Se(t.y,'"y" (Y Coordinate) Parameter'),n={crv:t.crv,kty:t.kty,x:t.x,y:t.y};break;case"OKP":Se(t.crv,'"crv" (Subtype of Key Pair) Parameter'),Se(t.x,'"x" (Public Key) Parameter'),n={crv:t.crv,kty:t.kty,x:t.x};break;case"RSA":Se(t.e,'"e" (Exponent) Parameter'),Se(t.n,'"n" (Modulus) Parameter'),n={e:t.e,kty:t.kty,n:t.n};break;case"oct":Se(t.k,'"k" (Key Value) Parameter'),n={k:t.k,kty:t.kty};break;default:throw new h('"kty" (Key Type) Parameter missing or unsupported')}const a=e.encode(JSON.stringify(n));return s(await F(r,a))}(r);return r.kid=n,r.alg="A256GCM",r},Je=async(e,t)=>{const r=(new TextEncoder).encode(JSON.stringify(t));return await new Ae(r).setProtectedHeader({alg:"ES256"}).sign(e)},De=async(e,t,r,n,a)=>{const o=await be(t),i={iss:r,sub:n,iat:Date.now(),exchange:{poo_dgst:o,hash_alg:"sha256",exchangeId:a}};return await Je(e,i)},Oe=async(e,t,r,n)=>{const a=await Pe(e,t);return{privateStorage:{availability:"privateStorage",permissions:{view:[a.exchange.orig,a.exchange.dest]},type:"dict",id:a.exchange.id,content:{[a.exchange.block_id]:{poO:t,poR:r}}},blockchain:{availability:"blockchain",type:"jwk",content:{[n.kid]:n}}}};export{ke as SIGNING_ALG,Oe as createBlockchainProof,Re as createJwk,Ue as createPoO,De as createPoR,Pe as decodePoo,He as decodePor,_e as decryptCipherblock,be as sha,Je as signProof,We as validateCipherblock,Ce as validatePoO,Ke as validatePoP,ve as validatePoR}; diff --git a/dist/bundles/iife.js b/dist/bundles/iife.js new file mode 100644 index 0000000..182dfda --- /dev/null +++ b/dist/bundles/iife.js @@ -0,0 +1 @@ +var nonRepudiationProofs=function(e){"use strict";const t=new TextEncoder,r=new TextDecoder,a=2**32;function n(...e){const t=e.reduce(((e,{length:t})=>e+t),0),r=new Uint8Array(t);let a=0;return e.forEach((e=>{r.set(e,a),a+=e.length})),r}function o(e,t,r){if(t<0||t>=a)throw new RangeError(`value must be >= 0 and <= 4294967295. Received ${t}`);e.set([t>>>24,t>>>16,t>>>8,255&t],r)}function i(e){const t=Math.floor(e/a),r=e%a,n=new Uint8Array(8);return o(n,t,0),o(n,r,4),n}function s(e){const t=new Uint8Array(4);return o(t,e),t}function c(e){return n(s(e.length),e)}const d=e=>(e=>{let r=e;"string"==typeof r&&(r=t.encode(r));const a=[];for(let e=0;e{let t=e;t instanceof Uint8Array&&(t=r.decode(t)),t=t.replace(/-/g,"+").replace(/_/g,"/").replace(/\s/g,"");try{return(e=>new Uint8Array(atob(e).split("").map((e=>e.charCodeAt(0)))))(t)}catch(e){throw new TypeError("The input to be decoded is not correctly encoded.")}};class h extends Error{constructor(e){var t;super(e),this.code="ERR_JOSE_GENERIC",this.name=this.constructor.name,null===(t=Error.captureStackTrace)||void 0===t||t.call(Error,this,this.constructor)}static get code(){return"ERR_JOSE_GENERIC"}}class y extends h{constructor(){super(...arguments),this.code="ERR_JOSE_ALG_NOT_ALLOWED"}static get code(){return"ERR_JOSE_ALG_NOT_ALLOWED"}}class u extends h{constructor(){super(...arguments),this.code="ERR_JOSE_NOT_SUPPORTED"}static get code(){return"ERR_JOSE_NOT_SUPPORTED"}}class w extends h{constructor(){super(...arguments),this.code="ERR_JWE_DECRYPTION_FAILED",this.message="decryption operation failed"}static get code(){return"ERR_JWE_DECRYPTION_FAILED"}}class l extends h{constructor(){super(...arguments),this.code="ERR_JWE_INVALID"}static get code(){return"ERR_JWE_INVALID"}}class f extends h{constructor(){super(...arguments),this.code="ERR_JWS_INVALID"}static get code(){return"ERR_JWS_INVALID"}}class g extends h{constructor(){super(...arguments),this.code="ERR_JWK_INVALID"}static get code(){return"ERR_JWK_INVALID"}}class E extends h{constructor(){super(...arguments),this.code="ERR_JWS_SIGNATURE_VERIFICATION_FAILED",this.message="signature verification failed"}static get code(){return"ERR_JWS_SIGNATURE_VERIFICATION_FAILED"}}var m=crypto;function A(e){try{return null!=e&&"boolean"==typeof e.extractable&&"string"==typeof e.algorithm.name&&"string"==typeof e.type}catch(e){return!1}}var S=m.getRandomValues.bind(m);function b(e){switch(e){case"A128GCM":case"A128GCMKW":case"A192GCM":case"A192GCMKW":case"A256GCM":case"A256GCMKW":return 96;case"A128CBC-HS256":case"A192CBC-HS384":case"A256CBC-HS512":return 128;default:throw new u(`Unsupported JWE Algorithm: ${e}`)}}var v=e=>S(new Uint8Array(b(e)>>3));const H=(e,t)=>{if(t.length<<3!==b(e))throw new l("Invalid Initialization Vector length")},C=(e,t)=>{if(e.length<<3!==t)throw new l("Invalid Content Encryption Key length")};function P(){return"function"==typeof WebSocketPair}function K(){try{return void 0!==process.versions.node}catch(e){return!1}}function _(e,t="algorithm.name"){return new TypeError(`CryptoKey does not support this operation, its ${t} must be ${e}`)}function W(e,t){return e.name===t}function k(e){return parseInt(e.name.substr(4),10)}function U(e,t){if(t.length&&!t.some((t=>e.usages.includes(t)))){let e="CryptoKey does not support this operation, its usages must include ";if(t.length>2){const r=t.pop();e+=`one of ${t.join(", ")}, or ${r}.`}else 2===t.length?e+=`one of ${t[0]} or ${t[1]}.`:e+=`${t[0]}.`;throw new TypeError(e)}}function R(e,t,...r){switch(t){case"HS256":case"HS384":case"HS512":{if(!W(e.algorithm,"HMAC"))throw _("HMAC");const r=parseInt(t.substr(2),10);if(k(e.algorithm.hash)!==r)throw _(`SHA-${r}`,"algorithm.hash");break}case"RS256":case"RS384":case"RS512":{if(!W(e.algorithm,"RSASSA-PKCS1-v1_5"))throw _("RSASSA-PKCS1-v1_5");const r=parseInt(t.substr(2),10);if(k(e.algorithm.hash)!==r)throw _(`SHA-${r}`,"algorithm.hash");break}case"PS256":case"PS384":case"PS512":{if(!W(e.algorithm,"RSA-PSS"))throw _("RSA-PSS");const r=parseInt(t.substr(2),10);if(k(e.algorithm.hash)!==r)throw _(`SHA-${r}`,"algorithm.hash");break}case K()&&"EdDSA":if("NODE-ED25519"!==e.algorithm.name&&"NODE-ED448"!==e.algorithm.name)throw _("NODE-ED25519 or NODE-ED448");break;case P()&&"EdDSA":if(!W(e.algorithm,"NODE-ED25519"))throw _("NODE-ED25519");break;case"ES256":case"ES384":case"ES512":{if(!W(e.algorithm,"ECDSA"))throw _("ECDSA");const r=function(e){switch(e){case"ES256":return"P-256";case"ES384":return"P-384";case"ES512":return"P-521";default:throw new Error("unreachable")}}(t);if(e.algorithm.namedCurve!==r)throw _(r,"algorithm.namedCurve");break}default:throw new TypeError("CryptoKey does not support this operation")}U(e,r)}function J(e,t,...r){switch(t){case"A128GCM":case"A192GCM":case"A256GCM":{if(!W(e.algorithm,"AES-GCM"))throw _("AES-GCM");const r=parseInt(t.substr(1,3),10);if(e.algorithm.length!==r)throw _(r,"algorithm.length");break}case"A128KW":case"A192KW":case"A256KW":{if(!W(e.algorithm,"AES-KW"))throw _("AES-KW");const r=parseInt(t.substr(1,3),10);if(e.algorithm.length!==r)throw _(r,"algorithm.length");break}case"ECDH-ES":if(!W(e.algorithm,"ECDH"))throw _("ECDH");break;case"PBES2-HS256+A128KW":case"PBES2-HS384+A192KW":case"PBES2-HS512+A256KW":if(!W(e.algorithm,"PBKDF2"))throw _("PBKDF2");break;case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":{if(!W(e.algorithm,"RSA-OAEP"))throw _("RSA-OAEP");const r=parseInt(t.substr(9),10)||1;if(k(e.algorithm.hash)!==r)throw _(`SHA-${r}`,"algorithm.hash");break}default:throw new TypeError("CryptoKey does not support this operation")}U(e,r)}var D=(e,...t)=>{let r="Key must be ";if(t.length>2){const e=t.pop();r+=`one of type ${t.join(", ")}, or ${e}.`}else 2===t.length?r+=`one of type ${t[0]} or ${t[1]}.`:r+=`of type ${t[0]}.`;return null==e?r+=` Received ${e}`:"function"==typeof e&&e.name?r+=` Received function ${e.name}`:"object"==typeof e&&null!=e&&e.constructor&&e.constructor.name&&(r+=` Received an instance of ${e.constructor.name}`),r},O=e=>A(e);const T=["CryptoKey"];async function M(e,t,r,a,o,s){if(!(t instanceof Uint8Array))throw new TypeError(D(t,"Uint8Array"));const c=parseInt(e.substr(1,3),10),d=await m.subtle.importKey("raw",t.subarray(c>>3),"AES-CBC",!1,["decrypt"]),p=await m.subtle.importKey("raw",t.subarray(0,c>>3),{hash:"SHA-"+(c<<1),name:"HMAC"},!1,["sign"]),h=n(s,a,r,i(s.length<<3)),y=new Uint8Array((await m.subtle.sign("HMAC",p,h)).slice(0,c>>3));let u,l;try{u=((e,t)=>{if(!(e instanceof Uint8Array))throw new TypeError("First argument must be a buffer");if(!(t instanceof Uint8Array))throw new TypeError("Second argument must be a buffer");if(e.length!==t.length)throw new TypeError("Input buffers must have the same length");const r=e.length;let a=0,n=-1;for(;++n{if(!(A(t)||t instanceof Uint8Array))throw new TypeError(D(t,...T,"Uint8Array"));switch(H(e,a),e){case"A128CBC-HS256":case"A192CBC-HS384":case"A256CBC-HS512":return t instanceof Uint8Array&&C(t,parseInt(e.substr(-3),10)),M(e,t,r,a,o,i);case"A128GCM":case"A192GCM":case"A256GCM":return t instanceof Uint8Array&&C(t,parseInt(e.substr(1,3),10)),async function(e,t,r,a,o,i){let s;t instanceof Uint8Array?s=await m.subtle.importKey("raw",t,"AES-GCM",!1,["decrypt"]):(J(t,e,"decrypt"),s=t);try{return new Uint8Array(await m.subtle.decrypt({additionalData:i,iv:a,name:"AES-GCM",tagLength:128},s,n(r,o)))}catch(e){throw new w}}(e,t,r,a,o,i);default:throw new u("Unsupported JWE Content Encryption Algorithm")}},x=async()=>{throw new u('JWE "zip" (Compression Algorithm) Header Parameter is not supported by your javascript runtime. You need to use the `inflateRaw` decrypt option to provide Inflate Raw implementation.')},B=async()=>{throw new u('JWE "zip" (Compression Algorithm) Header Parameter is not supported by your javascript runtime. You need to use the `deflateRaw` encrypt option to provide Deflate Raw implementation.')},$=(...e)=>{const t=e.filter(Boolean);if(0===t.length||1===t.length)return!0;let r;for(const e of t){const t=Object.keys(e);if(r&&0!==r.size)for(const e of t){if(r.has(e))return!1;r.add(e)}else r=new Set(t)}return!0};function G(e){if("object"!=typeof(t=e)||null===t||"[object Object]"!==Object.prototype.toString.call(e))return!1;var t;if(null===Object.getPrototypeOf(e))return!0;let r=e;for(;null!==Object.getPrototypeOf(r);)r=Object.getPrototypeOf(r);return Object.getPrototypeOf(e)===r}const N=[{hash:"SHA-256",name:"HMAC"},!0,["sign"]];function j(e,t){if(e.algorithm.length!==parseInt(t.substr(1,3),10))throw new TypeError(`Invalid key size for alg: ${t}`)}function z(e,t,r){if(A(e))return J(e,t,r),e;if(e instanceof Uint8Array)return m.subtle.importKey("raw",e,"AES-KW",!0,[r]);throw new TypeError(D(e,...T,"Uint8Array"))}const L=async(e,t,r)=>{const a=await z(t,e,"wrapKey");j(a,e);const n=await m.subtle.importKey("raw",r,...N);return new Uint8Array(await m.subtle.wrapKey("raw",n,a,"AES-KW"))},F=async(e,t,r)=>{const a=await z(t,e,"unwrapKey");j(a,e);const n=await m.subtle.unwrapKey("raw",r,a,"AES-KW",...N);return new Uint8Array(await m.subtle.exportKey("raw",n))},V=async(e,t)=>{const r=`SHA-${e.substr(-3)}`;return new Uint8Array(await m.subtle.digest(r,t))},Y=async(e,r,a,o,i=new Uint8Array(0),d=new Uint8Array(0))=>{if(!A(e))throw new TypeError(D(e,...T));if(J(e,"ECDH-ES"),!A(r))throw new TypeError(D(r,...T));J(r,"ECDH-ES","deriveBits","deriveKey");const p=n(c(t.encode(a)),c(i),c(d),s(o));if(!r.usages.includes("deriveBits"))throw new TypeError('ECDH-ES private key "usages" must include "deriveBits"');const h=new Uint8Array(await m.subtle.deriveBits({name:"ECDH",public:e},r,Math.ceil(parseInt(r.algorithm.namedCurve.substr(-3),10)/8)<<3));return async function(e,t,r,a){const o=Math.ceil((r>>3)/32);let i;for(let r=1;r<=o;r++){const o=new Uint8Array(4+t.length+a.length);o.set(s(r)),o.set(t,4),o.set(a,4+t.length),i=i?n(i,await e("sha256",o)):await e("sha256",o)}return i=i.slice(0,r>>3),i}(V,h,o,p)},q=e=>{if(!A(e))throw new TypeError(D(e,...T));return["P-256","P-384","P-521"].includes(e.algorithm.namedCurve)};async function X(e,r,a,o){!function(e){if(!(e instanceof Uint8Array)||e.length<8)throw new l("PBES2 Salt Input must be 8 or more octets")}(e);const i=function(e,r){return n(t.encode(e),new Uint8Array([0]),r)}(r,e),s=parseInt(r.substr(13,3),10),c={hash:`SHA-${r.substr(8,3)}`,iterations:a,name:"PBKDF2",salt:i},d={length:s,name:"AES-KW"},p=await function(e,t){if(e instanceof Uint8Array)return m.subtle.importKey("raw",e,"PBKDF2",!1,["deriveBits"]);if(A(e))return J(e,t,"deriveBits","deriveKey"),e;throw new TypeError(D(e,...T,"Uint8Array"))}(o,r);if(p.usages.includes("deriveBits"))return new Uint8Array(await m.subtle.deriveBits(c,p,s));if(p.usages.includes("deriveKey"))return m.subtle.deriveKey(c,p,d,!1,["wrapKey","unwrapKey"]);throw new TypeError('PBKDF2 key "usages" must include "deriveBits" or "deriveKey"')}function Q(e){switch(e){case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":return"RSA-OAEP";default:throw new u(`alg ${e} is not supported either by JOSE or your javascript runtime`)}}var Z=(e,t)=>{if(e.startsWith("RS")||e.startsWith("PS")){const{modulusLength:r}=t.algorithm;if("number"!=typeof r||r<2048)throw new TypeError(`${e} requires key modulusLength to be 2048 bits or larger`)}};function ee(e){switch(e){case"A128GCM":return 128;case"A192GCM":return 192;case"A256GCM":case"A128CBC-HS256":return 256;case"A192CBC-HS384":return 384;case"A256CBC-HS512":return 512;default:throw new u(`Unsupported JWE Algorithm: ${e}`)}}var te=e=>S(new Uint8Array(ee(e)>>3));var re=async e=>{var t,r;const{algorithm:a,keyUsages:n}=function(e){let t,r;switch(e.kty){case"oct":switch(e.alg){case"HS256":case"HS384":case"HS512":t={name:"HMAC",hash:`SHA-${e.alg.substr(-3)}`},r=["sign","verify"];break;case"A128CBC-HS256":case"A192CBC-HS384":case"A256CBC-HS512":throw new u(`${e.alg} keys cannot be imported as CryptoKey instances`);case"A128GCM":case"A192GCM":case"A256GCM":case"A128GCMKW":case"A192GCMKW":case"A256GCMKW":t={name:"AES-GCM"},r=["encrypt","decrypt"];break;case"A128KW":case"A192KW":case"A256KW":t={name:"AES-KW"},r=["wrapKey","unwrapKey"];break;case"PBES2-HS256+A128KW":case"PBES2-HS384+A192KW":case"PBES2-HS512+A256KW":t={name:"PBKDF2"},r=["deriveBits"];break;default:throw new u('Invalid or unsupported JWK "alg" (Algorithm) Parameter value')}break;case"RSA":switch(e.alg){case"PS256":case"PS384":case"PS512":t={name:"RSA-PSS",hash:`SHA-${e.alg.substr(-3)}`},r=e.d?["sign"]:["verify"];break;case"RS256":case"RS384":case"RS512":t={name:"RSASSA-PKCS1-v1_5",hash:`SHA-${e.alg.substr(-3)}`},r=e.d?["sign"]:["verify"];break;case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":t={name:"RSA-OAEP",hash:`SHA-${parseInt(e.alg.substr(-3),10)||1}`},r=e.d?["decrypt","unwrapKey"]:["encrypt","wrapKey"];break;default:throw new u('Invalid or unsupported JWK "alg" (Algorithm) Parameter value')}break;case"EC":switch(e.alg){case"ES256":t={name:"ECDSA",namedCurve:"P-256"},r=e.d?["sign"]:["verify"];break;case"ES384":t={name:"ECDSA",namedCurve:"P-384"},r=e.d?["sign"]:["verify"];break;case"ES512":t={name:"ECDSA",namedCurve:"P-521"},r=e.d?["sign"]:["verify"];break;case"ECDH-ES":case"ECDH-ES+A128KW":case"ECDH-ES+A192KW":case"ECDH-ES+A256KW":t={name:"ECDH",namedCurve:e.crv},r=e.d?["deriveBits"]:[];break;default:throw new u('Invalid or unsupported JWK "alg" (Algorithm) Parameter value')}break;case(P()||K())&&"OKP":if("EdDSA"!==e.alg)throw new u('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');switch(e.crv){case"Ed25519":t={name:"NODE-ED25519",namedCurve:"NODE-ED25519"},r=e.d?["sign"]:["verify"];break;case K()&&"Ed448":t={name:"NODE-ED448",namedCurve:"NODE-ED448"},r=e.d?["sign"]:["verify"];break;default:throw new u('Invalid or unsupported JWK "crv" (Subtype of Key Pair) Parameter value')}break;default:throw new u('Invalid or unsupported JWK "kty" (Key Type) Parameter value')}return{algorithm:t,keyUsages:r}}(e),o=[a,null!==(t=e.ext)&&void 0!==t&&t,null!==(r=e.key_ops)&&void 0!==r?r:n];if("PBKDF2"===a.name)return m.subtle.importKey("raw",p(e.k),...o);const i={...e};return delete i.alg,m.subtle.importKey("jwk",i,...o)};async function ae(e,t,r){if(!G(e))throw new TypeError("JWK must be an object");if(t||(t=e.alg),"string"!=typeof t||!t)throw new TypeError('"alg" argument is required when "jwk.alg" is not present');switch(e.kty){case"oct":if("string"!=typeof e.k||!e.k)throw new TypeError('missing "k" (Key Value) Parameter value');return null!=r||(r=!0!==e.ext),r?re({...e,alg:t,ext:!1}):p(e.k);case"RSA":if(void 0!==e.oth)throw new u('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');case"EC":case"OKP":return re({...e,alg:t});default:throw new u('Unsupported "kty" (Key Type) Parameter value')}}const ne=(e,t,r)=>{e.startsWith("HS")||"dir"===e||e.startsWith("PBES2")||/^A\d{3}(?:GCM)?KW$/.test(e)?(e=>{if(!(e instanceof Uint8Array)){if(!O(e))throw new TypeError(D(e,...T,"Uint8Array"));if("secret"!==e.type)throw new TypeError(`${T.join(" or ")} instances for symmetric algorithms must be of type "secret"`)}})(t):((e,t)=>{if(!O(e))throw new TypeError(D(e,...T));if("secret"===e.type)throw new TypeError(`${T.join(" or ")} instances for asymmetric algorithms must not be of type "secret"`);if("sign"===t&&"public"===e.type)throw new TypeError(`${T.join(" or ")} instances for asymmetric algorithm signing must be of type "private"`);if("decrypt"===t&&"public"===e.type)throw new TypeError(`${T.join(" or ")} instances for asymmetric algorithm decryption must be of type "private"`);if(e.algorithm&&"verify"===t&&"private"===e.type)throw new TypeError(`${T.join(" or ")} instances for asymmetric algorithm verifying must be of type "public"`);if(e.algorithm&&"encrypt"===t&&"private"===e.type)throw new TypeError(`${T.join(" or ")} instances for asymmetric algorithm encryption must be of type "public"`)})(t,r)};const oe=async(e,t,r,a,o)=>{if(!(A(r)||r instanceof Uint8Array))throw new TypeError(D(r,...T,"Uint8Array"));switch(H(e,a),e){case"A128CBC-HS256":case"A192CBC-HS384":case"A256CBC-HS512":return r instanceof Uint8Array&&C(r,parseInt(e.substr(-3),10)),async function(e,t,r,a,o){if(!(r instanceof Uint8Array))throw new TypeError(D(r,"Uint8Array"));const s=parseInt(e.substr(1,3),10),c=await m.subtle.importKey("raw",r.subarray(s>>3),"AES-CBC",!1,["encrypt"]),d=await m.subtle.importKey("raw",r.subarray(0,s>>3),{hash:"SHA-"+(s<<1),name:"HMAC"},!1,["sign"]),p=new Uint8Array(await m.subtle.encrypt({iv:a,name:"AES-CBC"},c,t)),h=n(o,a,p,i(o.length<<3));return{ciphertext:p,tag:new Uint8Array((await m.subtle.sign("HMAC",d,h)).slice(0,s>>3))}}(e,t,r,a,o);case"A128GCM":case"A192GCM":case"A256GCM":return r instanceof Uint8Array&&C(r,parseInt(e.substr(1,3),10)),async function(e,t,r,a,n){let o;r instanceof Uint8Array?o=await m.subtle.importKey("raw",r,"AES-GCM",!1,["encrypt"]):(J(r,e,"encrypt"),o=r);const i=new Uint8Array(await m.subtle.encrypt({additionalData:n,iv:a,name:"AES-GCM",tagLength:128},o,t)),s=i.slice(-16);return{ciphertext:i.slice(0,-16),tag:s}}(e,t,r,a,o);default:throw new u("Unsupported JWE Content Encryption Algorithm")}};async function ie(e,t,r,a){switch(ne(e,t,"decrypt"),e){case"dir":if(void 0!==r)throw new l("Encountered unexpected JWE Encrypted Key");return t;case"ECDH-ES":if(void 0!==r)throw new l("Encountered unexpected JWE Encrypted Key");case"ECDH-ES+A128KW":case"ECDH-ES+A192KW":case"ECDH-ES+A256KW":{if(!G(a.epk))throw new l('JOSE Header "epk" (Ephemeral Public Key) missing or invalid');if(!q(t))throw new u("ECDH-ES with the provided key is not allowed or not supported by your javascript runtime");const n=await ae(a.epk,e);let o,i;if(void 0!==a.apu){if("string"!=typeof a.apu)throw new l('JOSE Header "apu" (Agreement PartyUInfo) invalid');o=p(a.apu)}if(void 0!==a.apv){if("string"!=typeof a.apv)throw new l('JOSE Header "apv" (Agreement PartyVInfo) invalid');i=p(a.apv)}const s=await Y(n,t,"ECDH-ES"===e?a.enc:e,"ECDH-ES"===e?ee(a.enc):parseInt(e.substr(-5,3),10),o,i);if("ECDH-ES"===e)return s;if(void 0===r)throw new l("JWE Encrypted Key missing");return F(e.substr(-6),s,r)}case"RSA1_5":case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":if(void 0===r)throw new l("JWE Encrypted Key missing");return(async(e,t,r)=>{if(!A(t))throw new TypeError(D(t,...T));if(J(t,e,"decrypt","unwrapKey"),Z(e,t),t.usages.includes("decrypt"))return new Uint8Array(await m.subtle.decrypt(Q(e),t,r));if(t.usages.includes("unwrapKey")){const a=await m.subtle.unwrapKey("raw",r,t,Q(e),...N);return new Uint8Array(await m.subtle.exportKey("raw",a))}throw new TypeError('RSA-OAEP key "usages" must include "decrypt" or "unwrapKey" for this operation')})(e,t,r);case"PBES2-HS256+A128KW":case"PBES2-HS384+A192KW":case"PBES2-HS512+A256KW":if(void 0===r)throw new l("JWE Encrypted Key missing");if("number"!=typeof a.p2c)throw new l('JOSE Header "p2c" (PBES2 Count) missing or invalid');if("string"!=typeof a.p2s)throw new l('JOSE Header "p2s" (PBES2 Salt) missing or invalid');return(async(e,t,r,a,n)=>{const o=await X(n,e,a,t);return F(e.substr(-6),o,r)})(e,t,r,a.p2c,p(a.p2s));case"A128KW":case"A192KW":case"A256KW":if(void 0===r)throw new l("JWE Encrypted Key missing");return F(e,t,r);case"A128GCMKW":case"A192GCMKW":case"A256GCMKW":if(void 0===r)throw new l("JWE Encrypted Key missing");if("string"!=typeof a.iv)throw new l('JOSE Header "iv" (Initialization Vector) missing or invalid');if("string"!=typeof a.tag)throw new l('JOSE Header "tag" (Authentication Tag) missing or invalid');return async function(e,t,r,a,n){const o=e.substr(0,7);return I(o,t,r,a,n,new Uint8Array(0))}(e,t,r,p(a.iv),p(a.tag));default:throw new u('Invalid or unsupported "alg" (JWE Algorithm) header value')}}function se(e,t,r,a,n){if(void 0!==n.crit&&void 0===a.crit)throw new e('"crit" (Critical) Header Parameter MUST be integrity protected');if(!a||void 0===a.crit)return new Set;if(!Array.isArray(a.crit)||0===a.crit.length||a.crit.some((e=>"string"!=typeof e||0===e.length)))throw new e('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');let o;o=void 0!==r?new Map([...Object.entries(r),...t.entries()]):t;for(const t of a.crit){if(!o.has(t))throw new u(`Extension Header Parameter "${t}" is not recognized`);if(void 0===n[t])throw new e(`Extension Header Parameter "${t}" is missing`);if(o.get(t)&&void 0===a[t])throw new e(`Extension Header Parameter "${t}" MUST be integrity protected`)}return new Set(a.crit)}const ce=(e,t)=>{if(void 0!==t&&(!Array.isArray(t)||t.some((e=>"string"!=typeof e))))throw new TypeError(`"${e}" option must be an array of strings`);if(t)return new Set(t)};async function de(e,a,o){var i;if(!G(e))throw new l("Flattened JWE must be an object");if(void 0===e.protected&&void 0===e.header&&void 0===e.unprotected)throw new l("JOSE Header missing");if("string"!=typeof e.iv)throw new l("JWE Initialization Vector missing or incorrect type");if("string"!=typeof e.ciphertext)throw new l("JWE Ciphertext missing or incorrect type");if("string"!=typeof e.tag)throw new l("JWE Authentication Tag missing or incorrect type");if(void 0!==e.protected&&"string"!=typeof e.protected)throw new l("JWE Protected Header incorrect type");if(void 0!==e.encrypted_key&&"string"!=typeof e.encrypted_key)throw new l("JWE Encrypted Key incorrect type");if(void 0!==e.aad&&"string"!=typeof e.aad)throw new l("JWE AAD incorrect type");if(void 0!==e.header&&!G(e.header))throw new l("JWE Shared Unprotected Header incorrect type");if(void 0!==e.unprotected&&!G(e.unprotected))throw new l("JWE Per-Recipient Unprotected Header incorrect type");let s;if(e.protected){const t=p(e.protected);try{s=JSON.parse(r.decode(t))}catch(e){throw new l("JWE Protected Header is invalid")}}if(!$(s,e.header,e.unprotected))throw new l("JWE Protected, JWE Unprotected Header, and JWE Per-Recipient Unprotected Header Parameter names must be disjoint");const c={...s,...e.header,...e.unprotected};if(se(l,new Map,null==o?void 0:o.crit,s,c),void 0!==c.zip){if(!s||!s.zip)throw new l('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');if("DEF"!==c.zip)throw new u('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value')}const{alg:d,enc:h}=c;if("string"!=typeof d||!d)throw new l("missing JWE Algorithm (alg) in JWE Header");if("string"!=typeof h||!h)throw new l("missing JWE Encryption Algorithm (enc) in JWE Header");const w=o&&ce("keyManagementAlgorithms",o.keyManagementAlgorithms),f=o&&ce("contentEncryptionAlgorithms",o.contentEncryptionAlgorithms);if(w&&!w.has(d))throw new y('"alg" (Algorithm) Header Parameter not allowed');if(f&&!f.has(h))throw new y('"enc" (Encryption Algorithm) Header Parameter not allowed');let g;void 0!==e.encrypted_key&&(g=p(e.encrypted_key));let E,m=!1;"function"==typeof a&&(a=await a(s,e),m=!0);try{E=await ie(d,a,g,c)}catch(e){if(e instanceof TypeError)throw e;E=te(h)}const A=p(e.iv),S=p(e.tag),b=t.encode(null!==(i=e.protected)&&void 0!==i?i:"");let v;v=void 0!==e.aad?n(b,t.encode("."),t.encode(e.aad)):b;let H=await I(h,E,p(e.ciphertext),A,S,v);"DEF"===c.zip&&(H=await((null==o?void 0:o.inflateRaw)||x)(H));const C={plaintext:H};return void 0!==e.protected&&(C.protectedHeader=s),void 0!==e.aad&&(C.additionalAuthenticatedData=p(e.aad)),void 0!==e.unprotected&&(C.sharedUnprotectedHeader=e.unprotected),void 0!==e.header&&(C.unprotectedHeader=e.header),m?{...C,key:a}:C}async function pe(e,t,a){if(e instanceof Uint8Array&&(e=r.decode(e)),"string"!=typeof e)throw new l("Compact JWE must be a string or Uint8Array");const{0:n,1:o,2:i,3:s,4:c,length:d}=e.split(".");if(5!==d)throw new l("Invalid Compact JWE");const p=await de({ciphertext:s||void 0,iv:i||void 0,protected:n||void 0,tag:c||void 0,encrypted_key:o||void 0},t,a),h={plaintext:p.plaintext,protectedHeader:p.protectedHeader};return"function"==typeof t?{...h,key:p.key}:h}var he=async e=>{if(e instanceof Uint8Array)return{kty:"oct",k:d(e)};if(!A(e))throw new TypeError(D(e,...T,"Uint8Array"));if(!e.extractable)throw new TypeError("non-extractable CryptoKey cannot be exported as a JWK");const{ext:t,key_ops:r,alg:a,use:n,...o}=await m.subtle.exportKey("jwk",e);return o};async function ye(e){return he(e)}async function ue(e,t,r,a,n={}){let o,i,s;switch(ne(e,r,"encrypt"),e){case"dir":s=r;break;case"ECDH-ES":case"ECDH-ES+A128KW":case"ECDH-ES+A192KW":case"ECDH-ES+A256KW":{if(!q(r))throw new u("ECDH-ES with the provided key is not allowed or not supported by your javascript runtime");const{apu:c,apv:p}=n;let{epk:h}=n;h||(h=await(async e=>{if(!A(e))throw new TypeError(D(e,...T));return(await m.subtle.generateKey({name:"ECDH",namedCurve:e.algorithm.namedCurve},!0,["deriveBits"])).privateKey})(r));const{x:y,y:w,crv:l,kty:f}=await ye(h),g=await Y(r,h,"ECDH-ES"===e?t:e,"ECDH-ES"===e?ee(t):parseInt(e.substr(-5,3),10),c,p);if(i={epk:{x:y,y:w,crv:l,kty:f}},c&&(i.apu=d(c)),p&&(i.apv=d(p)),"ECDH-ES"===e){s=g;break}s=a||te(t);const E=e.substr(-6);o=await L(E,g,s);break}case"RSA1_5":case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":s=a||te(t),o=await(async(e,t,r)=>{if(!A(t))throw new TypeError(D(t,...T));if(J(t,e,"encrypt","wrapKey"),Z(e,t),t.usages.includes("encrypt"))return new Uint8Array(await m.subtle.encrypt(Q(e),t,r));if(t.usages.includes("wrapKey")){const a=await m.subtle.importKey("raw",r,...N);return new Uint8Array(await m.subtle.wrapKey("raw",a,t,Q(e)))}throw new TypeError('RSA-OAEP key "usages" must include "encrypt" or "wrapKey" for this operation')})(e,r,s);break;case"PBES2-HS256+A128KW":case"PBES2-HS384+A192KW":case"PBES2-HS512+A256KW":{s=a||te(t);const{p2c:c,p2s:p}=n;({encryptedKey:o,...i}=await(async(e,t,r,a=Math.floor(2049*Math.random())+2048,n=S(new Uint8Array(16)))=>{const o=await X(n,e,a,t);return{encryptedKey:await L(e.substr(-6),o,r),p2c:a,p2s:d(n)}})(e,r,s,c,p));break}case"A128KW":case"A192KW":case"A256KW":s=a||te(t),o=await L(e,r,s);break;case"A128GCMKW":case"A192GCMKW":case"A256GCMKW":{s=a||te(t);const{iv:c}=n;({encryptedKey:o,...i}=await async function(e,t,r,a){const n=e.substr(0,7);a||(a=v(n));const{ciphertext:o,tag:i}=await oe(n,r,t,a,new Uint8Array(0));return{encryptedKey:o,iv:d(a),tag:d(i)}}(e,r,s,c));break}default:throw new u('Invalid or unsupported "alg" (JWE Algorithm) header value')}return{cek:s,encryptedKey:o,parameters:i}}const we=Symbol();class le{constructor(e){if(!(e instanceof Uint8Array))throw new TypeError("plaintext must be an instance of Uint8Array");this._plaintext=e}setKeyManagementParameters(e){if(this._keyManagementParameters)throw new TypeError("setKeyManagementParameters can only be called once");return this._keyManagementParameters=e,this}setProtectedHeader(e){if(this._protectedHeader)throw new TypeError("setProtectedHeader can only be called once");return this._protectedHeader=e,this}setSharedUnprotectedHeader(e){if(this._sharedUnprotectedHeader)throw new TypeError("setSharedUnprotectedHeader can only be called once");return this._sharedUnprotectedHeader=e,this}setUnprotectedHeader(e){if(this._unprotectedHeader)throw new TypeError("setUnprotectedHeader can only be called once");return this._unprotectedHeader=e,this}setAdditionalAuthenticatedData(e){return this._aad=e,this}setContentEncryptionKey(e){if(this._cek)throw new TypeError("setContentEncryptionKey can only be called once");return this._cek=e,this}setInitializationVector(e){if(this._iv)throw new TypeError("setInitializationVector can only be called once");return this._iv=e,this}async encrypt(e,a){if(!this._protectedHeader&&!this._unprotectedHeader&&!this._sharedUnprotectedHeader)throw new l("either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()");if(!$(this._protectedHeader,this._unprotectedHeader,this._sharedUnprotectedHeader))throw new l("JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint");const o={...this._protectedHeader,...this._unprotectedHeader,...this._sharedUnprotectedHeader};if(se(l,new Map,null==a?void 0:a.crit,this._protectedHeader,o),void 0!==o.zip){if(!this._protectedHeader||!this._protectedHeader.zip)throw new l('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');if("DEF"!==o.zip)throw new u('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value')}const{alg:i,enc:s}=o;if("string"!=typeof i||!i)throw new l('JWE "alg" (Algorithm) Header Parameter missing or invalid');if("string"!=typeof s||!s)throw new l('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');let c,p,h,y,w,f,g;if("dir"===i){if(this._cek)throw new TypeError("setContentEncryptionKey cannot be called when using Direct Encryption")}else if("ECDH-ES"===i&&this._cek)throw new TypeError("setContentEncryptionKey cannot be called when using Direct Key Agreement");{let t;({cek:p,encryptedKey:c,parameters:t}=await ue(i,s,e,this._cek,this._keyManagementParameters)),t&&(a&&we in a?this._unprotectedHeader?this._unprotectedHeader={...this._unprotectedHeader,...t}:this.setUnprotectedHeader(t):this._protectedHeader?this._protectedHeader={...this._protectedHeader,...t}:this.setProtectedHeader(t))}if(this._iv||(this._iv=v(s)),y=this._protectedHeader?t.encode(d(JSON.stringify(this._protectedHeader))):t.encode(""),this._aad?(w=d(this._aad),h=n(y,t.encode("."),t.encode(w))):h=y,"DEF"===o.zip){const e=await((null==a?void 0:a.deflateRaw)||B)(this._plaintext);({ciphertext:f,tag:g}=await oe(s,e,p,this._iv,h))}else({ciphertext:f,tag:g}=await oe(s,this._plaintext,p,this._iv,h));const E={ciphertext:d(f),iv:d(this._iv),tag:d(g)};return c&&(E.encrypted_key=d(c)),w&&(E.aad=w),this._protectedHeader&&(E.protected=r.decode(y)),this._sharedUnprotectedHeader&&(E.unprotected=this._sharedUnprotectedHeader),this._unprotectedHeader&&(E.header=this._unprotectedHeader),E}}function fe(e,t){const r=parseInt(e.substr(-3),10);switch(e){case"HS256":case"HS384":case"HS512":return{hash:`SHA-${r}`,name:"HMAC"};case"PS256":case"PS384":case"PS512":return{hash:`SHA-${r}`,name:"RSA-PSS",saltLength:r>>3};case"RS256":case"RS384":case"RS512":return{hash:`SHA-${r}`,name:"RSASSA-PKCS1-v1_5"};case"ES256":case"ES384":case"ES512":return{hash:`SHA-${r}`,name:"ECDSA",namedCurve:t};case(P()||K())&&"EdDSA":return{name:t,namedCurve:t};default:throw new u(`alg ${e} is not supported either by JOSE or your javascript runtime`)}}function ge(e,t,r){if(A(t))return R(t,e,r),t;if(t instanceof Uint8Array){if(!e.startsWith("HS"))throw new TypeError(D(t,...T));return m.subtle.importKey("raw",t,{hash:`SHA-${e.substr(-3)}`,name:"HMAC"},!1,[r])}throw new TypeError(D(t,...T,"Uint8Array"))}async function Ee(e,a,o){var i;if(!G(e))throw new f("Flattened JWS must be an object");if(void 0===e.protected&&void 0===e.header)throw new f('Flattened JWS must have either of the "protected" or "header" members');if(void 0!==e.protected&&"string"!=typeof e.protected)throw new f("JWS Protected Header incorrect type");if(void 0===e.payload)throw new f("JWS Payload missing");if("string"!=typeof e.signature)throw new f("JWS Signature missing or incorrect type");if(void 0!==e.header&&!G(e.header))throw new f("JWS Unprotected Header incorrect type");let s={};if(e.protected){const t=p(e.protected);try{s=JSON.parse(r.decode(t))}catch(e){throw new f("JWS Protected Header is invalid")}}if(!$(s,e.header))throw new f("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");const c={...s,...e.header};let d=!0;if(se(f,new Map([["b64",!0]]),null==o?void 0:o.crit,s,c).has("b64")&&(d=s.b64,"boolean"!=typeof d))throw new f('The "b64" (base64url-encode payload) Header Parameter must be a boolean');const{alg:h}=c;if("string"!=typeof h||!h)throw new f('JWS "alg" (Algorithm) Header Parameter missing or invalid');const u=o&&ce("algorithms",o.algorithms);if(u&&!u.has(h))throw new y('"alg" (Algorithm) Header Parameter not allowed');if(d){if("string"!=typeof e.payload)throw new f("JWS Payload must be a string")}else if("string"!=typeof e.payload&&!(e.payload instanceof Uint8Array))throw new f("JWS Payload must be a string or an Uint8Array instance");let w=!1;"function"==typeof a&&(a=await a(s,e),w=!0),ne(h,a,"verify");const l=n(t.encode(null!==(i=e.protected)&&void 0!==i?i:""),t.encode("."),"string"==typeof e.payload?t.encode(e.payload):e.payload),g=p(e.signature),A=await(async(e,t,r,a)=>{const n=await ge(e,t,"verify");Z(e,n);const o=fe(e,n.algorithm.namedCurve);try{return await m.subtle.verify(o,n,r,a)}catch(e){return!1}})(h,a,g,l);if(!A)throw new E;let S;S=d?p(e.payload):"string"==typeof e.payload?t.encode(e.payload):e.payload;const b={payload:S};return void 0!==e.protected&&(b.protectedHeader=s),void 0!==e.header&&(b.unprotectedHeader=e.header),w?{...b,key:a}:b}async function me(e,t,a){if(e instanceof Uint8Array&&(e=r.decode(e)),"string"!=typeof e)throw new f("Compact JWS must be a string or Uint8Array");const{0:n,1:o,2:i,length:s}=e.split(".");if(3!==s)throw new f("Invalid Compact JWS");const c=await Ee({payload:o,protected:n,signature:i},t,a),d={payload:c.payload,protectedHeader:c.protectedHeader};return"function"==typeof t?{...d,key:c.key}:d}class Ae{constructor(e){this._flattened=new le(e)}setContentEncryptionKey(e){return this._flattened.setContentEncryptionKey(e),this}setInitializationVector(e){return this._flattened.setInitializationVector(e),this}setProtectedHeader(e){return this._flattened.setProtectedHeader(e),this}setKeyManagementParameters(e){return this._flattened.setKeyManagementParameters(e),this}async encrypt(e,t){const r=await this._flattened.encrypt(e,t);return[r.protected,r.encrypted_key,r.iv,r.ciphertext,r.tag].join(".")}}class Se{constructor(e){if(!(e instanceof Uint8Array))throw new TypeError("payload must be an instance of Uint8Array");this._payload=e}setProtectedHeader(e){if(this._protectedHeader)throw new TypeError("setProtectedHeader can only be called once");return this._protectedHeader=e,this}setUnprotectedHeader(e){if(this._unprotectedHeader)throw new TypeError("setUnprotectedHeader can only be called once");return this._unprotectedHeader=e,this}async sign(e,a){if(!this._protectedHeader&&!this._unprotectedHeader)throw new f("either setProtectedHeader or setUnprotectedHeader must be called before #sign()");if(!$(this._protectedHeader,this._unprotectedHeader))throw new f("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");const o={...this._protectedHeader,...this._unprotectedHeader};let i=!0;if(se(f,new Map([["b64",!0]]),null==a?void 0:a.crit,this._protectedHeader,o).has("b64")&&(i=this._protectedHeader.b64,"boolean"!=typeof i))throw new f('The "b64" (base64url-encode payload) Header Parameter must be a boolean');const{alg:s}=o;if("string"!=typeof s||!s)throw new f('JWS "alg" (Algorithm) Header Parameter missing or invalid');ne(s,e,"sign");let c,p=this._payload;i&&(p=t.encode(d(p))),c=this._protectedHeader?t.encode(d(JSON.stringify(this._protectedHeader))):t.encode("");const h=n(c,t.encode("."),p),y=await(async(e,t,r)=>{const a=await ge(e,t,"sign");Z(e,a);const n=await m.subtle.sign(fe(e,a.algorithm.namedCurve),a,r);return new Uint8Array(n)})(s,e,h),u={signature:d(y),payload:""};return i&&(u.payload=r.decode(p)),this._unprotectedHeader&&(u.header=this._unprotectedHeader),this._protectedHeader&&(u.protected=r.decode(c)),u}}class be{constructor(e){this._flattened=new Se(e)}setProtectedHeader(e){return this._flattened.setProtectedHeader(e),this}async sign(e,t){const r=await this._flattened.sign(e,t);if(void 0===r.payload)throw new TypeError("use the flattened module for creating JWS with b64: false");return`${r.protected}.${r.payload}.${r.signature}`}}const ve=(e,t)=>{if("string"!=typeof e||!e)throw new g(`${t} missing or invalid`)};const He=async function(e,t="SHA-256"){const r=["SHA-1","SHA-256","SHA-384","SHA-512"];if(!r.includes(t))throw new RangeError(`Valid hash algorith values are any of ${JSON.stringify(r)}`);const a=new TextEncoder,n="string"==typeof e?a.encode(e).buffer:e;let o="";{const e=await crypto.subtle.digest(t,n),r="0123456789abcdef";new Uint8Array(e).forEach((e=>{o+=r[e>>4]+r[15&e]}))}return o},Ce=async(e,t)=>{const{payload:r}=await me(t,e).catch((e=>{throw new Error(`PoR: ${String(e)}`)}));return JSON.parse((new TextDecoder).decode(r).toString())},Pe=async(e,t)=>{const{payload:r}=await me(t,e).catch((e=>{throw new Error("PoO "+String(e))}));return JSON.parse((new TextDecoder).decode(r).toString())},Ke=async(e,t)=>{const r=new TextDecoder,a=await ae(t,"A256GCM"),{plaintext:n}=await pe(e,a);return r.decode(n)},_e="ES256",We=async(e,t)=>{const r=(new TextEncoder).encode(JSON.stringify(t));return await new be(r).setProtectedHeader({alg:_e}).sign(e)};return e.SIGNING_ALG=_e,e.createBlockchainProof=async(e,t,r,a)=>{const n=await Pe(e,t);return{privateStorage:{availability:"privateStorage",permissions:{view:[n.exchange.orig,n.exchange.dest]},type:"dict",id:n.exchange.id,content:{[n.exchange.block_id]:{poO:t,poR:r}}},blockchain:{availability:"blockchain",type:"jwk",content:{[a.kid]:a}}}},e.createJwk=async()=>{let e;e=await window.crypto.subtle.generateKey({name:"AES-GCM",length:256},!0,["encrypt","decrypt"]);const r=await ye(e),a=await async function(e,r="sha256"){if(!G(e))throw new TypeError("JWK must be an object");let a;switch(e.kty){case"EC":ve(e.crv,'"crv" (Curve) Parameter'),ve(e.x,'"x" (X Coordinate) Parameter'),ve(e.y,'"y" (Y Coordinate) Parameter'),a={crv:e.crv,kty:e.kty,x:e.x,y:e.y};break;case"OKP":ve(e.crv,'"crv" (Subtype of Key Pair) Parameter'),ve(e.x,'"x" (Public Key) Parameter'),a={crv:e.crv,kty:e.kty,x:e.x};break;case"RSA":ve(e.e,'"e" (Exponent) Parameter'),ve(e.n,'"n" (Modulus) Parameter'),a={e:e.e,kty:e.kty,n:e.n};break;case"oct":ve(e.k,'"k" (Key Value) Parameter'),a={k:e.k,kty:e.kty};break;default:throw new u('"kty" (Key Type) Parameter missing or unsupported')}const n=t.encode(JSON.stringify(a));return d(await V(r,n))}(r);return r.kid=a,r.alg="A256GCM",r},e.createPoO=async(e,t,r,a,n,o,i)=>{const s="string"==typeof t?(new TextEncoder).encode(t):new Uint8Array(t),c=await ae(i),d=await new Ae(s).setProtectedHeader({alg:"dir",enc:"A256GCM"}).encrypt(c),p=await He(d),h=await He(s),y=await He(JSON.stringify(i)),u={iss:r,sub:a,iat:Date.now(),exchange:{id:n,orig:r,dest:a,block_id:o,block_desc:"description",hash_alg:"sha256",cipherblock_dgst:p,block_commitment:h,key_commitment:y}};return{cipherblock:d,poO:await We(e,u)}},e.createPoR=async(e,t,r,a,n)=>{const o=await He(t),i={iss:r,sub:a,iat:Date.now(),exchange:{poo_dgst:o,hash_alg:"sha256",exchangeId:n}};return await We(e,i)},e.decodePoo=Pe,e.decodePor=Ce,e.decryptCipherblock=Ke,e.sha=He,e.signProof=We,e.validateCipherblock=async(e,t,r,a)=>{const n=await Ke(t,r);if(await He(n)===a.exchange.block_commitment)return!0;throw new Error("hashed CipherBlock not correspond to block_commitment parameter included in the proof of origin")},e.validatePoO=async(e,t,r)=>{const a=await Pe(e,t),n=await He(r);if(a.exchange.cipherblock_dgst!==n)throw new Error("the cipherblock_dgst parameter in the proof of origin does not correspond to hash of the cipherblock received by the provider");if(Date.now()-a.iat>5e3)throw new Error("timestamp error");return!0},e.validatePoP=(e,t,r,a,n)=>new Promise(((o,i)=>{me(r,e).catch((e=>{i(new Error("PoP "+String(e)))})),Pe(t,n).then((e=>{He(JSON.stringify(a)).then((t=>{e.exchange.key_commitment===t?o(!0):i(new Error("hashed key not correspond to poO key_commitment parameter"))})).catch((e=>i(e)))})).catch((e=>i(e)))})),e.validatePoR=async(e,t,r)=>{const a=await Ce(e,t);if(await He(r)!==a.exchange.poo_dgst)throw new Error("the hashed proof of origin received does not correspond to the poo_dgst parameter in the proof of origin");if(Date.now()-a.iat>5e3)throw new Error("timestamp error");return!0},Object.defineProperty(e,"__esModule",{value:!0}),e}({}); diff --git a/dist/bundles/umd.js b/dist/bundles/umd.js new file mode 100644 index 0000000..c368b0a --- /dev/null +++ b/dist/bundles/umd.js @@ -0,0 +1 @@ +!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).nonRepudiationProofs={})}(this,(function(e){"use strict";const t=new TextEncoder,r=new TextDecoder,n=2**32;function a(...e){const t=e.reduce(((e,{length:t})=>e+t),0),r=new Uint8Array(t);let n=0;return e.forEach((e=>{r.set(e,n),n+=e.length})),r}function o(e,t,r){if(t<0||t>=n)throw new RangeError(`value must be >= 0 and <= 4294967295. Received ${t}`);e.set([t>>>24,t>>>16,t>>>8,255&t],r)}function i(e){const t=Math.floor(e/n),r=e%n,a=new Uint8Array(8);return o(a,t,0),o(a,r,4),a}function s(e){const t=new Uint8Array(4);return o(t,e),t}function c(e){return a(s(e.length),e)}const d=e=>(e=>{let r=e;"string"==typeof r&&(r=t.encode(r));const n=[];for(let e=0;e{let t=e;t instanceof Uint8Array&&(t=r.decode(t)),t=t.replace(/-/g,"+").replace(/_/g,"/").replace(/\s/g,"");try{return(e=>new Uint8Array(atob(e).split("").map((e=>e.charCodeAt(0)))))(t)}catch(e){throw new TypeError("The input to be decoded is not correctly encoded.")}};class h extends Error{constructor(e){var t;super(e),this.code="ERR_JOSE_GENERIC",this.name=this.constructor.name,null===(t=Error.captureStackTrace)||void 0===t||t.call(Error,this,this.constructor)}static get code(){return"ERR_JOSE_GENERIC"}}class y extends h{constructor(){super(...arguments),this.code="ERR_JOSE_ALG_NOT_ALLOWED"}static get code(){return"ERR_JOSE_ALG_NOT_ALLOWED"}}class u extends h{constructor(){super(...arguments),this.code="ERR_JOSE_NOT_SUPPORTED"}static get code(){return"ERR_JOSE_NOT_SUPPORTED"}}class w extends h{constructor(){super(...arguments),this.code="ERR_JWE_DECRYPTION_FAILED",this.message="decryption operation failed"}static get code(){return"ERR_JWE_DECRYPTION_FAILED"}}class l extends h{constructor(){super(...arguments),this.code="ERR_JWE_INVALID"}static get code(){return"ERR_JWE_INVALID"}}class f extends h{constructor(){super(...arguments),this.code="ERR_JWS_INVALID"}static get code(){return"ERR_JWS_INVALID"}}class g extends h{constructor(){super(...arguments),this.code="ERR_JWK_INVALID"}static get code(){return"ERR_JWK_INVALID"}}class E extends h{constructor(){super(...arguments),this.code="ERR_JWS_SIGNATURE_VERIFICATION_FAILED",this.message="signature verification failed"}static get code(){return"ERR_JWS_SIGNATURE_VERIFICATION_FAILED"}}var m=crypto;function A(e){try{return null!=e&&"boolean"==typeof e.extractable&&"string"==typeof e.algorithm.name&&"string"==typeof e.type}catch(e){return!1}}var S=m.getRandomValues.bind(m);function b(e){switch(e){case"A128GCM":case"A128GCMKW":case"A192GCM":case"A192GCMKW":case"A256GCM":case"A256GCMKW":return 96;case"A128CBC-HS256":case"A192CBC-HS384":case"A256CBC-HS512":return 128;default:throw new u(`Unsupported JWE Algorithm: ${e}`)}}var v=e=>S(new Uint8Array(b(e)>>3));const H=(e,t)=>{if(t.length<<3!==b(e))throw new l("Invalid Initialization Vector length")},C=(e,t)=>{if(e.length<<3!==t)throw new l("Invalid Content Encryption Key length")};function P(){return"function"==typeof WebSocketPair}function K(){try{return void 0!==process.versions.node}catch(e){return!1}}function _(e,t="algorithm.name"){return new TypeError(`CryptoKey does not support this operation, its ${t} must be ${e}`)}function W(e,t){return e.name===t}function k(e){return parseInt(e.name.substr(4),10)}function U(e,t){if(t.length&&!t.some((t=>e.usages.includes(t)))){let e="CryptoKey does not support this operation, its usages must include ";if(t.length>2){const r=t.pop();e+=`one of ${t.join(", ")}, or ${r}.`}else 2===t.length?e+=`one of ${t[0]} or ${t[1]}.`:e+=`${t[0]}.`;throw new TypeError(e)}}function R(e,t,...r){switch(t){case"HS256":case"HS384":case"HS512":{if(!W(e.algorithm,"HMAC"))throw _("HMAC");const r=parseInt(t.substr(2),10);if(k(e.algorithm.hash)!==r)throw _(`SHA-${r}`,"algorithm.hash");break}case"RS256":case"RS384":case"RS512":{if(!W(e.algorithm,"RSASSA-PKCS1-v1_5"))throw _("RSASSA-PKCS1-v1_5");const r=parseInt(t.substr(2),10);if(k(e.algorithm.hash)!==r)throw _(`SHA-${r}`,"algorithm.hash");break}case"PS256":case"PS384":case"PS512":{if(!W(e.algorithm,"RSA-PSS"))throw _("RSA-PSS");const r=parseInt(t.substr(2),10);if(k(e.algorithm.hash)!==r)throw _(`SHA-${r}`,"algorithm.hash");break}case K()&&"EdDSA":if("NODE-ED25519"!==e.algorithm.name&&"NODE-ED448"!==e.algorithm.name)throw _("NODE-ED25519 or NODE-ED448");break;case P()&&"EdDSA":if(!W(e.algorithm,"NODE-ED25519"))throw _("NODE-ED25519");break;case"ES256":case"ES384":case"ES512":{if(!W(e.algorithm,"ECDSA"))throw _("ECDSA");const r=function(e){switch(e){case"ES256":return"P-256";case"ES384":return"P-384";case"ES512":return"P-521";default:throw new Error("unreachable")}}(t);if(e.algorithm.namedCurve!==r)throw _(r,"algorithm.namedCurve");break}default:throw new TypeError("CryptoKey does not support this operation")}U(e,r)}function J(e,t,...r){switch(t){case"A128GCM":case"A192GCM":case"A256GCM":{if(!W(e.algorithm,"AES-GCM"))throw _("AES-GCM");const r=parseInt(t.substr(1,3),10);if(e.algorithm.length!==r)throw _(r,"algorithm.length");break}case"A128KW":case"A192KW":case"A256KW":{if(!W(e.algorithm,"AES-KW"))throw _("AES-KW");const r=parseInt(t.substr(1,3),10);if(e.algorithm.length!==r)throw _(r,"algorithm.length");break}case"ECDH-ES":if(!W(e.algorithm,"ECDH"))throw _("ECDH");break;case"PBES2-HS256+A128KW":case"PBES2-HS384+A192KW":case"PBES2-HS512+A256KW":if(!W(e.algorithm,"PBKDF2"))throw _("PBKDF2");break;case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":{if(!W(e.algorithm,"RSA-OAEP"))throw _("RSA-OAEP");const r=parseInt(t.substr(9),10)||1;if(k(e.algorithm.hash)!==r)throw _(`SHA-${r}`,"algorithm.hash");break}default:throw new TypeError("CryptoKey does not support this operation")}U(e,r)}var D=(e,...t)=>{let r="Key must be ";if(t.length>2){const e=t.pop();r+=`one of type ${t.join(", ")}, or ${e}.`}else 2===t.length?r+=`one of type ${t[0]} or ${t[1]}.`:r+=`of type ${t[0]}.`;return null==e?r+=` Received ${e}`:"function"==typeof e&&e.name?r+=` Received function ${e.name}`:"object"==typeof e&&null!=e&&e.constructor&&e.constructor.name&&(r+=` Received an instance of ${e.constructor.name}`),r},O=e=>A(e);const T=["CryptoKey"];async function M(e,t,r,n,o,s){if(!(t instanceof Uint8Array))throw new TypeError(D(t,"Uint8Array"));const c=parseInt(e.substr(1,3),10),d=await m.subtle.importKey("raw",t.subarray(c>>3),"AES-CBC",!1,["decrypt"]),p=await m.subtle.importKey("raw",t.subarray(0,c>>3),{hash:"SHA-"+(c<<1),name:"HMAC"},!1,["sign"]),h=a(s,n,r,i(s.length<<3)),y=new Uint8Array((await m.subtle.sign("HMAC",p,h)).slice(0,c>>3));let u,l;try{u=((e,t)=>{if(!(e instanceof Uint8Array))throw new TypeError("First argument must be a buffer");if(!(t instanceof Uint8Array))throw new TypeError("Second argument must be a buffer");if(e.length!==t.length)throw new TypeError("Input buffers must have the same length");const r=e.length;let n=0,a=-1;for(;++a{if(!(A(t)||t instanceof Uint8Array))throw new TypeError(D(t,...T,"Uint8Array"));switch(H(e,n),e){case"A128CBC-HS256":case"A192CBC-HS384":case"A256CBC-HS512":return t instanceof Uint8Array&&C(t,parseInt(e.substr(-3),10)),M(e,t,r,n,o,i);case"A128GCM":case"A192GCM":case"A256GCM":return t instanceof Uint8Array&&C(t,parseInt(e.substr(1,3),10)),async function(e,t,r,n,o,i){let s;t instanceof Uint8Array?s=await m.subtle.importKey("raw",t,"AES-GCM",!1,["decrypt"]):(J(t,e,"decrypt"),s=t);try{return new Uint8Array(await m.subtle.decrypt({additionalData:i,iv:n,name:"AES-GCM",tagLength:128},s,a(r,o)))}catch(e){throw new w}}(e,t,r,n,o,i);default:throw new u("Unsupported JWE Content Encryption Algorithm")}},x=async()=>{throw new u('JWE "zip" (Compression Algorithm) Header Parameter is not supported by your javascript runtime. You need to use the `inflateRaw` decrypt option to provide Inflate Raw implementation.')},B=async()=>{throw new u('JWE "zip" (Compression Algorithm) Header Parameter is not supported by your javascript runtime. You need to use the `deflateRaw` encrypt option to provide Deflate Raw implementation.')},$=(...e)=>{const t=e.filter(Boolean);if(0===t.length||1===t.length)return!0;let r;for(const e of t){const t=Object.keys(e);if(r&&0!==r.size)for(const e of t){if(r.has(e))return!1;r.add(e)}else r=new Set(t)}return!0};function G(e){if("object"!=typeof(t=e)||null===t||"[object Object]"!==Object.prototype.toString.call(e))return!1;var t;if(null===Object.getPrototypeOf(e))return!0;let r=e;for(;null!==Object.getPrototypeOf(r);)r=Object.getPrototypeOf(r);return Object.getPrototypeOf(e)===r}const j=[{hash:"SHA-256",name:"HMAC"},!0,["sign"]];function N(e,t){if(e.algorithm.length!==parseInt(t.substr(1,3),10))throw new TypeError(`Invalid key size for alg: ${t}`)}function z(e,t,r){if(A(e))return J(e,t,r),e;if(e instanceof Uint8Array)return m.subtle.importKey("raw",e,"AES-KW",!0,[r]);throw new TypeError(D(e,...T,"Uint8Array"))}const L=async(e,t,r)=>{const n=await z(t,e,"wrapKey");N(n,e);const a=await m.subtle.importKey("raw",r,...j);return new Uint8Array(await m.subtle.wrapKey("raw",a,n,"AES-KW"))},F=async(e,t,r)=>{const n=await z(t,e,"unwrapKey");N(n,e);const a=await m.subtle.unwrapKey("raw",r,n,"AES-KW",...j);return new Uint8Array(await m.subtle.exportKey("raw",a))},V=async(e,t)=>{const r=`SHA-${e.substr(-3)}`;return new Uint8Array(await m.subtle.digest(r,t))},Y=async(e,r,n,o,i=new Uint8Array(0),d=new Uint8Array(0))=>{if(!A(e))throw new TypeError(D(e,...T));if(J(e,"ECDH-ES"),!A(r))throw new TypeError(D(r,...T));J(r,"ECDH-ES","deriveBits","deriveKey");const p=a(c(t.encode(n)),c(i),c(d),s(o));if(!r.usages.includes("deriveBits"))throw new TypeError('ECDH-ES private key "usages" must include "deriveBits"');const h=new Uint8Array(await m.subtle.deriveBits({name:"ECDH",public:e},r,Math.ceil(parseInt(r.algorithm.namedCurve.substr(-3),10)/8)<<3));return async function(e,t,r,n){const o=Math.ceil((r>>3)/32);let i;for(let r=1;r<=o;r++){const o=new Uint8Array(4+t.length+n.length);o.set(s(r)),o.set(t,4),o.set(n,4+t.length),i=i?a(i,await e("sha256",o)):await e("sha256",o)}return i=i.slice(0,r>>3),i}(V,h,o,p)},q=e=>{if(!A(e))throw new TypeError(D(e,...T));return["P-256","P-384","P-521"].includes(e.algorithm.namedCurve)};async function X(e,r,n,o){!function(e){if(!(e instanceof Uint8Array)||e.length<8)throw new l("PBES2 Salt Input must be 8 or more octets")}(e);const i=function(e,r){return a(t.encode(e),new Uint8Array([0]),r)}(r,e),s=parseInt(r.substr(13,3),10),c={hash:`SHA-${r.substr(8,3)}`,iterations:n,name:"PBKDF2",salt:i},d={length:s,name:"AES-KW"},p=await function(e,t){if(e instanceof Uint8Array)return m.subtle.importKey("raw",e,"PBKDF2",!1,["deriveBits"]);if(A(e))return J(e,t,"deriveBits","deriveKey"),e;throw new TypeError(D(e,...T,"Uint8Array"))}(o,r);if(p.usages.includes("deriveBits"))return new Uint8Array(await m.subtle.deriveBits(c,p,s));if(p.usages.includes("deriveKey"))return m.subtle.deriveKey(c,p,d,!1,["wrapKey","unwrapKey"]);throw new TypeError('PBKDF2 key "usages" must include "deriveBits" or "deriveKey"')}function Q(e){switch(e){case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":return"RSA-OAEP";default:throw new u(`alg ${e} is not supported either by JOSE or your javascript runtime`)}}var Z=(e,t)=>{if(e.startsWith("RS")||e.startsWith("PS")){const{modulusLength:r}=t.algorithm;if("number"!=typeof r||r<2048)throw new TypeError(`${e} requires key modulusLength to be 2048 bits or larger`)}};function ee(e){switch(e){case"A128GCM":return 128;case"A192GCM":return 192;case"A256GCM":case"A128CBC-HS256":return 256;case"A192CBC-HS384":return 384;case"A256CBC-HS512":return 512;default:throw new u(`Unsupported JWE Algorithm: ${e}`)}}var te=e=>S(new Uint8Array(ee(e)>>3));var re=async e=>{var t,r;const{algorithm:n,keyUsages:a}=function(e){let t,r;switch(e.kty){case"oct":switch(e.alg){case"HS256":case"HS384":case"HS512":t={name:"HMAC",hash:`SHA-${e.alg.substr(-3)}`},r=["sign","verify"];break;case"A128CBC-HS256":case"A192CBC-HS384":case"A256CBC-HS512":throw new u(`${e.alg} keys cannot be imported as CryptoKey instances`);case"A128GCM":case"A192GCM":case"A256GCM":case"A128GCMKW":case"A192GCMKW":case"A256GCMKW":t={name:"AES-GCM"},r=["encrypt","decrypt"];break;case"A128KW":case"A192KW":case"A256KW":t={name:"AES-KW"},r=["wrapKey","unwrapKey"];break;case"PBES2-HS256+A128KW":case"PBES2-HS384+A192KW":case"PBES2-HS512+A256KW":t={name:"PBKDF2"},r=["deriveBits"];break;default:throw new u('Invalid or unsupported JWK "alg" (Algorithm) Parameter value')}break;case"RSA":switch(e.alg){case"PS256":case"PS384":case"PS512":t={name:"RSA-PSS",hash:`SHA-${e.alg.substr(-3)}`},r=e.d?["sign"]:["verify"];break;case"RS256":case"RS384":case"RS512":t={name:"RSASSA-PKCS1-v1_5",hash:`SHA-${e.alg.substr(-3)}`},r=e.d?["sign"]:["verify"];break;case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":t={name:"RSA-OAEP",hash:`SHA-${parseInt(e.alg.substr(-3),10)||1}`},r=e.d?["decrypt","unwrapKey"]:["encrypt","wrapKey"];break;default:throw new u('Invalid or unsupported JWK "alg" (Algorithm) Parameter value')}break;case"EC":switch(e.alg){case"ES256":t={name:"ECDSA",namedCurve:"P-256"},r=e.d?["sign"]:["verify"];break;case"ES384":t={name:"ECDSA",namedCurve:"P-384"},r=e.d?["sign"]:["verify"];break;case"ES512":t={name:"ECDSA",namedCurve:"P-521"},r=e.d?["sign"]:["verify"];break;case"ECDH-ES":case"ECDH-ES+A128KW":case"ECDH-ES+A192KW":case"ECDH-ES+A256KW":t={name:"ECDH",namedCurve:e.crv},r=e.d?["deriveBits"]:[];break;default:throw new u('Invalid or unsupported JWK "alg" (Algorithm) Parameter value')}break;case(P()||K())&&"OKP":if("EdDSA"!==e.alg)throw new u('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');switch(e.crv){case"Ed25519":t={name:"NODE-ED25519",namedCurve:"NODE-ED25519"},r=e.d?["sign"]:["verify"];break;case K()&&"Ed448":t={name:"NODE-ED448",namedCurve:"NODE-ED448"},r=e.d?["sign"]:["verify"];break;default:throw new u('Invalid or unsupported JWK "crv" (Subtype of Key Pair) Parameter value')}break;default:throw new u('Invalid or unsupported JWK "kty" (Key Type) Parameter value')}return{algorithm:t,keyUsages:r}}(e),o=[n,null!==(t=e.ext)&&void 0!==t&&t,null!==(r=e.key_ops)&&void 0!==r?r:a];if("PBKDF2"===n.name)return m.subtle.importKey("raw",p(e.k),...o);const i={...e};return delete i.alg,m.subtle.importKey("jwk",i,...o)};async function ne(e,t,r){if(!G(e))throw new TypeError("JWK must be an object");if(t||(t=e.alg),"string"!=typeof t||!t)throw new TypeError('"alg" argument is required when "jwk.alg" is not present');switch(e.kty){case"oct":if("string"!=typeof e.k||!e.k)throw new TypeError('missing "k" (Key Value) Parameter value');return null!=r||(r=!0!==e.ext),r?re({...e,alg:t,ext:!1}):p(e.k);case"RSA":if(void 0!==e.oth)throw new u('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');case"EC":case"OKP":return re({...e,alg:t});default:throw new u('Unsupported "kty" (Key Type) Parameter value')}}const ae=(e,t,r)=>{e.startsWith("HS")||"dir"===e||e.startsWith("PBES2")||/^A\d{3}(?:GCM)?KW$/.test(e)?(e=>{if(!(e instanceof Uint8Array)){if(!O(e))throw new TypeError(D(e,...T,"Uint8Array"));if("secret"!==e.type)throw new TypeError(`${T.join(" or ")} instances for symmetric algorithms must be of type "secret"`)}})(t):((e,t)=>{if(!O(e))throw new TypeError(D(e,...T));if("secret"===e.type)throw new TypeError(`${T.join(" or ")} instances for asymmetric algorithms must not be of type "secret"`);if("sign"===t&&"public"===e.type)throw new TypeError(`${T.join(" or ")} instances for asymmetric algorithm signing must be of type "private"`);if("decrypt"===t&&"public"===e.type)throw new TypeError(`${T.join(" or ")} instances for asymmetric algorithm decryption must be of type "private"`);if(e.algorithm&&"verify"===t&&"private"===e.type)throw new TypeError(`${T.join(" or ")} instances for asymmetric algorithm verifying must be of type "public"`);if(e.algorithm&&"encrypt"===t&&"private"===e.type)throw new TypeError(`${T.join(" or ")} instances for asymmetric algorithm encryption must be of type "public"`)})(t,r)};const oe=async(e,t,r,n,o)=>{if(!(A(r)||r instanceof Uint8Array))throw new TypeError(D(r,...T,"Uint8Array"));switch(H(e,n),e){case"A128CBC-HS256":case"A192CBC-HS384":case"A256CBC-HS512":return r instanceof Uint8Array&&C(r,parseInt(e.substr(-3),10)),async function(e,t,r,n,o){if(!(r instanceof Uint8Array))throw new TypeError(D(r,"Uint8Array"));const s=parseInt(e.substr(1,3),10),c=await m.subtle.importKey("raw",r.subarray(s>>3),"AES-CBC",!1,["encrypt"]),d=await m.subtle.importKey("raw",r.subarray(0,s>>3),{hash:"SHA-"+(s<<1),name:"HMAC"},!1,["sign"]),p=new Uint8Array(await m.subtle.encrypt({iv:n,name:"AES-CBC"},c,t)),h=a(o,n,p,i(o.length<<3));return{ciphertext:p,tag:new Uint8Array((await m.subtle.sign("HMAC",d,h)).slice(0,s>>3))}}(e,t,r,n,o);case"A128GCM":case"A192GCM":case"A256GCM":return r instanceof Uint8Array&&C(r,parseInt(e.substr(1,3),10)),async function(e,t,r,n,a){let o;r instanceof Uint8Array?o=await m.subtle.importKey("raw",r,"AES-GCM",!1,["encrypt"]):(J(r,e,"encrypt"),o=r);const i=new Uint8Array(await m.subtle.encrypt({additionalData:a,iv:n,name:"AES-GCM",tagLength:128},o,t)),s=i.slice(-16);return{ciphertext:i.slice(0,-16),tag:s}}(e,t,r,n,o);default:throw new u("Unsupported JWE Content Encryption Algorithm")}};async function ie(e,t,r,n){switch(ae(e,t,"decrypt"),e){case"dir":if(void 0!==r)throw new l("Encountered unexpected JWE Encrypted Key");return t;case"ECDH-ES":if(void 0!==r)throw new l("Encountered unexpected JWE Encrypted Key");case"ECDH-ES+A128KW":case"ECDH-ES+A192KW":case"ECDH-ES+A256KW":{if(!G(n.epk))throw new l('JOSE Header "epk" (Ephemeral Public Key) missing or invalid');if(!q(t))throw new u("ECDH-ES with the provided key is not allowed or not supported by your javascript runtime");const a=await ne(n.epk,e);let o,i;if(void 0!==n.apu){if("string"!=typeof n.apu)throw new l('JOSE Header "apu" (Agreement PartyUInfo) invalid');o=p(n.apu)}if(void 0!==n.apv){if("string"!=typeof n.apv)throw new l('JOSE Header "apv" (Agreement PartyVInfo) invalid');i=p(n.apv)}const s=await Y(a,t,"ECDH-ES"===e?n.enc:e,"ECDH-ES"===e?ee(n.enc):parseInt(e.substr(-5,3),10),o,i);if("ECDH-ES"===e)return s;if(void 0===r)throw new l("JWE Encrypted Key missing");return F(e.substr(-6),s,r)}case"RSA1_5":case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":if(void 0===r)throw new l("JWE Encrypted Key missing");return(async(e,t,r)=>{if(!A(t))throw new TypeError(D(t,...T));if(J(t,e,"decrypt","unwrapKey"),Z(e,t),t.usages.includes("decrypt"))return new Uint8Array(await m.subtle.decrypt(Q(e),t,r));if(t.usages.includes("unwrapKey")){const n=await m.subtle.unwrapKey("raw",r,t,Q(e),...j);return new Uint8Array(await m.subtle.exportKey("raw",n))}throw new TypeError('RSA-OAEP key "usages" must include "decrypt" or "unwrapKey" for this operation')})(e,t,r);case"PBES2-HS256+A128KW":case"PBES2-HS384+A192KW":case"PBES2-HS512+A256KW":if(void 0===r)throw new l("JWE Encrypted Key missing");if("number"!=typeof n.p2c)throw new l('JOSE Header "p2c" (PBES2 Count) missing or invalid');if("string"!=typeof n.p2s)throw new l('JOSE Header "p2s" (PBES2 Salt) missing or invalid');return(async(e,t,r,n,a)=>{const o=await X(a,e,n,t);return F(e.substr(-6),o,r)})(e,t,r,n.p2c,p(n.p2s));case"A128KW":case"A192KW":case"A256KW":if(void 0===r)throw new l("JWE Encrypted Key missing");return F(e,t,r);case"A128GCMKW":case"A192GCMKW":case"A256GCMKW":if(void 0===r)throw new l("JWE Encrypted Key missing");if("string"!=typeof n.iv)throw new l('JOSE Header "iv" (Initialization Vector) missing or invalid');if("string"!=typeof n.tag)throw new l('JOSE Header "tag" (Authentication Tag) missing or invalid');return async function(e,t,r,n,a){const o=e.substr(0,7);return I(o,t,r,n,a,new Uint8Array(0))}(e,t,r,p(n.iv),p(n.tag));default:throw new u('Invalid or unsupported "alg" (JWE Algorithm) header value')}}function se(e,t,r,n,a){if(void 0!==a.crit&&void 0===n.crit)throw new e('"crit" (Critical) Header Parameter MUST be integrity protected');if(!n||void 0===n.crit)return new Set;if(!Array.isArray(n.crit)||0===n.crit.length||n.crit.some((e=>"string"!=typeof e||0===e.length)))throw new e('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');let o;o=void 0!==r?new Map([...Object.entries(r),...t.entries()]):t;for(const t of n.crit){if(!o.has(t))throw new u(`Extension Header Parameter "${t}" is not recognized`);if(void 0===a[t])throw new e(`Extension Header Parameter "${t}" is missing`);if(o.get(t)&&void 0===n[t])throw new e(`Extension Header Parameter "${t}" MUST be integrity protected`)}return new Set(n.crit)}const ce=(e,t)=>{if(void 0!==t&&(!Array.isArray(t)||t.some((e=>"string"!=typeof e))))throw new TypeError(`"${e}" option must be an array of strings`);if(t)return new Set(t)};async function de(e,n,o){var i;if(!G(e))throw new l("Flattened JWE must be an object");if(void 0===e.protected&&void 0===e.header&&void 0===e.unprotected)throw new l("JOSE Header missing");if("string"!=typeof e.iv)throw new l("JWE Initialization Vector missing or incorrect type");if("string"!=typeof e.ciphertext)throw new l("JWE Ciphertext missing or incorrect type");if("string"!=typeof e.tag)throw new l("JWE Authentication Tag missing or incorrect type");if(void 0!==e.protected&&"string"!=typeof e.protected)throw new l("JWE Protected Header incorrect type");if(void 0!==e.encrypted_key&&"string"!=typeof e.encrypted_key)throw new l("JWE Encrypted Key incorrect type");if(void 0!==e.aad&&"string"!=typeof e.aad)throw new l("JWE AAD incorrect type");if(void 0!==e.header&&!G(e.header))throw new l("JWE Shared Unprotected Header incorrect type");if(void 0!==e.unprotected&&!G(e.unprotected))throw new l("JWE Per-Recipient Unprotected Header incorrect type");let s;if(e.protected){const t=p(e.protected);try{s=JSON.parse(r.decode(t))}catch(e){throw new l("JWE Protected Header is invalid")}}if(!$(s,e.header,e.unprotected))throw new l("JWE Protected, JWE Unprotected Header, and JWE Per-Recipient Unprotected Header Parameter names must be disjoint");const c={...s,...e.header,...e.unprotected};if(se(l,new Map,null==o?void 0:o.crit,s,c),void 0!==c.zip){if(!s||!s.zip)throw new l('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');if("DEF"!==c.zip)throw new u('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value')}const{alg:d,enc:h}=c;if("string"!=typeof d||!d)throw new l("missing JWE Algorithm (alg) in JWE Header");if("string"!=typeof h||!h)throw new l("missing JWE Encryption Algorithm (enc) in JWE Header");const w=o&&ce("keyManagementAlgorithms",o.keyManagementAlgorithms),f=o&&ce("contentEncryptionAlgorithms",o.contentEncryptionAlgorithms);if(w&&!w.has(d))throw new y('"alg" (Algorithm) Header Parameter not allowed');if(f&&!f.has(h))throw new y('"enc" (Encryption Algorithm) Header Parameter not allowed');let g;void 0!==e.encrypted_key&&(g=p(e.encrypted_key));let E,m=!1;"function"==typeof n&&(n=await n(s,e),m=!0);try{E=await ie(d,n,g,c)}catch(e){if(e instanceof TypeError)throw e;E=te(h)}const A=p(e.iv),S=p(e.tag),b=t.encode(null!==(i=e.protected)&&void 0!==i?i:"");let v;v=void 0!==e.aad?a(b,t.encode("."),t.encode(e.aad)):b;let H=await I(h,E,p(e.ciphertext),A,S,v);"DEF"===c.zip&&(H=await((null==o?void 0:o.inflateRaw)||x)(H));const C={plaintext:H};return void 0!==e.protected&&(C.protectedHeader=s),void 0!==e.aad&&(C.additionalAuthenticatedData=p(e.aad)),void 0!==e.unprotected&&(C.sharedUnprotectedHeader=e.unprotected),void 0!==e.header&&(C.unprotectedHeader=e.header),m?{...C,key:n}:C}async function pe(e,t,n){if(e instanceof Uint8Array&&(e=r.decode(e)),"string"!=typeof e)throw new l("Compact JWE must be a string or Uint8Array");const{0:a,1:o,2:i,3:s,4:c,length:d}=e.split(".");if(5!==d)throw new l("Invalid Compact JWE");const p=await de({ciphertext:s||void 0,iv:i||void 0,protected:a||void 0,tag:c||void 0,encrypted_key:o||void 0},t,n),h={plaintext:p.plaintext,protectedHeader:p.protectedHeader};return"function"==typeof t?{...h,key:p.key}:h}var he=async e=>{if(e instanceof Uint8Array)return{kty:"oct",k:d(e)};if(!A(e))throw new TypeError(D(e,...T,"Uint8Array"));if(!e.extractable)throw new TypeError("non-extractable CryptoKey cannot be exported as a JWK");const{ext:t,key_ops:r,alg:n,use:a,...o}=await m.subtle.exportKey("jwk",e);return o};async function ye(e){return he(e)}async function ue(e,t,r,n,a={}){let o,i,s;switch(ae(e,r,"encrypt"),e){case"dir":s=r;break;case"ECDH-ES":case"ECDH-ES+A128KW":case"ECDH-ES+A192KW":case"ECDH-ES+A256KW":{if(!q(r))throw new u("ECDH-ES with the provided key is not allowed or not supported by your javascript runtime");const{apu:c,apv:p}=a;let{epk:h}=a;h||(h=await(async e=>{if(!A(e))throw new TypeError(D(e,...T));return(await m.subtle.generateKey({name:"ECDH",namedCurve:e.algorithm.namedCurve},!0,["deriveBits"])).privateKey})(r));const{x:y,y:w,crv:l,kty:f}=await ye(h),g=await Y(r,h,"ECDH-ES"===e?t:e,"ECDH-ES"===e?ee(t):parseInt(e.substr(-5,3),10),c,p);if(i={epk:{x:y,y:w,crv:l,kty:f}},c&&(i.apu=d(c)),p&&(i.apv=d(p)),"ECDH-ES"===e){s=g;break}s=n||te(t);const E=e.substr(-6);o=await L(E,g,s);break}case"RSA1_5":case"RSA-OAEP":case"RSA-OAEP-256":case"RSA-OAEP-384":case"RSA-OAEP-512":s=n||te(t),o=await(async(e,t,r)=>{if(!A(t))throw new TypeError(D(t,...T));if(J(t,e,"encrypt","wrapKey"),Z(e,t),t.usages.includes("encrypt"))return new Uint8Array(await m.subtle.encrypt(Q(e),t,r));if(t.usages.includes("wrapKey")){const n=await m.subtle.importKey("raw",r,...j);return new Uint8Array(await m.subtle.wrapKey("raw",n,t,Q(e)))}throw new TypeError('RSA-OAEP key "usages" must include "encrypt" or "wrapKey" for this operation')})(e,r,s);break;case"PBES2-HS256+A128KW":case"PBES2-HS384+A192KW":case"PBES2-HS512+A256KW":{s=n||te(t);const{p2c:c,p2s:p}=a;({encryptedKey:o,...i}=await(async(e,t,r,n=Math.floor(2049*Math.random())+2048,a=S(new Uint8Array(16)))=>{const o=await X(a,e,n,t);return{encryptedKey:await L(e.substr(-6),o,r),p2c:n,p2s:d(a)}})(e,r,s,c,p));break}case"A128KW":case"A192KW":case"A256KW":s=n||te(t),o=await L(e,r,s);break;case"A128GCMKW":case"A192GCMKW":case"A256GCMKW":{s=n||te(t);const{iv:c}=a;({encryptedKey:o,...i}=await async function(e,t,r,n){const a=e.substr(0,7);n||(n=v(a));const{ciphertext:o,tag:i}=await oe(a,r,t,n,new Uint8Array(0));return{encryptedKey:o,iv:d(n),tag:d(i)}}(e,r,s,c));break}default:throw new u('Invalid or unsupported "alg" (JWE Algorithm) header value')}return{cek:s,encryptedKey:o,parameters:i}}const we=Symbol();class le{constructor(e){if(!(e instanceof Uint8Array))throw new TypeError("plaintext must be an instance of Uint8Array");this._plaintext=e}setKeyManagementParameters(e){if(this._keyManagementParameters)throw new TypeError("setKeyManagementParameters can only be called once");return this._keyManagementParameters=e,this}setProtectedHeader(e){if(this._protectedHeader)throw new TypeError("setProtectedHeader can only be called once");return this._protectedHeader=e,this}setSharedUnprotectedHeader(e){if(this._sharedUnprotectedHeader)throw new TypeError("setSharedUnprotectedHeader can only be called once");return this._sharedUnprotectedHeader=e,this}setUnprotectedHeader(e){if(this._unprotectedHeader)throw new TypeError("setUnprotectedHeader can only be called once");return this._unprotectedHeader=e,this}setAdditionalAuthenticatedData(e){return this._aad=e,this}setContentEncryptionKey(e){if(this._cek)throw new TypeError("setContentEncryptionKey can only be called once");return this._cek=e,this}setInitializationVector(e){if(this._iv)throw new TypeError("setInitializationVector can only be called once");return this._iv=e,this}async encrypt(e,n){if(!this._protectedHeader&&!this._unprotectedHeader&&!this._sharedUnprotectedHeader)throw new l("either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()");if(!$(this._protectedHeader,this._unprotectedHeader,this._sharedUnprotectedHeader))throw new l("JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint");const o={...this._protectedHeader,...this._unprotectedHeader,...this._sharedUnprotectedHeader};if(se(l,new Map,null==n?void 0:n.crit,this._protectedHeader,o),void 0!==o.zip){if(!this._protectedHeader||!this._protectedHeader.zip)throw new l('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');if("DEF"!==o.zip)throw new u('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value')}const{alg:i,enc:s}=o;if("string"!=typeof i||!i)throw new l('JWE "alg" (Algorithm) Header Parameter missing or invalid');if("string"!=typeof s||!s)throw new l('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');let c,p,h,y,w,f,g;if("dir"===i){if(this._cek)throw new TypeError("setContentEncryptionKey cannot be called when using Direct Encryption")}else if("ECDH-ES"===i&&this._cek)throw new TypeError("setContentEncryptionKey cannot be called when using Direct Key Agreement");{let t;({cek:p,encryptedKey:c,parameters:t}=await ue(i,s,e,this._cek,this._keyManagementParameters)),t&&(n&&we in n?this._unprotectedHeader?this._unprotectedHeader={...this._unprotectedHeader,...t}:this.setUnprotectedHeader(t):this._protectedHeader?this._protectedHeader={...this._protectedHeader,...t}:this.setProtectedHeader(t))}if(this._iv||(this._iv=v(s)),y=this._protectedHeader?t.encode(d(JSON.stringify(this._protectedHeader))):t.encode(""),this._aad?(w=d(this._aad),h=a(y,t.encode("."),t.encode(w))):h=y,"DEF"===o.zip){const e=await((null==n?void 0:n.deflateRaw)||B)(this._plaintext);({ciphertext:f,tag:g}=await oe(s,e,p,this._iv,h))}else({ciphertext:f,tag:g}=await oe(s,this._plaintext,p,this._iv,h));const E={ciphertext:d(f),iv:d(this._iv),tag:d(g)};return c&&(E.encrypted_key=d(c)),w&&(E.aad=w),this._protectedHeader&&(E.protected=r.decode(y)),this._sharedUnprotectedHeader&&(E.unprotected=this._sharedUnprotectedHeader),this._unprotectedHeader&&(E.header=this._unprotectedHeader),E}}function fe(e,t){const r=parseInt(e.substr(-3),10);switch(e){case"HS256":case"HS384":case"HS512":return{hash:`SHA-${r}`,name:"HMAC"};case"PS256":case"PS384":case"PS512":return{hash:`SHA-${r}`,name:"RSA-PSS",saltLength:r>>3};case"RS256":case"RS384":case"RS512":return{hash:`SHA-${r}`,name:"RSASSA-PKCS1-v1_5"};case"ES256":case"ES384":case"ES512":return{hash:`SHA-${r}`,name:"ECDSA",namedCurve:t};case(P()||K())&&"EdDSA":return{name:t,namedCurve:t};default:throw new u(`alg ${e} is not supported either by JOSE or your javascript runtime`)}}function ge(e,t,r){if(A(t))return R(t,e,r),t;if(t instanceof Uint8Array){if(!e.startsWith("HS"))throw new TypeError(D(t,...T));return m.subtle.importKey("raw",t,{hash:`SHA-${e.substr(-3)}`,name:"HMAC"},!1,[r])}throw new TypeError(D(t,...T,"Uint8Array"))}async function Ee(e,n,o){var i;if(!G(e))throw new f("Flattened JWS must be an object");if(void 0===e.protected&&void 0===e.header)throw new f('Flattened JWS must have either of the "protected" or "header" members');if(void 0!==e.protected&&"string"!=typeof e.protected)throw new f("JWS Protected Header incorrect type");if(void 0===e.payload)throw new f("JWS Payload missing");if("string"!=typeof e.signature)throw new f("JWS Signature missing or incorrect type");if(void 0!==e.header&&!G(e.header))throw new f("JWS Unprotected Header incorrect type");let s={};if(e.protected){const t=p(e.protected);try{s=JSON.parse(r.decode(t))}catch(e){throw new f("JWS Protected Header is invalid")}}if(!$(s,e.header))throw new f("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");const c={...s,...e.header};let d=!0;if(se(f,new Map([["b64",!0]]),null==o?void 0:o.crit,s,c).has("b64")&&(d=s.b64,"boolean"!=typeof d))throw new f('The "b64" (base64url-encode payload) Header Parameter must be a boolean');const{alg:h}=c;if("string"!=typeof h||!h)throw new f('JWS "alg" (Algorithm) Header Parameter missing or invalid');const u=o&&ce("algorithms",o.algorithms);if(u&&!u.has(h))throw new y('"alg" (Algorithm) Header Parameter not allowed');if(d){if("string"!=typeof e.payload)throw new f("JWS Payload must be a string")}else if("string"!=typeof e.payload&&!(e.payload instanceof Uint8Array))throw new f("JWS Payload must be a string or an Uint8Array instance");let w=!1;"function"==typeof n&&(n=await n(s,e),w=!0),ae(h,n,"verify");const l=a(t.encode(null!==(i=e.protected)&&void 0!==i?i:""),t.encode("."),"string"==typeof e.payload?t.encode(e.payload):e.payload),g=p(e.signature),A=await(async(e,t,r,n)=>{const a=await ge(e,t,"verify");Z(e,a);const o=fe(e,a.algorithm.namedCurve);try{return await m.subtle.verify(o,a,r,n)}catch(e){return!1}})(h,n,g,l);if(!A)throw new E;let S;S=d?p(e.payload):"string"==typeof e.payload?t.encode(e.payload):e.payload;const b={payload:S};return void 0!==e.protected&&(b.protectedHeader=s),void 0!==e.header&&(b.unprotectedHeader=e.header),w?{...b,key:n}:b}async function me(e,t,n){if(e instanceof Uint8Array&&(e=r.decode(e)),"string"!=typeof e)throw new f("Compact JWS must be a string or Uint8Array");const{0:a,1:o,2:i,length:s}=e.split(".");if(3!==s)throw new f("Invalid Compact JWS");const c=await Ee({payload:o,protected:a,signature:i},t,n),d={payload:c.payload,protectedHeader:c.protectedHeader};return"function"==typeof t?{...d,key:c.key}:d}class Ae{constructor(e){this._flattened=new le(e)}setContentEncryptionKey(e){return this._flattened.setContentEncryptionKey(e),this}setInitializationVector(e){return this._flattened.setInitializationVector(e),this}setProtectedHeader(e){return this._flattened.setProtectedHeader(e),this}setKeyManagementParameters(e){return this._flattened.setKeyManagementParameters(e),this}async encrypt(e,t){const r=await this._flattened.encrypt(e,t);return[r.protected,r.encrypted_key,r.iv,r.ciphertext,r.tag].join(".")}}class Se{constructor(e){if(!(e instanceof Uint8Array))throw new TypeError("payload must be an instance of Uint8Array");this._payload=e}setProtectedHeader(e){if(this._protectedHeader)throw new TypeError("setProtectedHeader can only be called once");return this._protectedHeader=e,this}setUnprotectedHeader(e){if(this._unprotectedHeader)throw new TypeError("setUnprotectedHeader can only be called once");return this._unprotectedHeader=e,this}async sign(e,n){if(!this._protectedHeader&&!this._unprotectedHeader)throw new f("either setProtectedHeader or setUnprotectedHeader must be called before #sign()");if(!$(this._protectedHeader,this._unprotectedHeader))throw new f("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");const o={...this._protectedHeader,...this._unprotectedHeader};let i=!0;if(se(f,new Map([["b64",!0]]),null==n?void 0:n.crit,this._protectedHeader,o).has("b64")&&(i=this._protectedHeader.b64,"boolean"!=typeof i))throw new f('The "b64" (base64url-encode payload) Header Parameter must be a boolean');const{alg:s}=o;if("string"!=typeof s||!s)throw new f('JWS "alg" (Algorithm) Header Parameter missing or invalid');ae(s,e,"sign");let c,p=this._payload;i&&(p=t.encode(d(p))),c=this._protectedHeader?t.encode(d(JSON.stringify(this._protectedHeader))):t.encode("");const h=a(c,t.encode("."),p),y=await(async(e,t,r)=>{const n=await ge(e,t,"sign");Z(e,n);const a=await m.subtle.sign(fe(e,n.algorithm.namedCurve),n,r);return new Uint8Array(a)})(s,e,h),u={signature:d(y),payload:""};return i&&(u.payload=r.decode(p)),this._unprotectedHeader&&(u.header=this._unprotectedHeader),this._protectedHeader&&(u.protected=r.decode(c)),u}}class be{constructor(e){this._flattened=new Se(e)}setProtectedHeader(e){return this._flattened.setProtectedHeader(e),this}async sign(e,t){const r=await this._flattened.sign(e,t);if(void 0===r.payload)throw new TypeError("use the flattened module for creating JWS with b64: false");return`${r.protected}.${r.payload}.${r.signature}`}}const ve=(e,t)=>{if("string"!=typeof e||!e)throw new g(`${t} missing or invalid`)};const He=async function(e,t="SHA-256"){const r=["SHA-1","SHA-256","SHA-384","SHA-512"];if(!r.includes(t))throw new RangeError(`Valid hash algorith values are any of ${JSON.stringify(r)}`);const n=new TextEncoder,a="string"==typeof e?n.encode(e).buffer:e;let o="";{const e=await crypto.subtle.digest(t,a),r="0123456789abcdef";new Uint8Array(e).forEach((e=>{o+=r[e>>4]+r[15&e]}))}return o},Ce=async(e,t)=>{const{payload:r}=await me(t,e).catch((e=>{throw new Error(`PoR: ${String(e)}`)}));return JSON.parse((new TextDecoder).decode(r).toString())},Pe=async(e,t)=>{const{payload:r}=await me(t,e).catch((e=>{throw new Error("PoO "+String(e))}));return JSON.parse((new TextDecoder).decode(r).toString())},Ke=async(e,t)=>{const r=new TextDecoder,n=await ne(t,"A256GCM"),{plaintext:a}=await pe(e,n);return r.decode(a)},_e="ES256",We=async(e,t)=>{const r=(new TextEncoder).encode(JSON.stringify(t));return await new be(r).setProtectedHeader({alg:_e}).sign(e)};e.SIGNING_ALG=_e,e.createBlockchainProof=async(e,t,r,n)=>{const a=await Pe(e,t);return{privateStorage:{availability:"privateStorage",permissions:{view:[a.exchange.orig,a.exchange.dest]},type:"dict",id:a.exchange.id,content:{[a.exchange.block_id]:{poO:t,poR:r}}},blockchain:{availability:"blockchain",type:"jwk",content:{[n.kid]:n}}}},e.createJwk=async()=>{let e;e=await window.crypto.subtle.generateKey({name:"AES-GCM",length:256},!0,["encrypt","decrypt"]);const r=await ye(e),n=await async function(e,r="sha256"){if(!G(e))throw new TypeError("JWK must be an object");let n;switch(e.kty){case"EC":ve(e.crv,'"crv" (Curve) Parameter'),ve(e.x,'"x" (X Coordinate) Parameter'),ve(e.y,'"y" (Y Coordinate) Parameter'),n={crv:e.crv,kty:e.kty,x:e.x,y:e.y};break;case"OKP":ve(e.crv,'"crv" (Subtype of Key Pair) Parameter'),ve(e.x,'"x" (Public Key) Parameter'),n={crv:e.crv,kty:e.kty,x:e.x};break;case"RSA":ve(e.e,'"e" (Exponent) Parameter'),ve(e.n,'"n" (Modulus) Parameter'),n={e:e.e,kty:e.kty,n:e.n};break;case"oct":ve(e.k,'"k" (Key Value) Parameter'),n={k:e.k,kty:e.kty};break;default:throw new u('"kty" (Key Type) Parameter missing or unsupported')}const a=t.encode(JSON.stringify(n));return d(await V(r,a))}(r);return r.kid=n,r.alg="A256GCM",r},e.createPoO=async(e,t,r,n,a,o,i)=>{const s="string"==typeof t?(new TextEncoder).encode(t):new Uint8Array(t),c=await ne(i),d=await new Ae(s).setProtectedHeader({alg:"dir",enc:"A256GCM"}).encrypt(c),p=await He(d),h=await He(s),y=await He(JSON.stringify(i)),u={iss:r,sub:n,iat:Date.now(),exchange:{id:a,orig:r,dest:n,block_id:o,block_desc:"description",hash_alg:"sha256",cipherblock_dgst:p,block_commitment:h,key_commitment:y}};return{cipherblock:d,poO:await We(e,u)}},e.createPoR=async(e,t,r,n,a)=>{const o=await He(t),i={iss:r,sub:n,iat:Date.now(),exchange:{poo_dgst:o,hash_alg:"sha256",exchangeId:a}};return await We(e,i)},e.decodePoo=Pe,e.decodePor=Ce,e.decryptCipherblock=Ke,e.sha=He,e.signProof=We,e.validateCipherblock=async(e,t,r,n)=>{const a=await Ke(t,r);if(await He(a)===n.exchange.block_commitment)return!0;throw new Error("hashed CipherBlock not correspond to block_commitment parameter included in the proof of origin")},e.validatePoO=async(e,t,r)=>{const n=await Pe(e,t),a=await He(r);if(n.exchange.cipherblock_dgst!==a)throw new Error("the cipherblock_dgst parameter in the proof of origin does not correspond to hash of the cipherblock received by the provider");if(Date.now()-n.iat>5e3)throw new Error("timestamp error");return!0},e.validatePoP=(e,t,r,n,a)=>new Promise(((o,i)=>{me(r,e).catch((e=>{i(new Error("PoP "+String(e)))})),Pe(t,a).then((e=>{He(JSON.stringify(n)).then((t=>{e.exchange.key_commitment===t?o(!0):i(new Error("hashed key not correspond to poO key_commitment parameter"))})).catch((e=>i(e)))})).catch((e=>i(e)))})),e.validatePoR=async(e,t,r)=>{const n=await Ce(e,t);if(await He(r)!==n.exchange.poo_dgst)throw new Error("the hashed proof of origin received does not correspond to the poo_dgst parameter in the proof of origin");if(Date.now()-n.iat>5e3)throw new Error("timestamp error");return!0},Object.defineProperty(e,"__esModule",{value:!0})})); diff --git a/docs/interfaces/PoO.md b/docs/interfaces/PoO.md new file mode 100644 index 0000000..970d3e6 --- /dev/null +++ b/docs/interfaces/PoO.md @@ -0,0 +1,64 @@ +# Interface: PoO + +## Table of contents + +### Properties + +- [exchange](PoO.md#exchange) +- [iat](PoO.md#iat) +- [iss](PoO.md#iss) +- [sub](PoO.md#sub) + +## Properties + +### exchange + +• **exchange**: `Object` + +#### Type declaration + +| Name | Type | +| :------ | :------ | +| `block_commitment` | `string` | +| `block_desc` | `string` | +| `block_id` | `number` | +| `cipherblock_dgst` | `string` | +| `dest` | `string` | +| `hash_alg` | `string` | +| `id` | `number` | +| `key_commitment` | `string` | +| `orig` | `string` | + +#### Defined in + +[proofInterfaces.ts:19](https://gitlab.com/i3-market/code/wp3/t3.3/non-repudiable-exchange/non-repudiable-proofs/-/blob/a3055d8/src/ts/proofInterfaces.ts#L19) + +___ + +### iat + +• **iat**: `number` + +#### Defined in + +[proofInterfaces.ts:18](https://gitlab.com/i3-market/code/wp3/t3.3/non-repudiable-exchange/non-repudiable-proofs/-/blob/a3055d8/src/ts/proofInterfaces.ts#L18) + +___ + +### iss + +• **iss**: `string` + +#### Defined in + +[proofInterfaces.ts:16](https://gitlab.com/i3-market/code/wp3/t3.3/non-repudiable-exchange/non-repudiable-proofs/-/blob/a3055d8/src/ts/proofInterfaces.ts#L16) + +___ + +### sub + +• **sub**: `string` + +#### Defined in + +[proofInterfaces.ts:17](https://gitlab.com/i3-market/code/wp3/t3.3/non-repudiable-exchange/non-repudiable-proofs/-/blob/a3055d8/src/ts/proofInterfaces.ts#L17) diff --git a/docs/interfaces/PoR.md b/docs/interfaces/PoR.md new file mode 100644 index 0000000..5da7233 --- /dev/null +++ b/docs/interfaces/PoR.md @@ -0,0 +1,58 @@ +# Interface: PoR + +## Table of contents + +### Properties + +- [exchange](PoR.md#exchange) +- [iat](PoR.md#iat) +- [iss](PoR.md#iss) +- [sub](PoR.md#sub) + +## Properties + +### exchange + +• **exchange**: `Object` + +#### Type declaration + +| Name | Type | +| :------ | :------ | +| `exchangeId` | `number` | +| `hash_alg` | `string` | +| `poo_dgst` | `string` | + +#### Defined in + +[proofInterfaces.ts:35](https://gitlab.com/i3-market/code/wp3/t3.3/non-repudiable-exchange/non-repudiable-proofs/-/blob/a3055d8/src/ts/proofInterfaces.ts#L35) + +___ + +### iat + +• **iat**: `number` + +#### Defined in + +[proofInterfaces.ts:34](https://gitlab.com/i3-market/code/wp3/t3.3/non-repudiable-exchange/non-repudiable-proofs/-/blob/a3055d8/src/ts/proofInterfaces.ts#L34) + +___ + +### iss + +• **iss**: `string` + +#### Defined in + +[proofInterfaces.ts:32](https://gitlab.com/i3-market/code/wp3/t3.3/non-repudiable-exchange/non-repudiable-proofs/-/blob/a3055d8/src/ts/proofInterfaces.ts#L32) + +___ + +### sub + +• **sub**: `string` + +#### Defined in + +[proofInterfaces.ts:33](https://gitlab.com/i3-market/code/wp3/t3.3/non-repudiable-exchange/non-repudiable-proofs/-/blob/a3055d8/src/ts/proofInterfaces.ts#L33) diff --git a/types/createProofs.d.ts b/types/createProofs.d.ts new file mode 100644 index 0000000..a264fcb --- /dev/null +++ b/types/createProofs.d.ts @@ -0,0 +1,43 @@ +import { JWK, KeyLike } from 'jose'; +import { account } from './proofInterfaces'; +export declare const SIGNING_ALG = "ES256"; +export declare const ENC_ALG = "AES-GCM"; +export declare const ENC_ALG_KEY_LENGTH = 256; +/** + * + * Create Proof of Origin and sign with Provider private key + * + * @param privateKey - private key of the signer/issuer + * @param block - the blocks asdfsdfsd + * @param providerId + * @param consumerId + * @param exchangeId + * @param blockId + * @param jwk + * @returns + */ +declare const createPoO: (privateKey: KeyLike, block: ArrayBufferLike | string, providerId: string, consumerId: string, exchangeId: number, blockId: number, jwk: JWK) => Promise<{ + cipherblock: string; + poO: string; +}>; +/** + * Create a random (high entropy) symmetric JWK secret + * + * @returns a promise that resolves to a JWK + */ +declare const createJwk: () => Promise; +/** + * Sign a proof with private key + */ +declare const signProof: (privateKey: KeyLike, proof: any) => Promise; +/** + * Create Proof of Receipt and sign with Consumer private key + */ +declare const createPoR: (privateKey: KeyLike, poO: string, providerId: string, consumerId: string, exchangeId: number) => Promise; +/** + * + * Prepare block to be send to the Backplain API + */ +declare const createBlockchainProof: (publicKey: KeyLike, poO: string, poR: string, jwk: JWK) => Promise; +export { createJwk, createPoO, signProof, createPoR, createBlockchainProof }; +//# sourceMappingURL=createProofs.d.ts.map \ No newline at end of file diff --git a/types/createProofs.d.ts.map b/types/createProofs.d.ts.map new file mode 100644 index 0000000..83b8315 --- /dev/null +++ b/types/createProofs.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"createProofs.d.ts","sourceRoot":"","sources":["../src/ts/createProofs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuD,GAAG,EAAE,OAAO,EAAwC,MAAM,MAAM,CAAA;AAE9H,OAAO,EAAE,OAAO,EAAY,MAAM,mBAAmB,CAAA;AAGrD,eAAO,MAAM,WAAW,UAAU,CAAA;AAClC,eAAO,MAAM,OAAO,YAAY,CAAA;AAChC,eAAO,MAAM,kBAAkB,MAAM,CAAA;AAErC;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,SAAS,eAAsB,OAAO,SAAS,eAAe,GAAG,MAAM,cAAc,MAAM,cAAc,MAAM,cAAc,MAAM,WAAW,MAAM,OAAO,GAAG;iBAA0B,MAAM;SAAO,MAAM;EA8BhN,CAAA;AAED;;;;GAIG;AACH,QAAA,MAAM,SAAS,QAAa,QAAQ,GAAG,CAqBtC,CAAA;AAED;;GAEG;AACH,QAAA,MAAM,SAAS,eAAsB,OAAO,SAAS,GAAG,KAAG,QAAQ,MAAM,CAOxE,CAAA;AAED;;GAEG;AACH,QAAA,MAAM,SAAS,eAAsB,OAAO,OAAO,MAAM,cAAc,MAAM,cAAc,MAAM,cAAc,MAAM,KAAG,QAAQ,MAAM,CAgBrI,CAAA;AAED;;;GAGG;AACH,QAAA,MAAM,qBAAqB,cAAqB,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO,GAAG,KAAG,QAAQ,OAAO,CAoB5G,CAAA;AAyBD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,qBAAqB,EAAE,CAAA"} \ No newline at end of file diff --git a/types/index.d.ts b/types/index.d.ts new file mode 100644 index 0000000..d4ba57a --- /dev/null +++ b/types/index.d.ts @@ -0,0 +1,13 @@ +/** + * My module description. Please update with your module data. + * + * @remarks + * This module runs perfectly in node.js and browsers + * + * @packageDocumentation + */ +export { SIGNING_ALG, createJwk, createPoO, signProof, createPoR, createBlockchainProof } from './createProofs'; +export { account, PoO, PoR } from './proofInterfaces'; +export { validatePoR, validatePoO, validatePoP, decryptCipherblock, validateCipherblock, decodePoo, decodePor } from './validateProofs'; +export { sha } from './sha'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/types/index.d.ts.map b/types/index.d.ts.map new file mode 100644 index 0000000..fbb3820 --- /dev/null +++ b/types/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/ts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAC/G,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AACvI,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA"} \ No newline at end of file diff --git a/types/proofInterfaces.d.ts b/types/proofInterfaces.d.ts new file mode 100644 index 0000000..6edae31 --- /dev/null +++ b/types/proofInterfaces.d.ts @@ -0,0 +1,62 @@ +import types from 'jose'; +export interface DataExchange { + id: number; + orig?: string; + dest?: string; + block_id?: number; + block_desc?: string; + hash_alg: string; + cipherblock_dgst: string; + block_commitment: string; + key_commitment: string; +} +export interface PoO { + iss: string; + sub: string; + iat: number; + exchange: { + id: number; + orig: string; + dest: string; + block_id: number; + block_desc: string; + hash_alg: string; + cipherblock_dgst: string; + block_commitment: string; + key_commitment: string; + }; +} +export interface PoR { + iss: string; + sub: string; + iat: number; + exchange: { + poo_dgst: string; + hash_alg: string; + exchangeId: number; + }; +} +export interface account { + privateStorage: { + availability: string; + permissions: { + view: string[]; + }; + type: string; + id: number; + content: { + [block_id: number]: { + poO: string; + poR: string; + }; + }; + }; + blockchain: { + availability: string; + type: string; + content: { + [kid: string]: types.JWK; + }; + }; +} +//# sourceMappingURL=proofInterfaces.d.ts.map \ No newline at end of file diff --git a/types/proofInterfaces.d.ts.map b/types/proofInterfaces.d.ts.map new file mode 100644 index 0000000..1133b0e --- /dev/null +++ b/types/proofInterfaces.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"proofInterfaces.d.ts","sourceRoot":"","sources":["../src/ts/proofInterfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,CAAA;AAExB,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB,EAAE,MAAM,CAAA;IACxB,gBAAgB,EAAE,MAAM,CAAA;IACxB,cAAc,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,GAAG;IAClB,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE;QACR,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;QACZ,QAAQ,EAAE,MAAM,CAAA;QAChB,UAAU,EAAE,MAAM,CAAA;QAClB,QAAQ,EAAE,MAAM,CAAA;QAChB,gBAAgB,EAAE,MAAM,CAAA;QACxB,gBAAgB,EAAE,MAAM,CAAA;QACxB,cAAc,EAAE,MAAM,CAAA;KACvB,CAAA;CACF;AACD,MAAM,WAAW,GAAG;IAClB,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE;QACR,QAAQ,EAAE,MAAM,CAAA;QAChB,QAAQ,EAAE,MAAM,CAAA;QAChB,UAAU,EAAE,MAAM,CAAA;KACnB,CAAA;CACF;AACD,MAAM,WAAW,OAAO;IACtB,cAAc,EAAE;QACd,YAAY,EAAE,MAAM,CAAA;QACpB,WAAW,EAAE;YACX,IAAI,EAAE,MAAM,EAAE,CAAA;SACf,CAAA;QACD,IAAI,EAAE,MAAM,CAAA;QACZ,EAAE,EAAE,MAAM,CAAA;QACV,OAAO,EAAE;YACP,CAAC,QAAQ,EAAE,MAAM,GAAG;gBAClB,GAAG,EAAE,MAAM,CAAA;gBACX,GAAG,EAAE,MAAM,CAAA;aACZ,CAAA;SACF,CAAA;KACF,CAAA;IACD,UAAU,EAAE;QACV,YAAY,EAAE,MAAM,CAAA;QACpB,IAAI,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE;YACP,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,GAAG,CAAA;SACzB,CAAA;KACF,CAAA;CACF"} \ No newline at end of file diff --git a/types/sha.d.ts b/types/sha.d.ts new file mode 100644 index 0000000..a93dadc --- /dev/null +++ b/types/sha.d.ts @@ -0,0 +1,4 @@ +declare const sha: (input: string | Uint8Array, algorithm?: string) => Promise; +export { sha }; +export default sha; +//# sourceMappingURL=sha.d.ts.map \ No newline at end of file diff --git a/types/sha.d.ts.map b/types/sha.d.ts.map new file mode 100644 index 0000000..d0361ec --- /dev/null +++ b/types/sha.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"sha.d.ts","sourceRoot":"","sources":["../src/ts/sha.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,GAAG,UAA0B,MAAM,GAAC,UAAU,yBAA0B,QAAQ,MAAM,CAqB3F,CAAA;AACD,OAAO,EAAE,GAAG,EAAE,CAAA;AACd,eAAe,GAAG,CAAA"} \ No newline at end of file diff --git a/types/validateProofs.d.ts b/types/validateProofs.d.ts new file mode 100644 index 0000000..1c95edf --- /dev/null +++ b/types/validateProofs.d.ts @@ -0,0 +1,32 @@ +import { JWK, KeyLike } from 'jose'; +import { PoO, PoR } from './proofInterfaces'; +/** + * Validate Proof or Request using the Provider Public Key + */ +declare const validatePoR: (publicKey: KeyLike, poR: string, poO: string) => Promise; +/** + * Decode Proof of Reception with Consumer public key + */ +declare const decodePor: (publicKey: KeyLike, poR: string) => Promise; +/** + * Validate Proof or Origin using the Consumer Public Key + */ +declare const validatePoO: (publicKey: KeyLike, poO: string, cipherblock: string) => Promise; +/** + * Decode Proof of Origin with Provider public key + */ +declare const decodePoo: (publicKey: KeyLike, poO: string) => Promise; +/** + * Validate Proof of Publication using the Backplain Public Key + */ +declare const validatePoP: (publicKeyBackplain: KeyLike, publicKeyProvider: KeyLike, poP: string, jwk: JWK, poO: string) => Promise; +/** + * Decrypt the cipherblock received + */ +declare const decryptCipherblock: (chiperblock: string, jwk: JWK) => Promise; +/** + * Validate the cipherblock + */ +declare const validateCipherblock: (publicKey: KeyLike, chiperblock: string, jwk: JWK, poO: PoO) => Promise; +export { validatePoR, validatePoO, validatePoP, decryptCipherblock, validateCipherblock, decodePoo, decodePor }; +//# sourceMappingURL=validateProofs.d.ts.map \ No newline at end of file diff --git a/types/validateProofs.d.ts.map b/types/validateProofs.d.ts.map new file mode 100644 index 0000000..e97aa79 --- /dev/null +++ b/types/validateProofs.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"validateProofs.d.ts","sourceRoot":"","sources":["../src/ts/validateProofs.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4C,GAAG,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAE7E,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAA;AAK5C;;GAEG;AACH,QAAA,MAAM,WAAW,cAAqB,OAAO,OAAO,MAAM,OAAO,MAAM,KAAG,QAAQ,OAAO,CAWxF,CAAA;AAED;;GAEG;AACH,QAAA,MAAM,SAAS,cAAqB,OAAO,OAAO,MAAM,KAAG,QAAQ,GAAG,CAMrE,CAAA;AAED;;GAEG;AACH,QAAA,MAAM,WAAW,cAAqB,OAAO,OAAO,MAAM,eAAe,MAAM,KAAG,QAAQ,OAAO,CAWhG,CAAA;AAED;;GAEG;AACH,QAAA,MAAM,SAAS,cAAqB,OAAO,OAAO,MAAM,KAAG,QAAQ,GAAG,CAMrE,CAAA;AAED;;GAEG;AACH,QAAA,MAAM,WAAW,uBAAwB,OAAO,qBAAqB,OAAO,OAAO,MAAM,OAAO,GAAG,OAAO,MAAM,KAAG,QAAQ,OAAO,CAoBjI,CAAA;AAED;;GAEG;AACH,QAAA,MAAM,kBAAkB,gBAAuB,MAAM,OAAO,GAAG,KAAG,QAAQ,MAAM,CAM/E,CAAA;AAED;;GAEG;AACH,QAAA,MAAM,mBAAmB,cAAqB,OAAO,eAAe,MAAM,OAAO,GAAG,OAAO,GAAG,KAAG,QAAQ,OAAO,CAU/G,CAAA;AAED,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,SAAS,EAAE,SAAS,EAAE,CAAA"} \ No newline at end of file