diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000..35127bc --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,52 @@ +# Publishes @microsoft/msrcrypto to npm. +# +# Dormant until you cut a release: it runs only when a GitHub Release is +# published or a v* tag is pushed. It builds, verifies the package contents, +# then publishes with npm provenance (supply-chain attestation). +# +# Note: the QUnit suite (test/SubtleTests.html) is a manual, real-browser +# harness (it targets IE8+ behavior) and is intentionally not run here. +# +# Prerequisites (one-time, when you are ready to publish): +# - Add an npm automation token as the repository secret NPM_TOKEN, OR +# configure npm Trusted Publishing (OIDC) and drop the NODE_AUTH_TOKEN env. +# - The `id-token: write` permission below is required for --provenance. +name: Publish + +on: + release: + types: [published] + push: + tags: + - "v*" + +permissions: + contents: read + id-token: write # required for npm --provenance + +jobs: + publish: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v5 + + - name: Setup Node.js + uses: actions/setup-node@v5 + with: + node-version: 22 + registry-url: https://registry.npmjs.org + + - name: Install dependencies + run: npm ci + + - name: Build + run: npm run build + + - name: Verify package contents + run: npm pack --dry-run + + - name: Publish to npm + run: npm publish --provenance --access public + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} diff --git a/.gitignore b/.gitignore index c7cf211..ca2a032 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,8 @@ -# npm packages loaded on user's system +# Installed dependencies node_modules/ -# This gets re-built by gulp with each build. -scripts/subtle.js +# OS / editor artifacts +.DS_Store -/.history -/.DS_Store +# Local test comparison page +test/hmac-export-compare.html diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 21ac7c2..0000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "files.exclude": {}, - "cSpell.words": [ - "Ciphertext", - "HMAC", - "NIST", - "PRNG", - "Precomputation", - "bitlength", - "gctr", - "msrcrypto", - "qunit" - ] -} \ No newline at end of file diff --git a/.vscode/tasks.json b/.vscode/tasks.json deleted file mode 100644 index e3d1fd1..0000000 --- a/.vscode/tasks.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - // See https://go.microsoft.com/fwlink/?LinkId=733558 - // for the documentation about the tasks.json format - "version": "2.0.0", - "tasks": [ - { - "type": "gulp", - "task": "default", - "problemMatcher": [], - "group": { - "kind": "build", - "isDefault": true - } - }, - { - "type": "npm", - "script": "install", - "problemMatcher": [] - } - ] -} \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..f1bf574 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,125 @@ +# Changelog + +All notable changes to this project are documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [1.7.0] - 2026-06-26 + +### Breaking Changes + +- Errors for invalid input and unsupported algorithms are now delivered as a + rejected promise instead of being thrown synchronously. Code relying on a + synchronous `try`/`catch` around `SubtleCrypto` calls must move to + `.catch()`/`await`. +- Error objects changed shape: failures are now `DOMException`s with + specification names (e.g. `OperationError`, `DataError`) rather than plain + `Error`s. Code inspecting `error.message` or custom error fields may need to + switch to `error.name`. +- `getRandomValues` now throws `QuotaExceededError` for requests larger than + 65,536 bytes and `TypeMismatchError` for floating-point typed arrays, where + previously such calls may have succeeded. +- `generateKey` validation is stricter: AES rejects key lengths other than 128, + 192, or 256 bits, and HMAC interprets `length` as bits. Inputs accepted by + earlier versions may now be rejected. +- Built output moved from `lib/` to `dist/` and type declarations from + `definitions/` to `types/`. Imports by package name are unaffected, but deep + paths such as `@microsoft/msrcrypto/lib/...` must be updated. +- The minimum supported Node.js version is now 18. + +### Added + +- TypeScript declarations ([`types/msrCrypto.d.ts`](types/msrCrypto.d.ts)) were + rewritten to describe the library's own `MsrCrypto` surface and to resolve for + the `@microsoft/msrcrypto` import specifier (via `export =`). +- An `Errors` test module that asserts the public APIs reject/throw with the + correct error names, plus the previously-unwired `CryptoKey` test module. +- npm package metadata (`keywords`, `author`, `homepage`, `bugs`, `exports`, + `sideEffects`, `publishConfig`) and a `prepublishOnly` build guard. +- Dormant GitHub Actions release workflow that builds, verifies the package, + and publishes to npm with provenance on tagged releases. + +### Changed + +- `SubtleCrypto` algorithm parameters now accept a string `AlgorithmIdentifier` + (e.g. `"SHA-256"`) in addition to an object, matching the W3C Web Crypto spec. +- `SubtleCrypto` methods now surface invalid input and unsupported algorithms as + a rejected promise instead of throwing synchronously, per the Web Crypto + contract. Missing or wrong-type arguments reject with a `TypeError`. +- Errors raised by the library are now `DOMException`s with specification names + (`NotSupportedError`, `OperationError`, `InvalidAccessError`, `DataError`), + falling back to an `Error` carrying the name and legacy code on engines + without a `DOMException` constructor (e.g. IE8). +- `getRandomValues` now throws `QuotaExceededError` for requests larger than + 65,536 bytes and `TypeMismatchError` for floating-point typed arrays. +- The library version is now injected into the bundle from `package.json` at + build time, eliminating version drift between the package and the bundle. +- The build system was migrated to [esbuild](https://esbuild.github.io/) (driven + by `build.mjs`), producing the unminified and minified bundles, and the + minimum supported Node.js version was raised to 18. +- Repository layout: built output moved from `lib/` to `dist/`, type + declarations from `definitions/` to `types/`, and sources under `src/`. The + published `main`/`types` paths are resolved through `package.json`, so + installs via the package name are unaffected; only deep paths such as + `@microsoft/msrcrypto/lib/...` changed. + +### Fixed + +- HMAC `generateKey` now honors the optional `length` parameter correctly (bits, + not bytes) and zeroes the unused trailing bits of the final byte for + non-byte-aligned lengths, matching native Web Crypto behavior. +- AES `generateKey` (CBC, GCM, KW) now rejects key lengths other than 128, 192, + or 256 bits instead of accepting any multiple of 8. +- Removed a stray `console.log` that leaked exported key material during + `wrapKey`. +- Fixed an error in the worker result path that threw when assigning to the + read-only `DOMException.code` property. +- `SubtleCrypto.generateKey` for RSA algorithms now honors the requested key + usages (routing each usage to the public or private key it applies to) + instead of forcing a fixed pair. Generating an `RSA-OAEP` key with + `["wrapKey", "unwrapKey"]` now yields keys usable with `wrapKey`/`unwrapKey`. + +### Removed + +- Dead, unreachable `wrapKey.js` module (legacy JWE-style key wrapping that was + never dispatched) and its orphaned JWK byte-serializer helper. The public + `wrapKey`/`unwrapKey` continue to work via the standard + export-then-encrypt / decrypt-then-import path. + +## [1.6.0] + +- Automatic web-worker usage is disabled by default. When enabled, it may cause + problems when the library is bundled with other scripts. +- `raw` key import support for HMAC & ECDH. +- `spki` public key import for RSA. +- `wrapKey` support for AES-CBC, AES-GCM, RSA-OAEP. +- PBKDF2 key derivation algorithm. +- Additional side-channel protection. +- Moved source to GitHub. + +## [1.5.0] + +- Added support for streaming input/output data to crypto calls. +- Allow concurrent crypto calls of the same type at the same time. +- Added `raw` keyImport/keyExport format for HMAC, AES-CBC, AES-GCM. +- Added `IE11PromiseWrapper.js` to wrap the IE11 non-standard Web Crypto API so + it behaves like the current standard Promise-based API. +- Removed RSASSA-PKCS1-v1_5 encrypt/decrypt algorithm (obsolete, no longer + supported by modern browsers). +- Added TypeScript definitions (`msrCrypto.d.ts`). +- Moved the Promise polyfill outside of the library so the built-in browser + version can be used when available. + +## [1.4.0] + +- Updated the API to the latest Web Crypto API spec and modern browser + implementations. +- Promises are now supported; the IE11-style event callbacks were removed. This + is a breaking change for code using the pre-1.4 `onComplete`/`onError` + calling conventions. + +[1.7.0]: https://github.com/microsoft/MSR-JavaScript-Crypto/releases/tag/v1.7.0 +[1.6.0]: https://github.com/microsoft/MSR-JavaScript-Crypto/releases/tag/v1.6.0 +[1.5.0]: https://github.com/microsoft/MSR-JavaScript-Crypto/releases/tag/v1.5.0 +[1.4.0]: https://github.com/microsoft/MSR-JavaScript-Crypto/releases/tag/v1.4.0 diff --git a/README.md b/README.md index ba4c65c..aecda9d 100644 --- a/README.md +++ b/README.md @@ -22,10 +22,24 @@ var crypto = window.crypto /*native*/ || window.msCrypto /*IE11 native*/ || win crypto.subtle.encrypt(...); ``` +The library is exposed only under the name `msrCrypto`; it does **not** assign `crypto` or `CryptoKey` to the global scope automatically. +Some libraries (for example, [`jose`](https://github.com/panva/jose)) expect a top-level `CryptoKey` to be available and will fail to recognize keys if it is missing. +If you are using msrCrypto as a polyfill in an environment without native Web Crypto, assign both globals yourself: +```javascript +// Only install the polyfill where native Web Crypto is not available. +if (!window.crypto || !window.crypto.subtle) { + window.crypto = window.msrCrypto; // exposes crypto.subtle, crypto.getRandomValues, etc. + window.CryptoKey = window.msrCrypto.CryptoKey; // top-level CryptoKey constructor +} +``` +> Use `globalThis` instead of `window` in non-browser environments. + +Keys returned by `msrCrypto.subtle` are instances of `msrCrypto.CryptoKey`. Once `CryptoKey` is assigned to the global scope, `key instanceof CryptoKey` evaluates to `true`, which satisfies the polyfill detection used by consumers such as `jose`. + ## Library Files -Full library [`/lib/msrCrypto.js`](https://github.com/microsoft/MSR-JavaScript-Crypto/blob/master/lib/msrcrypto.js) -Minified library [`/lib/msrCrypto.min.js`](https://github.com/microsoft/MSR-JavaScript-Crypto/blob/master/lib/msrcrypto.min.js) +Full library [`/dist/msrcrypto.js`](https://github.com/microsoft/MSR-JavaScript-Crypto/blob/master/dist/msrcrypto.js) +Minified library [`/dist/msrcrypto.min.js`](https://github.com/microsoft/MSR-JavaScript-Crypto/blob/master/dist/msrcrypto.min.js) ## Supported Algorithms @@ -64,8 +78,8 @@ Supported ECC curves: >_While this library has npm build dependencies, it has no run-time dependencies._ -You may build the library from the source files. The library is built using [gulp](https://gulpjs.com/) from npm to concatenate many individual JavaScript files into a single library file. -Run `npm install` from a command terminal to install the required _npm_ packages. `gulpfile.js` contains a list of scripts included in the build. You may remove scripts to create a subset of the library that supports fewer algorithms. Be aware, many scripts have dependencies on other scripts to function properly. +You may build the library from the source files. The library is built using [esbuild](https://esbuild.github.io/) to concatenate many individual JavaScript files (in `src/`) into a single library file. +Run `npm install` from a command terminal to install the required _npm_ packages. The `fullBuild` list in `build.mjs` contains the scripts included in the build. You may remove scripts to create a subset of the library that supports fewer algorithms. Be aware, many scripts have dependencies on other scripts to function properly. #### Building from Visual Studio Code: >_These steps require that [git](https://git-scm.com/downloads), [Node.js](https://nodejs.org/en/), and [Visual Studio Code](https://code.visualstudio.com/) are installed on your system._ @@ -78,15 +92,15 @@ Run `npm install` from a command terminal to install the required _npm_ packages >Select menu `View->Command Palette...` (or `F1`) then enter `Developer: Reload Window` 5. Build the project: menu `View->Command Palette...` (or `F1`) then enter `Tasks: Run Build Task`. >Alternately you can use the _ctrl+shift+b_ keyboard shortcut. -6. The newly built library files will appear in the `lib` directory as `msrCrypto.js` and `msrCrypto.min.js`. +6. The newly built library files will appear in the `dist` directory as `msrcrypto.js` and `msrcrypto.min.js`. #### Building from the command line: >_These steps require that [git](https://git-scm.com/downloads) and [Node.js](https://nodejs.org/en/) are installed on your system._ 1. Clone the repo to a local folder `git clone https://github.com/microsoft/MSR-JavaScript-Crypto.git` 2. `cd MSR-JavaScript-Crypto` to enter the project directory. 3. `npm install` to install the required [Node.js](https://nodejs.org/en/) modules to the project's `node_modules` folder. -4. `node_modules\.bin\gulp` to build the library files. -5. The newly built library files will appear in the `lib` directory as `msrCrypto.js` and `msrCrypto.min.js`. +4. `npm run build` to build the library files. +5. The newly built library files will appear in the `dist` directory as `msrcrypto.js` and `msrcrypto.min.js`. ## Additional Utilities @@ -137,7 +151,7 @@ var data = new Uint8Array(dataArray); #### IE11 IE11 supports the Web Crypto API, but was based on a pre-release version of the spec and was never updated. So it uses event based calls instead of Promises and a few other quirks of the API. -In the `/lib` folder there is a `IE11PromiseWrapper.js` file. This shim can be loaded in IE11 and allow you to call the native Web Crypto API using the Promise based calling scheme. This shim also corrects some of the quirks in the IE11 API. +In the `/dist` folder there is a `IE11PromiseWrapper.js` file. This shim can be loaded in IE11 and allow you to call the native Web Crypto API using the Promise based calling scheme. This shim also corrects some of the quirks in the IE11 API. ## Random Number Generator (PRNG): @@ -163,84 +177,9 @@ A good source for documentation is: >msrCrypto uses identical calls as these documents with the addition of allowing both regular JavaScript Arrays and Typed-Arrays for data input and output. -## Updates - -#### Changes with version 1.6 - - Automatic web-worker usage is disabled by default. - When enabled, it may cause problems when the library is bundled with other scripts. - - raw key import support for HMAC & ECDH. - - spki public key import for RSA. - - wrapKey support for AES-CBC, AES-GCM, RSA-OAEP. - - PBKDF2 key derivation algorithm. - - Includes additional side-channel protection. - - Moved source to GitHub. - -#### Changes with version 1.5 - - Added support for streaming input/output data to crypto calls. - See Samples/StreamSample.html for an example on how to use this feature. - - Now allow concurrent crypto calls of the same type at the same time. Before, concurrent - crypto operations that shared code would possibly return incorrect results. - Now, for example, you could perform multiple encryptions at the same time with streaming. +## Changelog - Added 'raw' keyImport/keyExport format for hmac, AES-CBC, AES-GCM. - - Added IE11PromiseWrapper.js script to wrap the IE11 non-standard WebCrypto api and make - it function the same as current standard WebCrypto api. Your WebCrypto code should now - work with msrCrypto, IE11-WebCrypto, and the current standard WebCrypto with minimal - special case code. - - Removed RSASSA-PKCS1-v1_5 encrypt/decrypt algorithm. (considered less secure and obsolete) - It is no longer supported by WebCrypto in modern browsers. - - Added TypeScript d.ts file. msrCrypto.d.ts for using with type script. - - Moved the Promise polyfill outside of the msrCrypto library so you can use the built-in - browser version when available. - -#### Changes with version 1.4 - -The API has been updated to support the latest Web Crypto API spec and be compatible with the -implementation on the latest browsers. - -Promises are now supported and the IE11 based events are removed. Crypto calls are now in the -form: - -```javascript -// NEW STYLE with Promises -msrCrypto.subtle.encrypt().then( - function(encryptionResult) { - //... do something here with the result - }, - function(error) { - //... handle error - } -); -``` - -This will break code that uses the pre-1.4 calling conventions: -```javascript -// OLD STYLE with events (before version 1.4) -var cryptoOperation = msrCrypto.subtle.encrypt(); - -cryptoOperation.onComplete = - function(encryptionResult) { - //... do something here with the result - }; - -cryptoOperation.onError = - function(encryptionResult) { - //... handle error - }; -``` +See [CHANGELOG.md](CHANGELOG.md) for the history of notable changes across versions. ## Contributing diff --git a/build.mjs b/build.mjs new file mode 100644 index 0000000..60b688f --- /dev/null +++ b/build.mjs @@ -0,0 +1,383 @@ +// Build script for @microsoft/msrcrypto. +// +// Replaces the previous Gulp pipeline. Single dev dependency: esbuild. +// +// Pipeline: +// 1. Concatenate the full source list -> dist/msrcrypto.js +// - strip per-file leading license headers (avoid ~30 duplicate copies) +// - strip /* debug-block */ ... /* end-debug-block */ regions +// - prepend a single LICENSE header +// (the src/subtle/* files are concatenated inline, in order, so the +// msrcryptoSubtle IIFE scope is formed by head.js ... tail.js) +// 2. esbuild minify dist/msrcrypto.js -> dist/msrcrypto.min.js +// - target: es5 (source is ES5; refuse to introduce ES6+ syntax) +// - minifySyntax: false (preserves obj["catch"] form needed for IE8) +// +// Usage: npm run build +// npm run build -- --watch + +import * as esbuild from "esbuild"; +import { readFile, writeFile, rm, mkdir } from "node:fs/promises"; +import { existsSync } from "node:fs"; +import { dirname } from "node:path"; +import { performance } from "node:perf_hooks"; + +const LICENSE_FILE = "LICENSE"; +const FULL_BUNDLE_OUT = "dist/msrcrypto.js"; +const MIN_BUNDLE_OUT = "dist/msrcrypto.min.js"; + +// Single source of truth for the library version: package.json. The value is +// injected into the bundle at build time so the shipped msrCryptoVersion can +// never drift from the published package version. +const PKG_VERSION = JSON.parse(await readFile("package.json", "utf8")).version; +const VERSION_RE = /var msrCryptoVersion = "[^"]*";/; + +const fullBuild = [ + "src/bundleHead.js", + "src/operations.js", + "src/global.js", + "src/utilities.js", + "src/asn1.js", + "src/worker.js", + "src/jwk.js", + "src/cryptoMath.js", + "src/cryptoECC.js", + "src/curves_NIST.js", + "src/curves_BN.js", + "src/curves_NUMS.js", + "src/sha.js", + "src/sha1.js", + "src/sha256.js", + "src/sha512.js", + "src/hmac.js", + "src/aes.js", + "src/aes-cbc.js", + "src/aes-gcm.js", + "src/aes-kw.js", + "src/random.js", + "src/entropy.js", + "src/prime.js", + "src/rsa-base.js", + "src/rsa-oaep.js", + "src/rsa-pkcs1.js", + "src/rsa-pss.js", + "src/rsa.js", + "src/concat.js", + "src/pbkdf2.js", + "src/hkdf.js", + "src/hkdf-ctr.js", + "src/ecdh.js", + "src/ecdsa.js", + "src/subtle/head.js", + "src/subtle/syncWorker.js", + "src/subtle/operations.js", + "src/subtle/keyManager.js", + "src/subtle/workerManager.js", + "src/subtle/subtleInterface.js", + "src/subtle/tail.js", + "src/bundleTail.js", + "src/subtle/promises.js", +]; + +const DEBUG_BLOCK_RE = + /\/\*\s*debug-block\s*\*\/[\s\S]*?\/\*\s*end-debug-block\s*\*\//g; + +// Strip all comments from source (replicates gulp-strip-comments behaviour). +// Handles // line comments, /* block comments */, string literals, and +// regex literals — so it does not accidentally strip comment-like text +// inside those constructs (e.g. /https?:\/\//). +// +// Regex-vs-division disambiguation: a bare / is a regex literal start when +// the previous significant (non-whitespace) character is NOT one that can +// end a primary expression (identifier, digit, ), ]). This heuristic is +// standard and correct for all ES5 patterns found in this codebase. +function stripAllComments(src) { + let out = ""; + let i = 0; + const n = src.length; + var prevSig = ""; // last non-whitespace character written to output + + function isOutAtLineStart() { + var p = out.length - 1; + while (p >= 0 && (out[p] === " " || out[p] === "\t" || out[p] === "\r")) { + p--; + } + return p < 0 || out[p] === "\n"; + } + + function trimOutLineIndent() { + while (out.length > 0) { + var ch = out[out.length - 1]; + if (ch === " " || ch === "\t" || ch === "\r") { + out = out.slice(0, out.length - 1); + } else { + break; + } + } + } + + while (i < n) { + var c = src[i]; + + if (c === "/" && i + 1 < n) { + // Block comment + if (src[i + 1] === "*") { + var bEnd = src.indexOf("*/", i + 2); + var bNext = bEnd === -1 ? n : bEnd + 2; + if (bNext < n && isOutAtLineStart()) { + var bi = bNext; + while (bi < n && (src[bi] === " " || src[bi] === "\t" || src[bi] === "\r")) { + bi++; + } + if (bi < n && src[bi] === "\n") { + trimOutLineIndent(); + i = bi + 1; + continue; + } + } + i = bNext; + continue; + } + // Line comment + if (src[i + 1] === "/") { + var lEnd = src.indexOf("\n", i + 2); + if (lEnd === -1) { + i = n; + continue; + } + if (isOutAtLineStart()) { + trimOutLineIndent(); + i = lEnd + 1; + continue; + } + i = lEnd; // keep newline for end-of-line comments after code + continue; + } + // Regex literal when previous significant char cannot end an expression + if (!/[a-zA-Z0-9_$)\]]/.test(prevSig)) { + out += c; i++; // opening / + while (i < n) { + var rc = src[i]; + if (rc === "\\") { // escape sequence + out += rc; i++; + if (i < n) { out += src[i++]; } + continue; + } + if (rc === "[") { // character class [...] + out += rc; i++; + while (i < n) { + var cc = src[i]; + out += cc; i++; + if (cc === "\\") { if (i < n) { out += src[i++]; } continue; } + if (cc === "]") break; + } + continue; + } + out += rc; i++; + if (rc === "/") break; // closing / + } + // consume regex flags (g i m y) + while (i < n && /[gimy]/.test(src[i])) { out += src[i++]; } + prevSig = "/"; + continue; + } + // Otherwise: division operator — fall through to default + } + + // String literals + if (c === '"' || c === "'") { + var q = c; + out += c; i++; + while (i < n) { + var sc = src[i]; + out += sc; i++; + if (sc === "\\") { if (i < n) { out += src[i++]; } continue; } + if (sc === q) break; + } + prevSig = q; + continue; + } + + out += c; i++; + if (c !== " " && c !== "\t" && c !== "\r" && c !== "\n") prevSig = c; + } + return out; +} + +// Remove trailing horizontal whitespace and collapse long runs of blank lines +// introduced by comment stripping. +function collapseEmptyLines(src) { + return src + .replace(/[ \t]+\n/g, "\n") + .replace(/\n{3,}/g, "\n\n") + .replace(/\n+$/, "\n"); +} + +// Remove only the LEADING comment block(s) from a source file. +// This drops the per-file license header without touching inline comments, +// strings, or regex literals further down. Safe for ES5 sources. +// Also skips a leading UTF-8 BOM (U+FEFF) — 37 of the source files in this +// repo start with one, and without skipping it the loop bails out before +// reaching the comment that follows. +function stripLeadingComments(src) { + let i = 0; + const n = src.length; + while (i < n) { + const c = src[i]; + if (c === " " || c === "\t" || c === "\r" || c === "\n" || c === "\uFEFF") { + i++; + continue; + } + if (c === "/" && src[i + 1] === "*") { + const end = src.indexOf("*/", i + 2); + if (end === -1) break; + i = end + 2; + continue; + } + if (c === "/" && src[i + 1] === "/") { + const end = src.indexOf("\n", i + 2); + i = end === -1 ? n : end + 1; + continue; + } + break; + } + return src.slice(i); +} + +async function concatFiles(files, { stripHeader } = { stripHeader: true }) { + const parts = await Promise.all( + files.map(async (f) => { + let text = await readFile(f, "utf8"); + // Strip BOM unconditionally — embedded BOMs in the middle of a + // concatenated bundle are invalid as a token. + if (text.charCodeAt(0) === 0xfeff) text = text.slice(1); + return stripHeader ? stripLeadingComments(text) : text; + }), + ); + return parts.join("\n"); +} + +async function ensureDir(path) { + const dir = dirname(path); + if (!existsSync(dir)) { + await mkdir(dir, { recursive: true }); + } +} + +async function cleanOutputs() { + for (const f of [FULL_BUNDLE_OUT, MIN_BUNDLE_OUT]) { + if (existsSync(f)) { + await rm(f, { force: true }); + } + } +} + +function fmtBytes(n) { + if (n < 1024) return `${n} B`; + if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`; + return `${(n / 1024 / 1024).toFixed(2)} MB`; +} + +async function build() { + const t0 = performance.now(); + + const license = await readFile(LICENSE_FILE, "utf8"); + + // 1. dist/msrcrypto.js — full UMD bundle. + let fullBundle = await concatFiles(fullBuild); + fullBundle = fullBundle.replace(DEBUG_BLOCK_RE, ""); + fullBundle = stripAllComments(fullBundle); + fullBundle = collapseEmptyLines(fullBundle); + // Inject the package.json version so the bundle's msrCryptoVersion always + // matches the published package version. + if (!VERSION_RE.test(fullBundle)) { + throw new Error("build: could not find msrCryptoVersion declaration to inject version"); + } + fullBundle = fullBundle.replace(VERSION_RE, `var msrCryptoVersion = "${PKG_VERSION}";`); + fullBundle = license + "\n" + fullBundle; + await ensureDir(FULL_BUNDLE_OUT); + await writeFile(FULL_BUNDLE_OUT, fullBundle); + + // 2. dist/msrcrypto.min.js — minified. + // minifySyntax is intentionally OFF so esbuild does not rewrite + // obj["catch"] to obj.catch (catch is a reserved word on IE8). + const minified = await esbuild.transform(fullBundle, { + loader: "js", + target: "es5", + minifyWhitespace: true, + minifyIdentifiers: true, + minifySyntax: false, + legalComments: "none", + charset: "utf8", + }); + await writeFile(MIN_BUNDLE_OUT, license + "\n" + minified.code); + + const t1 = performance.now(); + + const sizes = await Promise.all( + [FULL_BUNDLE_OUT, MIN_BUNDLE_OUT].map(async (f) => { + const buf = await readFile(f); + return { file: f, bytes: buf.length }; + }), + ); + + console.log(`built in ${(t1 - t0).toFixed(0)} ms (v${PKG_VERSION})`); + for (const s of sizes) { + console.log(` ${s.file.padEnd(24)} ${fmtBytes(s.bytes)}`); + } +} + +async function watch() { + const { watch: fsWatch } = await import("node:fs"); + const all = new Set([...fullBuild, LICENSE_FILE]); + let timer = null; + const rebuild = () => { + clearTimeout(timer); + timer = setTimeout(() => { + build().catch((err) => console.error(err)); + }, 50); + }; + await build(); + console.log("watching for changes..."); + + // Keep references to every FSWatcher so they are not garbage-collected + // and stay active for the lifetime of the process. + const watchers = []; + + for (const f of all) { + try { + watchers.push(fsWatch(f, rebuild)); + } catch { + // file may not exist yet — that's fine + } + } + + // Also watch the directories that contain source files so newly-added + // files trigger rebuilds. fs.watch({ recursive: true }) is not supported + // on all platforms (notably Linux), where it throws — fall back to a + // non-recursive watch on the src directory in that case. The per-file + // watchers above still cover every file in the build list either way. + try { + watchers.push(fsWatch("src", { recursive: true }, rebuild)); + } catch { + try { + watchers.push(fsWatch("src", rebuild)); + } catch { + // src may not be watchable — per-file watchers still apply + } + } + + return watchers; +} + +const args = process.argv.slice(2); +if (args.includes("--clean")) { + await cleanOutputs(); + console.log("cleaned build outputs"); +} else if (args.includes("--watch")) { + await cleanOutputs(); + await watch(); +} else { + await cleanOutputs(); + await build(); +} diff --git a/definitions/IE11PromiseWrapper.d.ts b/definitions/IE11PromiseWrapper.d.ts deleted file mode 100644 index 879cf83..0000000 --- a/definitions/IE11PromiseWrapper.d.ts +++ /dev/null @@ -1,4 +0,0 @@ -declare module "IE11PromiseWrapper" { - var ieE11PromiseWrapper: Crypto /*lib.d.ts*/ - export = ieE11PromiseWrapper; -} \ No newline at end of file diff --git a/definitions/msrCrypto.d.ts b/definitions/msrCrypto.d.ts deleted file mode 100644 index 5757255..0000000 --- a/definitions/msrCrypto.d.ts +++ /dev/null @@ -1,34 +0,0 @@ -// Crypto from lib.d.ts -declare module "msrCrypto" { - var msrCrypto: Crypto; - export = msrCrypto; -} - -// Extend default Crypto from lib.d.ts to add msrCrypto extras -interface Crypto { - initPrng(entropyData: ArrayLike): void; - toBase64(data: ArrayLike | ArrayBuffer, toBase64Url?: boolean): string; - fromBase64(data: string): ArrayLike; - textToBytes(text: string): ArrayLike; - bytesToText(bytes: ArrayLike): String; -} - -// Extend default Algorithm from lib.d.ts -//interface Algorithm { -// salt?: ArrayLike, -// namedCurve?: string, -// iv?: ArrayLike, -// tagLength?: number, -// additionalData?: ArrayLike, -// hash?: { name: string }, -// length?: number, -// stream?: boolean -//} - -// Support msrCrypto streaming with new StreamObject -interface StreamObject { - process(data: ArrayBuffer | ArrayLike): PromiseLike | void>; - finish(): PromiseLike>; - abort(): PromiseLike; -} - diff --git a/definitions/msrcrypto.intellisense.js b/definitions/msrcrypto.intellisense.js deleted file mode 100644 index 9f9e1c9..0000000 --- a/definitions/msrcrypto.intellisense.js +++ /dev/null @@ -1,305 +0,0 @@ -//******************************************************************************* -// -// Copyright 2020 Microsoft -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -//******************************************************************************* - -// tslint:disable: max-line-length - -intellisense.annotate(msrCrypto.subtle.encrypt, function(algorithm, keyHandle, buffer) { - /// - /// Encrypt a UInt8Array of data. Encrypt will return an ArrayBuffer if supported, otherwise it will return a regular Array. - /// - /// - /// UInt8Array - /// - /// - /// - /// Encrypt an array of bytes. Encrypt will return an ArrayBuffer if supported, otherwise it will return a regular Array. - /// - /// - /// An array of bytes (number from 0-255) - /// - /// - /// - /// Encrypt an array of bytes. Encrypt will return an ArrayBuffer if supported, otherwise it will return a regular Array. - /// - /// - /// A continuous array of bytes (number values from 0-255) - /// - /// -}); - -intellisense.annotate(msrCrypto.subtle.decrypt, function(algorithm, keyHandle, buffer) { - /// - /// Decrypt a UInt8Array of data. - /// Decrypt will return an ArrayBuffer if supported, otherwise it will return an Array of byte values (numbers from 0-255) - /// - /// - /// UInt8Array - /// - /// - /// - /// Decrypt an array of byte values. Decrypt will return an ArrayBuffer if supported, otherwise it will return a regular Array. - /// - /// - /// An array of bytes values (numbers from 0-255) - /// - /// -}); - -intellisense.annotate(msrCrypto.subtle.sign, function(algorithm, keyHandle, buffer) { - /// - /// Sign a UInt8Array of data. - /// Sign will return a signature as an ArrayBuffer if supported, otherwise it will return an Array of byte values (numbers from 0-255) - /// - /// - /// UInt8Array - /// - /// - /// - /// Sign an array of byte values. Sign will return an ArrayBuffer if supported, otherwise it will return a regular Array. - /// - /// - /// An array of bytes values (numbers from 0-255) - /// - /// -}); - -intellisense.annotate(msrCrypto.subtle.verify, function(algorithm, keyHandle, signature, buffer) { - /// - /// Verify a signature. - /// - /// - /// UInt8Array - /// UInt8Array - /// - /// - /// - /// Verify a signature. - /// - /// - /// UInt8Array - /// An array of bytes values (numbers from 0-255) - /// - /// - /// - /// Verify a signature. - /// - /// - /// An array of bytes values (numbers from 0-255) - /// An array of bytes values (numbers from 0-255) - /// - /// - /// - /// Verify a signature. - /// - /// - /// An array of bytes values (numbers from 0-255) - /// UInt8Array - /// - /// -}); - -intellisense.annotate(msrCrypto.subtle.digest, function(algorithm, buffer) { - /// - /// Digest data using a specified cryptographic hash algorithm - /// - /// UInt8Array - /// - /// - /// - /// Digest data using a specified cryptographic hash algorithm - /// - /// An array of bytes values (numbers from 0-255) - /// - /// -}); - -intellisense.annotate(msrCrypto.subtle.generateKey, function(algorithm, extractable, keyUsage) { - /// - /// Generate a new key for use with the algorithm specified by the algorithm parameter - /// - /// - /// - /// - /// -}); - -intellisense.annotate(msrCrypto.subtle.deriveKey, function(algorithm, baseKey, derivedKeyType, extractable, keyUsage) { - /// - /// Generate a key for the specified derivedKeyType, using the specified cryptographic key derivation algorithm with the given baseKey as input. - /// - /// - /// - /// - /// - /// - /// -}); - -intellisense.annotate(msrCrypto.subtle.deriveBits, function(algorithm, baseKey, length) { - /// - /// Generate an array of bytes from a given baseKey as input. - /// - /// - /// Number of bytes to return. - /// - /// -}); - -intellisense.annotate(msrCrypto.subtle.importKey, function(format, keyData, algorithm, extractable, keyUsage) { - /// - /// Constructs a new Key object using the key data specified by the keyData parameter. - /// - /// An array of bytes values (numbers from 0-255) - /// - /// - /// - /// - /// - /// - /// Constructs a new Key object using the key data specified by the keyData parameter. - /// - /// - /// - /// - /// - /// - /// -}); - -intellisense.annotate(msrCrypto.subtle.exportKey, function(format, keyHandle) { - /// - /// Exports the given key material of the Key object as specified by the key parameter. - /// - /// - /// - /// - - // Export is one of the few calls where the caller does not supply an algorithm - // since it's already part of the key to be exported. - // So, we're pulling out of the key and adding it to the parameter set since - // it's used as a switch to route the parameters to the right function. - // Now we don't have to treat this as a special case in the underlying code. -}); - -intellisense.annotate(msrCrypto.subtle.wrapKey, function(format, key, wrappingKey, wrappingKeyAlgorithm) { - /// - /// Returns a KeyOperation object which will asynchronously return an array containing the key material of key, encrypted with keyEncryptionKey using the specified keyWrappingAlgorithm. - /// - /// - /// - /// - /// - /// -}); - -intellisense.annotate(msrCrypto.subtle.unwrapKey, function(wrappedKey, keyAlgorithm, keyEncryptionKey, extractable, keyUsage) { - /// - /// Construct a Key object from encrypted key material. - /// An array of bytes values (numbers from 0-255) - /// - /// - /// - /// - /// - /// - /// - /// Construct a Key object from encrypted key material. - /// - /// - /// - /// - /// - /// - /// -}); - -intellisense.annotate(msrCrypto.toBase64, function(data, toBase64Url) { - /// - /// Convert Array of bytes to a Base64 string. - /// Byte values (numbers 0-255) - /// Return Base64Url encoding (this is different from Base64 encoding.) - /// - /// - /// - /// Convert Array of bytes to a Base64 string. - /// Byte values (numbers 0-255) - /// Return Base64Url encoding (this is different from Base64 encoding.) - /// - /// - /// - /// Convert Array of bytes to a Base64 string. - /// Byte values (numbers 0-255) - /// Return Base64Url encoding (this is different from Base64 encoding.) - /// - /// -}); - -intellisense.annotate(msrCrypto.fromBase64, function(base64String) { - /// - /// Decode a Base64/Base64Url encoded string to an Array of bytes. - /// Base64 encoded string. - /// - /// -}); - -intellisense.annotate(msrCrypto.textToBytes, function(text) { - /// - /// Convert UTF-8/ASCII to an Array of bytes. - /// UTF-8/ASCII text - /// - /// -}); - -intellisense.annotate(msrCrypto.bytesToText, function(byteArray) { - /// - /// Convert an Array of bytes to UTF-8/ASCII text. - /// Array of bytes. - /// - /// - /// - /// Convert an Array of bytes to UTF-8/ASCII text. - /// Array of bytes. - /// - /// - /// - /// Convert an Array of bytes to UTF-8/ASCII text. - /// Array of bytes. - /// - /// -}); - -intellisense.annotate(msrCrypto.getRandomValues, function(array) { - /// - /// Places cryptographically random values into the given array. - /// - /// - /// - /// - /// Places cryptographically random values into the given array. - /// - /// Returns ArrayBufferView if supported. - /// - -}); - -intellisense.annotate(msrCrypto.initPrng, function(array) { - /// - /// Add entropy to the PRNG. - /// Entropy input to seed or reseed the PRNG. - /// -}); diff --git a/lib/IE11PromiseWrapper.js b/dist/IE11PromiseWrapper.js similarity index 100% rename from lib/IE11PromiseWrapper.js rename to dist/IE11PromiseWrapper.js diff --git a/dist/msrcrypto.js b/dist/msrcrypto.js new file mode 100644 index 0000000..c215a97 --- /dev/null +++ b/dist/msrcrypto.js @@ -0,0 +1,10141 @@ +//******************************************************************************* +// +// Copyright 2020 Microsoft +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//******************************************************************************* + +"use strict"; + +var msrCryptoVersion = "1.7.0"; + +(function(root, factory) { + + if (typeof define === "function" && define.amd) { + define([], function() { + return (root.msrCrypto = factory(root)); + }); + } else if (typeof exports === "object") { + module.exports = factory(root); + } else { + root.msrCrypto = factory(root); + } + +}(this, function(global) { + + global = global || {}; + + var msrCrypto = function() { + +var operations = {}; + +operations.register = function(operationType, algorithmName, functionToCall) { + + if (!Object.prototype.hasOwnProperty.call(operations, operationType) || + typeof operations[operationType] !== "object") { + operations[operationType] = {}; + } + + var op = operations[operationType]; + + if (!Object.prototype.hasOwnProperty.call(op, algorithmName)) { + op[algorithmName] = functionToCall; + } + +}; + +operations.exists = function(operationType, algorithmName) { + if (!Object.prototype.hasOwnProperty.call(operations, operationType) || + typeof operations[operationType] !== "object") { + return false; + } + + var op = operations[operationType]; + + return Object.prototype.hasOwnProperty.call(op, algorithmName) && + typeof op[algorithmName] === "function"; +}; + +var scriptUrl = (function() { + + if (typeof document !== "undefined") { + try { + throw new Error(); + } catch (e) { + if (e.stack) { + var match = /\w+:\/\/(?:[^/\s]+\/)*[^/\s]*\.js/.exec(e.stack); + return (match && match.length > 0) ? match[0] : null; + } + } + } else if (typeof self !== "undefined" && typeof self.location !== "undefined") { + return self.location.href; + } + + return null; + + +})(); + +var fprngEntropyProvided = false; + +var webWorkerSupport = (typeof Worker !== "undefined"); + +var runningInWorkerInstance = typeof importScripts === "function" && self instanceof WorkerGlobalScope; + +var workerInitialized = false; + +var typedArraySupport = (typeof ArrayBuffer !== "undefined"); + +var setterSupport = (function() { + try { + Object.defineProperty({}, "oncomplete", {}); + return true; + } catch (ex) { + return false; + } +}()); + +var asyncMode = false; + +var createProperty = function(parentObject, propertyName, initialValue, getterFunction, setterFunction) { + + if (!setterSupport) { + parentObject[propertyName] = initialValue; + return; + } + + var setGet = {}; + + getterFunction && (setGet.get = getterFunction); + setterFunction && (setGet.set = setterFunction); + + Object.defineProperty( + parentObject, + propertyName, setGet); +}; + +var msrcryptoHashFunctions = {}; + +var cryptoKeyInternalToken = {}; + +function CryptoKey(token, keyHandle) { + + if (token !== cryptoKeyInternalToken) { + throw new Error("Illegal constructor"); + } + + for (var property in keyHandle) { + if (keyHandle.hasOwnProperty(property)) { + this[property] = keyHandle[property]; + } + } +} + +var msrcryptoUtilities = (function() { + + var encodingChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; + + function consoleLog(text) { + if ("console" in self && "log" in console) { console.log(text); } + } + + function toBase64(data, base64Url) { + + var dataType = getObjectType(data); + + if (dataType !== "Array" && dataType !== "Uint8Array" && dataType !== "ArrayBuffer") { + throw new Error("invalid input"); + } + + var output = ""; + var input = toArray(data); + + if (!base64Url) { + base64Url = false; + } + + var char1, char2, char3, enc1, enc2, enc3, enc4; + var i; + + for (i = 0; i < input.length; i += 3) { + + char1 = input[i]; + char2 = input[i + 1]; + char3 = input[i + 2]; + + + enc1 = char1 >> 2; + enc2 = ((char1 & 0x3) << 4) | (char2 >> 4); + enc3 = ((char2 & 0xF) << 2) | (char3 >> 6); + enc4 = char3 & 0x3F; + + if (isNaN(char2)) { + enc3 = enc4 = 64; + + } else if (isNaN(char3)) { + enc4 = 64; + } + + output = output + + encodingChars.charAt(enc1) + + encodingChars.charAt(enc2) + + encodingChars.charAt(enc3) + + encodingChars.charAt(enc4); + + } + + if (base64Url) { + return output.replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, ""); + } + + return output; + } + + function base64ToBytes(encodedString) { + + encodedString = encodedString.replace(/-/g, "+").replace(/_/g, "/"); + + while (encodedString.length % 4 !== 0) { + encodedString += "="; + } + + var output = []; + var char1, char2, char3; + var enc1, enc2, enc3, enc4; + var i; + + encodedString = encodedString.replace(/[^A-Za-z0-9\+\/\=]/g, ""); + + for (i = 0; i < encodedString.length; i += 4) { + + enc1 = encodingChars.indexOf(encodedString.charAt(i)); + enc2 = encodingChars.indexOf(encodedString.charAt(i + 1)); + enc3 = encodingChars.indexOf(encodedString.charAt(i + 2)); + enc4 = encodingChars.indexOf(encodedString.charAt(i + 3)); + + + char1 = (enc1 << 2) | (enc2 >> 4); + char2 = ((enc2 & 15) << 4) | (enc3 >> 2); + char3 = ((enc3 & 3) << 6) | enc4; + + output.push(char1); + + if (enc3 !== 64) { + output.push(char2); + } + + if (enc4 !== 64) { + output.push(char3); + } + + } + + return output; + + } + + function getObjectType(object) { + + return Object.prototype.toString.call(object).slice(8, -1); + } + + function bytesToHexString(bytes, separate) { + + var result = ""; + if (typeof separate === "undefined") { + separate = false; + } + + for (var i = 0; i < bytes.length; i++) { + + if (separate && (i % 4 === 0) && i !== 0) { + result += "-"; + } + + var hexval = bytes[i].toString(16).toUpperCase(); + if (hexval.length === 1) { + result += "0"; + } + + result += hexval; + } + + return result; + } + + function bytesToInt32(bytes, index) { + index = (index || 0); + + return (bytes[index] << 24) | + (bytes[index + 1] << 16) | + (bytes[index + 2] << 8) | + bytes[index + 3]; + } + + function hexToBytesArray(hexString) { + + hexString = hexString.replace(/\-/g, ""); + + var result = []; + while (hexString.length >= 2) { + result.push(parseInt(hexString.substring(0, 2), 16)); + hexString = hexString.substring(2, hexString.length); + } + + return result; + } + + function clone(object) { + + var newObject = {}; + for (var propertyName in object) { + if (object.hasOwnProperty(propertyName)) { + newObject[propertyName] = object[propertyName]; + } + } + return newObject; + } + + function unpackData(base64String, arraySize, toUint32s) { + + var bytes = base64ToBytes(base64String), + data = [], + i; + + if (isNaN(arraySize)) { + return bytes; + } else { + for (i = 0; i < bytes.length; i += arraySize) { + data.push(bytes.slice(i, i + arraySize)); + } + } + + if (toUint32s) { + for (i = 0; i < data.length; i++) { + data[i] = (data[i][0] << 24) + (data[i][1] << 16) + (data[i][2] << 8) + data[i][3]; + } + } + + return data; + } + + function int32ToBytes(int32) { + return [(int32 >>> 24) & 255, (int32 >>> 16) & 255, (int32 >>> 8) & 255, int32 & 255]; + } + + function int32ArrayToBytes(int32Array) { + + var result = []; + for (var i = 0; i < int32Array.length; i++) { + result = result.concat(int32ToBytes(int32Array[i])); + } + return result; + } + + function xorVectors(a, b, res) { + + var length = Math.min(a.length, b.length), + res = res || new Array(length); + for (var i = 0; i < length; i += 1) { + res[i] = a[i] ^ b[i]; + } + return res; + } + + function getVector(length, fillValue) { + + if (isNaN(fillValue)) { fillValue = 0; } + + var res = new Array(length); + for (var i = 0; i < length; i += 1) { + res[i] = fillValue; + } + return res; + } + + function toArray(typedArray) { + + if (!typedArray) { + return []; + } + + if (typedArray.pop) { + return typedArray; + } + + if (getObjectType(typedArray) === "ArrayBuffer") { + typedArray = new Uint8Array(typedArray); + } else if (typedArray.BYTES_PER_ELEMENT > 1) { + typedArray = new Uint8Array(typedArray.buffer); + } + + if (typedArray.length === 1) { return [typedArray[0]]; } + + if (typedArray.length < 65536) { return Array.apply(null, typedArray); } + + var returnArray = new Array(typedArray.length); + for (var i = 0; i < typedArray.length; i++) { + returnArray[i] = typedArray[i]; + } + + return returnArray; + + } + + function padEnd(array, value, finalLength) { + + while (array.length < finalLength) { + array.push(value); + } + + return array; + } + + function padFront(array, value, finalLength) { + + while (array.length < finalLength) { + array.unshift(value); + } + + return array; + } + + function arraysEqual(array1, array2) { + + var result = true; + + if (array1.length !== array2.length) { + result = false; + } + + for (var i = 0; i < array1.length; i++) { + if (array1[i] !== array2[i]) { + result = false; + } + } + + return result; + } + + function indexOf(array, searchElement, fromIndex) { + + var length = array.length >>> 0; + var start = fromIndex | 0; + + if (start < 0) { + start = Math.max(length + start, 0); + } + + for (; start < length; start += 1) { + if (array[start] === searchElement) { + return start; + } + } + + return -1; + } + + function verifyByteArray(array) { + + if (getObjectType(array) !== "Array") { + return false; + } + + var element; + + for (var i = 0; i < array.length; i++) { + + element = array[i]; + + if (isNaN(element) || element < 0 || element > 255) { + return false; + } + } + + return true; + } + + function checkParam(param, type, errorMessage) { + + if (!param) { + throw new Error(errorMessage); + } + + if (type && (getObjectType(param) !== type)) { + throw new Error(errorMessage); + } + + return true; + } + + function stringToBytes(text) { + + var encodedBytes = []; + + for (var i = 0, j = 0; i < text.length; i++) { + + var charCode = text.charCodeAt(i); + + if (charCode < 128) { + encodedBytes[j++] = charCode; + + } else if (charCode < 2048) { + encodedBytes[j++] = (charCode >>> 6) | 192; + encodedBytes[j++] = (charCode & 63) | 128; + + } else if (charCode < 0xD800 || charCode > 0xDFFF) { + encodedBytes[j++] = (charCode >>> 12) | 224; + encodedBytes[j++] = ((charCode >>> 6) & 63) | 128; + encodedBytes[j++] = (charCode & 63) | 128; + + } else { + charCode = ((charCode - 0xD800) * 0x400) + (text.charCodeAt(++i) - 0xDC00) + 0x10000; + encodedBytes[j++] = (charCode >>> 18) | 240; + encodedBytes[j++] = ((charCode >>> 12) & 63) | 128; + encodedBytes[j++] = (charCode >>> 6) & 63 | 128; + encodedBytes[j++] = (charCode & 63) | 128; + } + } + + return encodedBytes; + } + + function bytesToString(textBytes) { + + var result = "", + charCode; + + textBytes = toArray(textBytes); + + for (var i = 0; i < textBytes.length;) { + + var encodedChar = textBytes[i++]; + + if (encodedChar < 128) { + charCode = encodedChar; + + } else if (encodedChar < 224) { + charCode = (encodedChar << 6) + textBytes[i++] - 0x3080; + + } else if (encodedChar < 240) { + charCode = + (encodedChar << 12) + (textBytes[i++] << 6) + textBytes[i++] - 0xE2080; + + } else { + charCode = + (encodedChar << 18) + (textBytes[i++] << 12) + (textBytes[i++] << 6) + textBytes[i++] - 0x3C82080; + } + + if (charCode > 0xFFFF) { + var surrogateHigh = Math.floor((charCode - 0x10000) / 0x400) + 0xD800; + var surrogateLow = ((charCode - 0x10000) % 0x400) + 0xDC00; + result += String.fromCharCode(surrogateHigh, surrogateLow); + continue; + } + + result += String.fromCharCode(charCode); + } + + return result; + } + + var domExceptionCodes = { + IndexSizeError: 1, HierarchyRequestError: 3, WrongDocumentError: 4, + InvalidCharacterError: 5, NoModificationAllowedError: 7, NotFoundError: 8, + NotSupportedError: 9, InUseAttributeError: 10, InvalidStateError: 11, + SyntaxError: 12, InvalidModificationError: 13, NamespaceError: 14, + InvalidAccessError: 15, TypeMismatchError: 17, SecurityError: 18, + NetworkError: 19, AbortError: 20, URLMismatchError: 21, + QuotaExceededError: 22, TimeoutError: 23, InvalidNodeTypeError: 24, + DataCloneError: 25 + }; + + function error(name, message) { + + message = message || ""; + + try { + return new DOMException(message, name); + } catch (e) { + var err = new Error(message); + err.name = name; + if (domExceptionCodes.hasOwnProperty(name)) { + err.code = domExceptionCodes[name]; + } + return err; + } + } + + function isBytes(array) { + if(!(array instanceof Array)) return false; + for (var i = 0; i < array.length; i++) { + var d = array[i]; + if (!isInteger(d) || d > 255 || d < 0) return false; + } + return true; + } + + function isInteger(value) { + return typeof value === "number" && isFinite(value) && Math.floor(value) === value; + }; + + return { + consoleLog: consoleLog, + toBase64: toBase64, + fromBase64: base64ToBytes, + checkParam: checkParam, + getObjectType: getObjectType, + bytesToHexString: bytesToHexString, + bytesToInt32: bytesToInt32, + stringToBytes: stringToBytes, + bytesToString: bytesToString, + unpackData: unpackData, + hexToBytesArray: hexToBytesArray, + int32ToBytes: int32ToBytes, + int32ArrayToBytes: int32ArrayToBytes, + toArray: toArray, + arraysEqual: arraysEqual, + indexOf: indexOf, + clone: clone, + xorVectors: xorVectors, + padEnd: padEnd, + padFront: padFront, + getVector: getVector, + verifyByteArray: verifyByteArray, + error: error, + isBytes: isBytes, + isInteger: isInteger + }; + +})(); + +var asn1 = (function () { + var asn1Types = { + 0x00: "CUSTOM", + 0x01: "BOOLEAN", + 0x02: "INTEGER", + 0x03: "BIT STRING", + 0x04: "OCTET STRING", + 0x05: "NULL", + 0x06: "OBJECT IDENTIFIER", + 0x10: "SEQUENCE", + 0x11: "SET", + 0x13: "PRINTABLE STRING", + 0x17: "UTCTime" + }; + + var asn1Classes = { + 0x00: "UNIVERSAL", + 0x01: "APPLICATION", + 0x02: "Context-Defined", + 0x03: "PRIVATE" + }; + + function parse(bytes, force) { + force = !!force; + + var type = asn1Types[bytes[0] & 0x1f], + dataLen = bytes[1], + i = 0, + constructed = !!(bytes[0] & 0x20), + remainder, + child, + header; + + if (dataLen & 0x80) { + for (i = 0, dataLen = 0; i < (bytes[1] & 127); i++) { + dataLen = (dataLen << 8) + bytes[2 + i]; + } + } + + header = 2 + i; + + if (type === undefined || dataLen > bytes.length) { + return null; + } + + var obj = constructed ? [] : {}; + + obj.type = type; + obj.header = header; + obj.data = bytes.slice(0, dataLen + header); + + if (constructed || force) { + if (obj.type === "BIT STRING" && bytes[header] === 0) { + i++; + } + remainder = bytes.slice(header, obj.data.length); + while (remainder.length > 0) { + child = parse(remainder); + if (child === null) { + break; + } + obj.push(child); + remainder = remainder.slice(child.data.length); + } + } + return obj; + } + + function encode(node) { + var INTEGER = 0x02, + BIT_STRING = 0x03, + OCTET_STRING = 0x04, + NULL = 0x05, + OBJECT_IDENTIFIER = 0x06, + SEQUENCE = 0x10, + + APPLICATION = 0xA0, + CONSTRUCTED = 0x20; + + if (node.hasOwnProperty("INTEGER")) { + var val = node.INTEGER; + if (msrcryptoUtilities.isInteger(val)) val = intToBytes(val); + if (val[0] & 128) val.unshift(0); + var result = [INTEGER].concat(encodeLength(val), val); + return result; + } + + if (node.hasOwnProperty("OCTET STRING")) { + var val = node["OCTET STRING"]; + if (!(val instanceof Array)) val = encode(val); + var result = [OCTET_STRING].concat(encodeLength(val), val); + return result; + } + + if (node.hasOwnProperty("BIT STRING")) { + var val = node["BIT STRING"]; + if (!(val instanceof Array)) val = encode(val); + val.unshift(0); + var result = [BIT_STRING].concat(encodeLength(val), val); + return result; + } + + if (node.hasOwnProperty("NULL")) { + return [NULL, 0]; + } + + if (node.hasOwnProperty("OBJECT IDENTIFIER")) { + var val = encodeOid(node["OBJECT IDENTIFIER"]); + var result = [OBJECT_IDENTIFIER].concat(encodeLength(val), val); + return result; + } + + if (node.hasOwnProperty("SEQUENCE")) { + var nodes = node.SEQUENCE; + var val = []; + for (var i = 0; i < nodes.length; i++) { + val = val.concat(encode(nodes[i])); + } + var result = [SEQUENCE | CONSTRUCTED].concat(encodeLength(val), val); + return result; + } + + if (node.hasOwnProperty("APPLICATION")) { + var nodes = node.APPLICATION; + var structured = isNaN(parseInt(nodes[0])) ? CONSTRUCTED : 0; + var tag = node.tag; + var val = structured ? [] : node.APPLICATION; + + if(structured) { + for (var i = 0; i < nodes.length; i++) { + val = val.concat(encode(nodes[i])); + } + } + + var result = [APPLICATION | structured | tag].concat(encodeLength(val), val); + + return result; + } + + throw new Error("unsupported asn.1 type"); + } + + function encodeLength(bytes) { + var len = bytes.length; + if (len <= 127 ) return [len]; + var result = intToBytes(len); + result.unshift(result.length | 128); + return result; + } + + function intToBytes(int) { + var result = []; + if(int === 0) return [0]; + while (int > 0) { + result.unshift(int & 255); + int >>>= 8; + } + return result; + } + + function encodeOid(text) { + var parts = text.split("."); + var result = [parseInt(parts[0] * 40 + parseInt(parts[1]))]; + + for (var i = 2; i < parts.length; i++) { + var val = parseInt(parts[i]); + + var bytes = []; + while (val > 0) { + bytes.push((val & 127) | 128); + val = val >>> 7; + } + bytes[0] = bytes[0] & 127; + + result = result.concat(bytes.reverse()); + } + return result; + } + + + function toString(objTree, indent) { + var output = + new Array(indent + 1).join(" ") + + objTree.type + + " (" + + objTree.length + + ") " + + bytesToHexString(objTree.data).substring(0, 16) + + "\n"; + + if (!objTree.children) { + return output; + } + + for (var i = 0; i < objTree.children.length; i++) { + output += toString(objTree.children[i], indent + 4) + ""; + } + + return output; + } + + + return { + parse: parse, + encode: encode, + toString: function (objTree) { + return toString(objTree, 0); + } + }; +})(); + +var msrcryptoWorker = (function() { + + function returnResult(result) { + + if (workerInitialized && runningInWorkerInstance) { + self.postMessage(result); + } + return result; + } + + var workerId, + operationType, + operationSubType; + + return { + + jsCryptoRunner: function(e) { + + workerId = e.data.workerid; + operationType = e.data.operationType; + operationSubType = e.data.operationSubType; + + var operation = e.data.operationType, + algorithmName = e.data.algorithm.name, + result, + p = e.data; + + if (!operations.hasOwnProperty(operation)) { + throw new Error("unregistered algorithm."); + } + + var algorithmMap = operations[operation]; + + if (typeof algorithmMap !== "object" || algorithmMap === null || + !algorithmMap.hasOwnProperty(algorithmName)) { + throw new Error("unregistered algorithm."); + } + + var func = algorithmMap[algorithmName]; + + if (typeof func !== "function") { + throw new Error("unregistered algorithm."); + } + + if (p.operationSubType) { + result = returnResult({ type: p.operationSubType, result: func(p) }); + } else { + result = returnResult(func(p)); + } + + return result; + }, + + returnResult: returnResult + }; + +})(); + +if (runningInWorkerInstance) { + + self.onmessage = function(e) { + + if (!workerInitialized && e.data.prngSeed) { + var entropy = e.data.prngSeed; + msrcryptoPseudoRandom.init(entropy); + workerInitialized = true; + return msrcryptoWorker.returnResult({ initialized: true }); + } + + if (workerInitialized === true) { + try { + msrcryptoWorker.jsCryptoRunner(e); + } catch (ex) { + msrcryptoWorker.returnResult({ + error: { + name: (ex && ex.name) || "OperationError", + message: (ex && ex.message) || "", + code: (ex && ex.code) || 0 + } + }); + } + } + + }; +} + +var msrcryptoJwk = (function() { + + var utils = msrcryptoUtilities; + + function getKeyType(keyHandle) { + + var algType = keyHandle.algorithm.name.slice(0, 3).toUpperCase(); + + if (algType === "RSA") { + return "RSA"; + } + + if (algType === "ECD") { + return "EC"; + } + + return "oct"; + } + + function hashSize(algorithm) { + return algorithm.hash.name.substring(algorithm.hash.name.indexOf("-") + 1); + } + + var algorithmMap = { + + "HMAC": function(algorithm) { + return "HS" + hashSize(algorithm); + }, + + "AES-CBC": function(algorithm) { + return "A" + algorithm.length.toString() + "CBC"; + }, + + "AES-GCM": function(algorithm) { + return "A" + algorithm.length.toString() + "GCM"; + }, + + "AES-KW": function(algorithm) { + return "A" + algorithm.length.toString() + "KW"; + }, + + "RSAES-PKCS1-V1_5": function(algorithm) { + return "RSA1_5"; + }, + + "RSASSA-PKCS1-V1_5": function(algorithm) { + return "RS" + hashSize(algorithm); + }, + + "RSA-OAEP": function(algorithm) { + if (algorithm.hash.name.toUpperCase() === "SHA-1") { return "RSA-OAEP"; } + return "RSA-OAEP-" + hashSize(algorithm); + }, + + "RSA-PSS": function(algorithm) { + return "PS" + hashSize(algorithm); + }, + + "ECDSA": function(algorithm) { + return "EC-" + algorithm.namedCurve.substring(algorithm.namedCurve.indexOf("-") + 1); + } + }; + + function keyToJwk(keyHandle, keyData) { + + var key = {}; + + key.kty = getKeyType(keyHandle); + key.ext = keyHandle.extractable; + if ( algorithmMap[keyHandle.algorithm.name.toUpperCase()] ) { + key.alg = algorithmMap[keyHandle.algorithm.name.toUpperCase()]( keyHandle.algorithm ); + } + key.key_ops = keyHandle.usages; + + if (keyData.pop) { + key.k = utils.toBase64(keyData, true); + } else { + for (var property in keyData) { + if (keyData[property].pop && property !== "key_ops") { + key[property] = utils.toBase64(keyData[property], true); + } + } + } + + if (keyHandle.algorithm.namedCurve) { + key.crv = keyHandle.algorithm.namedCurve; + } + + return key; + } + + function jwkToKey(keyData, algorithm, propsToArray) { + var jsonKeyObject = JSON.parse(JSON.stringify(keyData)); + + for (var i = 0; i < propsToArray.length; i += 1) { + var propValue = jsonKeyObject[propsToArray[i]]; + if (propValue) { + jsonKeyObject[propsToArray[i]] = + utils.fromBase64(propValue); + } + } + + return jsonKeyObject; + } + + return { + keyToJwk: keyToJwk, + jwkToKey: jwkToKey + }; +})(); + +function msrcryptoMath() { + var DIGIT_BITS = 24; + var DIGIT_NUM_BYTES = Math.floor(DIGIT_BITS / 8); + var DIGIT_MASK = (1 << DIGIT_BITS) - 1; + var DIGIT_BASE = (1 << DIGIT_BITS); + var DIGIT_MAX = DIGIT_MASK; + var DIG_INV = 1 / DIGIT_BASE; + var DIGIT_MAX_ADDS = 31; + + var DIGIT_SCALER = [1, 256]; + for (var ds = 2; ds <= DIGIT_NUM_BYTES; ds++) { + DIGIT_SCALER[ds] = DIGIT_SCALER[ds - 1] * 256; + } + + var Zero = [0]; + var One = [1]; + + function createArray( parameter) { + var i, array = null; + if (!arguments.length || typeof arguments[0] === "number") { + array = new Array(parameter); + for (i = 0; i < parameter; i += 1) { + array[i] = 0; + } + } else if (typeof arguments[0] === "object") { + array = new Array(parameter.length); + for (i = 0; i < parameter.length; i += 1) { + array[i] = parameter[i]; + } + } + return array; + } + + function stringToDigits(numberStr, radix) { + + numberStr = numberStr.replace(/^\s+|\s+$/g, ""); + var num = [0]; + var buffer = [0]; + radix = radix || 10; + for (var i = 0; i < numberStr.length; i += 1) { + var char = parseInt(numberStr[i], radix); + if (isNaN(char)) { + throw new Error("Failed to convert string to integer in radix " + radix.toString()); + } + + multiply(num, radix, buffer); + + add(buffer, [ char], num); + normalizeDigitArray(num); + } + + return num; + } + + function digitsToString(digits, radix) { + + radix = radix || 10; + if (DIGIT_BASE <= radix) { + throw new Error("DIGIT_BASE is smaller than RADIX; cannot convert."); + } + + var wordLength = digits.length; + var quotient = []; + var remainder = []; + var temp1 = []; + var temp2 = []; + var divisor = []; + var a = []; + var i; + + var sb = ""; + var pad = "0"; + divisor[0] = radix; + while (Math.floor(DIGIT_BASE / divisor[0]) >= radix) { + divisor[0] = divisor[0] * radix; + pad = pad.concat("0"); + } + + for (i = 0; i < wordLength; i += 1) { + a[i] = digits[i]; + } + + do { + var allZeros = true; + for (i = 0; i < a.length; i += 1) { + if (a[i] !== 0) { + allZeros = false; + break; + } + } + + if (allZeros) { + break; + } + + divRem(a, divisor, quotient, remainder, temp1, temp2); + normalizeDigitArray(quotient, a.length, true); + + var newDigits = remainder[0].toString(radix); + sb = pad.substring(0, pad.length - newDigits.length) + newDigits + sb; + + var swap = a; + a = quotient; + quotient = swap; + } while (true); + + while (sb.length !== 0 && sb[0] === "0") { + sb = sb.substring(1, sb.length); + } + + if (sb.length === 0) { + sb = "0"; + } + + return sb; + } + + function computeBitArray(bytes) { + + var out = createArray(bytes.length * 8); + var bitLength = 0; + var i = bytes.length - 1; + while (i >= 0) { + var j = 0; + while (j < 8) { + var mask = (1 << j); + var bit = ((bytes[i] & mask) === mask) ? 1 : 0; + var thisBitIndex = (8 * ((bytes.length - i) - 1)) + j; + + if (bit === 1) { + bitLength = thisBitIndex + 1; + } + + out[thisBitIndex] = bit; + j += 1; + } + + i--; + } + + return out.slice(0, bitLength); + } + + function bitScanForward(digit) { + var index = 0; + + for (var i = 0; i < DIGIT_BITS; i++) { + index = Math.max(index, -(digit >>> i & 1) & i); + } + + return index; + } + + function highestSetBit(bytes) { + + var i = 0; + var bitLength = 0; + + while (i < bytes.length) { + if (bitLength === 0) { + var j = 7; + while (j >= 0 && bitLength === 0) { + var mask = (1 << j); + if ((bytes[i] & mask) === mask) { + bitLength = j + 1; + } + + j--; + } + } else { + bitLength += 8; + } + + i += 1; + } + + return bitLength; + } + + function fixedWindowRecode(digits, windowSize, t) { + + digits = digits.slice(); + + var recodedDigits = [], + windowSizeBits = Math.pow(2, windowSize), + windowSizeMinus1Bits = Math.pow(2, windowSize - 1); + + for (var i = 0; i < t; i++) { + + recodedDigits[i] = (digits[0] % windowSizeBits) - windowSizeMinus1Bits; + + digits[0] = digits[0] - recodedDigits[i]; + + cryptoMath.shiftRight(digits, digits, windowSize - 1); + } + + recodedDigits[i] = digits[0]; + + return recodedDigits; + } + + function fixedWindowRecode2(digits, windowSize) { + + var digLen = digits.length, + bits = new Array(digLen * DIGIT_BITS), + i = 0, + j = 0, + k = 0, + r = 0, + dig, + result = new Array(Math.ceil(digLen * DIGIT_BITS / windowSize)); + + for (k = 0, result[0] = 0; i < digLen; i++) { + for (j = 0, dig = digits[i]; j < DIGIT_BITS; j++ , dig >>>= 1) { + if (k === windowSize) { + result[++r] = 0; + k = 0; + } + result[r] += (dig & 1) << k++; + } + } + + return result; + } + + function fetchBits(digits, startBit, count) { + + var startDigit = Math.floor(startBit / cryptoMath.DIGIT_BITS); + var endDigit = startDigit + 1; + + var shiftRight = (startBit % cryptoMath.DIGIT_BITS); + var shiftLeft = cryptoMath.DIGIT_BITS - shiftRight; + + var bits = (digits[startDigit] >>> shiftRight) | (digits[endDigit] << shiftLeft); + + return bits & (cryptoMath.DIGIT_MASK >>> (cryptoMath.DIGIT_BITS - count)); + + } + + function fetchBits2(digits, startBit, count) { + + var startDigit = Math.floor(startBit / DIGIT_BITS), + shiftRight = (startBit % DIGIT_BITS); + + return (digits[startDigit] >>> shiftRight) | + (digits[startDigit + 1] << (DIGIT_BITS - shiftRight)) & + (DIGIT_MASK >>> (DIGIT_BITS - count)); + } + + function copyArray( source, sourceIndex, destination, destIndex, length) { + while (length-- > 0) { + destination[destIndex + length] = source[sourceIndex + length]; + } + } + + function isZero(array) { + var i, + result = 0; + + for (i = 0; i < array.length; i += 1) { + result = result | array[i]; + } + return !result; + } + + function isEven(array) { + return (array[0] & 0x1) === 0x0; + } + + function sequenceEqual(left, right) { + var equal = left.length === right.length; + + for (var i = 0; i < Math.min(left.length, right.length); i += 1) { + if (left[i] !== right[i]) { + equal = false; + } + } + + return equal; + } + + function bytesToDigits(bytes) { + + var arrayLength = Math.floor((bytes.length + DIGIT_NUM_BYTES - 1) / DIGIT_NUM_BYTES); + var array = new Array(arrayLength); + array[0] = 0; + var digit = 0, + index = 0, + scIndex = 0; + for (var i = bytes.length - 1; i >= 0; i--) { + digit = digit + (DIGIT_SCALER[scIndex++] * (bytes[i] & 0x0ff)); + if (DIGIT_SCALER[scIndex] === DIGIT_BASE) { + scIndex = 0; + array[index++] = digit; + digit = 0; + } + } + + if (digit !== 0) { + array[index] = digit; + } + + while (array[--arrayLength] == null) { + array[arrayLength] = 0; + } + + return array; + } + + function digitsToBytes(digits, trim, minTrimLength) { + + var i, j, byte1; + var bytes = [0]; + + if (typeof trim === "undefined") { + trim = true; + } + + for (i = 0; i < digits.length; i += 1) { + byte1 = digits[i]; + for (j = 0; j < DIGIT_NUM_BYTES; j += 1) { + bytes[i * DIGIT_NUM_BYTES + j] = byte1 & 0x0FF; + byte1 = Math.floor(byte1 / 256); + } + } + + bytes.reverse(); + + if (minTrimLength === undefined) { + minTrimLength = 1; + } + if (trim) { + while (bytes.length > minTrimLength && bytes[0] === 0) { + bytes.shift(); + } + } + + return bytes; + } + + function intToDigits(value, numDigits) { + + if (typeof numDigits === "undefined") { + if (value <= 1) { + numDigits = 1; + } else { + var numBits = Math.log(value) / Math.LN2; + numDigits = Math.ceil(numBits / DIGIT_BITS); + } + } + + var digitRepresentation = []; + while (value > 0) { + digitRepresentation.push(value % DIGIT_BASE); + value = Math.floor(value / DIGIT_BASE); + } + + while (digitRepresentation.length < numDigits) { + digitRepresentation.push(0); + } + + return digitRepresentation; + } + + function mswIndex(digits) { + for (var i = digits.length - 1; i >= 0; i--) { + if (digits[i] !== undefined && digits[i] !== 0) { + return i; + } + } + + return (digits[0] === 0) ? -1 : 0; + } + + function compareDigits(left, right) { + + var result = 0, + val, i; + + for (i = 0; i < Math.max(left.length, right.length); i++) { + val = ~~left[i] - ~~right[i]; + result = val + (result & -!val); + } + + return result; + } + + function normalizeDigitArray(digits, length, pad) { + + var i = mswIndex(digits); + + digits.length = length || i + 1; + + if (pad) { + while (++i < digits.length) { + digits[i] = 0; + } + } + + if (digits.length <= 0) { + digits[0] = 0; + digits.length = 1; + } + + return digits; + } + + function shiftRight(source, destination, bits, length) { + + if (bits === undefined) { + bits = 1; + } else if (bits >= DIGIT_BITS || bits < 0) { + throw new Error("Invalid bit count for shiftRight"); + } + if (length === undefined) { + length = source.length; + } + + var n = length - 1; + var leftShiftBitCount = DIGIT_BITS - bits; + for (var i = 0; i < n; i++) { + destination[i] = ((source[i + 1] << leftShiftBitCount) | (source[i] >>> bits)) & DIGIT_MASK; + } + + destination[n] = source[n] >>> bits; + } + + function shiftLeft(source, destination, bits, length) { + + if (bits === undefined) { + bits = 1; + } else if (bits >= DIGIT_BITS || bits < 0) { + throw new Error("bit count must be smaller than DIGIT_BITS and positive in shiftLeft"); + } + if (length === undefined) { + length = source.length; + } + + var rightShiftBitCount = DIGIT_BITS - bits; + destination[length] = (source[length - 1] >>> (DIGIT_BITS - bits)) || destination[length]; + for (var i = length - 1; i > 0; i--) { + destination[i] = ((source[i] << bits) | ((source[i - 1] >>> rightShiftBitCount))) & DIGIT_MASK; + } + + destination[0] = (source[0] << bits) & DIGIT_MASK; + } + + + function add(addend1, addend2, sum) { + + var shortArray = addend1; + var longArray = addend2; + if (addend2.length < addend1.length) { + shortArray = addend2; + longArray = addend1; + } + + var s = shortArray.length; + var carry = 0; + var i; + + for (i = 0; i < s; i += 1) { + carry += shortArray[i] + longArray[i]; + sum[i] = carry & DIGIT_MASK; + carry = (carry >> DIGIT_BITS); + } + + for (i = s; i < longArray.length; i += 1) { + carry += longArray[i]; + sum[i] = carry & DIGIT_MASK; + carry = (carry >> DIGIT_BITS); + } + + sum.length = longArray.length; + + if (carry !== 0) { + sum[i] = carry & DIGIT_MASK; + } + + return carry; + } + + function subtract(minuend, subtrahend, difference) { + + var s = subtrahend.length; + if (minuend.length < subtrahend.length) { + s = mswIndex(subtrahend) + 1; + if (minuend.length < s) { + throw new Error("Subtrahend is longer than minuend, not supported."); + } + } + var i, carry = 0; + for (i = 0; i < s; i += 1) { + carry += minuend[i] - subtrahend[i]; + difference[i] = carry & DIGIT_MASK; + carry = carry >> DIGIT_BITS; + } + + while (i < minuend.length) { + carry += minuend[i]; + difference[i++] = carry & DIGIT_MASK; + carry = carry >> DIGIT_BITS; + } + + return carry; + } + + function multiply(a, b, p) { + + b = (typeof b === "number") ? [b] : b; + + var i, j, k, l, c, t1, t2, alen = a.length, + blen = b.length, + bi; + + for (i = 0; i < alen + blen; i += 1) { + p[i] = 0; + } + + i = 0; + l = 0; + + var maxRounds = 31; + var ks = 0; + + while (i < blen) { + + l = Math.min(l + maxRounds, blen); + + for (; i < l; i++) { + bi = b[i]; + for (j = 0; j < alen; j++) { + p[i + j] += a[j] * bi; + } + } + + c = 0; + for (k = ks; k < i + alen; k++) { + t1 = p[k] + c; + t2 = t1 & DIGIT_MASK; + p[k] = t2; + c = (t1 - t2) * DIG_INV; + } + p[k] = c; + + ks += maxRounds; + } + + p.length = alen + blen; + + return p; + } + + function divRem(dividend, divisor, quotient, remainder, temp1, temp2) { + var m = mswIndex(dividend) + 1; + var n = mswIndex(divisor) + 1; + var qhat, rhat, carry, p, t, i, j; + + if (m < n) { + copyArray(dividend, 0, remainder, 0, dividend.length); + remainder.length = dividend.length; + normalizeDigitArray(remainder); + quotient[0] = 0; + quotient.length = 1; + return; + } else if (n === 0 || (n === 1 && divisor[n - 1] === 0)) { + throw new Error("Division by zero."); + } else if (n === 1) { + t = divisor[0]; + rhat = 0; + for (j = m - 1; j >= 0; j--) { + p = (rhat * DIGIT_BASE) + dividend[j]; + quotient[j] = (p / t) & DIGIT_MASK; + rhat = (p - quotient[j] * t) & DIGIT_MASK; + } + quotient.length = m; + normalizeDigitArray(quotient); + remainder[0] = rhat; + remainder.length = 1; + return; + } + + var s = DIGIT_BITS - 1 - bitScanForward(divisor[n - 1]); + var vn = temp1 || []; + vn.length = n; + shiftLeft(divisor, vn, s, n); + + var un = temp2 || []; + un.length = m; + shiftLeft(dividend, un, s, m); + un[m] = un[m] || 0; + + quotient.length = m - n + 1; + remainder.length = n; + for (j = m - n; j >= 0; j--) { + qhat = Math.floor((un[j + n] * DIGIT_BASE + un[j + n - 1]) / vn[n - 1]); + rhat = (un[j + n] * DIGIT_BASE + un[j + n - 1]) - qhat * vn[n - 1]; + + while (true) { + if (qhat >= DIGIT_BASE || (qhat * vn[n - 2]) > ((rhat * DIGIT_BASE) + un[j + n - 2])) { + qhat = qhat - 1; + rhat = rhat + vn[n - 1]; + if (rhat < DIGIT_BASE) { + continue; + } + } + + break; + } + + carry = 0; + for (i = 0; i < n; i++) { + p = qhat * vn[i]; + t = un[i + j] - carry - (p & DIGIT_MASK); + un[i + j] = t & DIGIT_MASK; + carry = Math.floor(p / DIGIT_BASE) - Math.floor(t / DIGIT_BASE); + } + + t = un[j + n] - carry; + un[j + n] = t & DIGIT_MASK; + + quotient[j] = qhat & DIGIT_MASK; + + if (t < 0) { + quotient[j] = quotient[j] - 1; + + carry = 0; + for (i = 0; i < n; i++) { + t = un[i + j] + vn[i] + carry; + un[i + j] = t & DIGIT_MASK; + carry = t >> DIGIT_BITS; + } + un[j + n] = (un[j + n] + carry) & DIGIT_MASK; + } + } + + for (i = 0; i < n; i++) { + remainder[i] = ((un[i] >>> s) | (un[i + 1] << (DIGIT_BITS - s))) & DIGIT_MASK; + } + + normalizeDigitArray(quotient); + normalizeDigitArray(remainder); + } + + function reduce(number, modulus, remainder, temp1, temp2) { + + var quotient = []; + divRem(number, modulus, quotient, remainder, temp1, temp2); + + return remainder; + } + + function modMul(multiplicand, multiplier, modulus, product, temp1, temp2) { + + var quotient = []; + multiply(multiplicand, multiplier, quotient); + divRem(quotient, modulus, quotient, product, temp1, temp2); + + return product; + } + + function eea(a, b, upp, vpp, rpp) { + var rp; + if (isZero(a)) { + copyArray(b, 0, rpp, 0, b.length); + rpp.length = b.length; + return 0; + } else if (isZero(b)) { + copyArray(a, 0, rpp, 0, a.length); + rpp.length = a.length; + return 0; + } else if (compareDigits(a, b) < 0) { + rp = a.slice(0); + copyArray(b, 0, rpp, 0, b.length); + rpp.length = b.length; + } else { + rp = b.slice(0); + copyArray(a, 0, rpp, 0, a.length); + rpp.length = a.length; + } + + normalizeDigitArray(rpp); + normalizeDigitArray(rp); + var q = new Array(rpp.length); + var r = new Array(rpp.length); + + var v = new Array(rpp.length); + var vppPresent = vpp !== undefined; + var vp; + if (vppPresent) { + vp = new Array(rpp.length); + vp[0] = 1; + vp.length = 1; + vpp[0] = 0; + vpp.length = 1; + } + + var up; + var u = new Array(rpp.length); + var uppPresent = upp !== undefined; + if (uppPresent) { + up = new Array(rpp.length); + up[0] = 0; + up.length = 1; + upp[0] = 1; + upp.length = 1; + } + + var k = -1; + + var upp_out = upp; + var vpp_out = vpp; + var rpp_out = rpp; + var save; + + while (!isZero(rp)) { + divRem(rpp, rp, q, r, u, v); + + if (uppPresent) { + multiply(q, up, u); + add(u, upp, u); + normalizeDigitArray(u); + save = upp; + upp = up; + up = u; + u = save; + } + + if (vppPresent) { + multiply(q, vp, v); + add(v, vpp, v); + normalizeDigitArray(v); + save = vpp; + vpp = vp; + vp = v; + v = save; + } + + save = rpp; + rpp = rp; + rp = r; + r = save; + + k++; + } + + if (uppPresent) { + copyArray(upp, 0, upp_out, 0, upp.length); + upp_out.length = upp.length; + } + if (vppPresent) { + copyArray(vpp, 0, vpp_out, 0, vpp.length); + vpp_out.length = vpp.length; + } + copyArray(rpp, 0, rpp_out, 0, rpp.length); + rpp_out.length = rpp.length; + + return k; + } + + function gcd(a, b, output) { + var aa = a; + var bb = b; + if (compareDigits(a, b) > 0) { + aa = b; + bb = a; + } + + eea(aa, bb, undefined, undefined, output); + return normalizeDigitArray(output); + } + + function modInv(a, n, aInv, pad) { + var upp = new Array(n.length); + var vpp = new Array(n.length); + var rpp = new Array(n.length); + var k = eea(a, n, vpp, upp, rpp); + + aInv = aInv || []; + if (compareDigits(rpp, One) !== 0) { + aInv[0] = NaN; + aInv.length = 1; + } else { + if ((k & 1) === 1) { + subtract(n, upp, aInv); + } else { + copyArray(upp, 0, aInv, 0, upp.length); + aInv.length = upp.length; + } + if (pad) { + normalizeDigitArray(aInv, n.length, true); + } else { + normalizeDigitArray(aInv); + } + } + + return aInv; + } + + function modInvCT(a, n, aInv, pad) { + + var nMinus2 = []; + aInv = aInv || []; + subtract(n, [2], nMinus2); + modExp(a, nMinus2, n, aInv); + normalizeDigitArray(aInv); + return aInv; + } + + function modExp(base, exponent, modulus, result) { + + result = result || []; + + if (compareDigits(exponent, Zero) === 0) { + result[0] = 1; + } else if (compareDigits(exponent, One) === 0) { + copyArray(base, 0, result, 0, base.length); + result.length = base.length; + } else { + var montmul = new MontgomeryMultiplier(modulus); + normalizeDigitArray(base, montmul.s, true); + montmul.modExp( + base, + exponent, + result); + result.length = modulus.length; + } + + return result; + } + + function MontgomeryMultiplier(modulus, context) { + + function computeM0Prime(m0) { + var m0Pr = 1; + var a = 2; + var b = 3; + var c = b & m0; + + for (var i = 2; i <= DIGIT_BITS; i += 1) { + if (a < c) { + m0Pr += a; + } + + a = a << 1; + b = (b << 1) | 1; + c = m0 * m0Pr & b; + } + + var result = (~m0Pr & DIGIT_MASK) + 1; + return result; + } + + function montgomeryReduction(t, m, result) { + + var m0 = m[0]; + var mPrime = computeM0Prime(m0); + var n = m.length; + var A = t.slice(0); + var ui = []; + var uimbi = []; + var uim = []; + var bi = [1]; + + for (var i = 0; i < n; i++) { + + ui = (A[i] * mPrime) % DIGIT_BASE; + + multiply(m, [ui], uim); + multiply(uim, bi, uimbi); + + add(A, uimbi, A); + + bi.unshift(0); + } + + A = A.slice(n); + for (i = 0; i < A.length; i++) { + result[i] = A[i]; + } + + } + + function montgomeryMultiply(multiplicand, multiplier, result, ctx) { + + + ctx = ctx || this; + + var m = ctx.m, + s = m.length, + mPrime = ctx.mPrime, + m0 = ctx.m0, + rightI, r0, q, i = 0, + j, jm1, t1, t2, carry, rounds = 0; + + var temp = createArray(s + 2); + + while (i < s) { + + rounds = Math.min(s, rounds + 16); + + for (; i < rounds;) { + + rightI = ~~multiplier[i]; + + r0 = temp[0] + multiplicand[0] * rightI; + + q = ((r0 & DIGIT_MASK) * mPrime) & DIGIT_MASK; + + temp[1] += ((m0 * q + r0) * DIG_INV) | 0; + + for (j = 1, jm1 = 0; j < s; jm1 = j, j += 1) { + temp[jm1] = temp[j] + m[j] * q + multiplicand[j] * rightI; + } + temp[jm1] = temp[j]; + temp[j] = 0; + + i++; + } + + carry = 0; + for (j = 0; j < s; j++) { + t1 = temp[j] + carry; + t2 = t1 & DIGIT_MASK; + temp[j] = t2; + carry = (t1 - t2) * DIG_INV; + } + temp[j] = carry; + } + + for (i = 0; i < s; i += 1) { + result[i] = temp[i]; + } + result.length = s; + + var needSubtract = +(cryptoMath.compareDigits(temp, m) > 0); + cryptoMath.subtract(result, m, ctx.temp2); + + ctSetArray(needSubtract, result, ctx.temp2); + + return; + } + + function convertToMontgomeryForm( digits) { + + if (digits.length < this.s) { + digits.length = this.s; + for (var i = 0; i < this.s; i++) { + digits[i] = isNaN(digits[i]) ? 0 : digits[i]; + } + } + + var result = createArray(digits.length); + + this.montgomeryMultiply(digits, this.rSquaredModm, result); + for (i = 0; i < this.s; i += 1) { + digits[i] = result[i]; + } + } + + function convertToStandardForm(digits) { + this.montgomeryMultiply(digits, this.one, this.temp1); + for (var i = 0; i < this.s; i += 1) { + digits[i] = this.temp1[i]; + } + } + + var windowSizeThresholds = [ + [158, 2], + [634, 3], + [1984, 4], + [5568, 5], + [14670, 6] + ]; + + function optimalWindowSize(length) { + + var bits = length * DIGIT_BITS; + for (var i = 0; i < windowSizeThresholds.length; i++) { + if (bits <= windowSizeThresholds[i][0]) { + return windowSizeThresholds[i][1]; + } + } + + return windowSizeThresholds[windowSizeThresholds.length - 1][1] + 1; + } + + function modExp(base, exponent, result, skipSideChannel) { + + skipSideChannel = !!skipSideChannel; + + var windowBits = optimalWindowSize(exponent.length); + + var i, j, + expBits = fixedWindowRecode2(exponent, windowBits).reverse(), + partialResult = this.rModM.slice(0), + baseTableLen = Math.pow(2, windowBits), + bt = baseTable; + + bt.length = baseTableLen; + bt[0] = this.rModM; + for (i = 1; i < baseTableLen; i++) { + bt[i] = []; + multiply(bt[i - 1], base, bt[i]); + this.reduce(bt[i]); + } + + var tableVal = []; + var exp; + + for (i = 0; i < expBits.length; i++) { + for (j = 0; j < windowBits; j++) { + this.montgomeryMultiply(partialResult, partialResult, partialResult); + } + + exp = expBits[i]; + + skipSideChannel ? + (tableVal = bt[exp]) : + getTableEntry(bt, exp, tableVal); + + this.montgomeryMultiply(partialResult, tableVal, partialResult); + } + + this.montgomeryMultiply(partialResult, this.one, result); + + return result; + } + + function getTableEntry(bt, exp, tableVal) { + + var z, t, mask, tableEntry, k; + for (z = 0; z < bt[0].length; z++) { tableVal[z] = 0; } + for (t = 0; t < bt.length; t++) { + tableEntry = bt[t]; + mask = -(exp === t); + for (k = 0; k < tableEntry.length; k++) { + tableVal[k] = tableVal[k] | (tableEntry[k] & mask); + } + } + } + + function ctSetArray(condition, a, b) { + var bMask = -condition; + var aMask = ~bMask; + + for (var i = 0; i < a.length; i++) { + a[i] = (a[i] & aMask) | (b[i] & bMask); + } + } + + function reduce(x, result) { + + + var k = this.m.length, + q1, q2, q3, + r1, r2, + i, + needSubtract, + temp = []; + + result = result || x; + + q1 = x.slice(k - 1); + q2 = []; multiply(q1, this.mu, q2); + q3 = q2.slice(k + 1); + + r1 = x.slice(0, k + 1); + r2 = []; multiply(q3, m, r2); r2 = r2.slice(0, k + 1); + + r1[k + 1] = compareDigits(r1, r2) >>> 31; + + for (i = 0; i < result.length; i++) { result[i] = 0; } + subtract(r1, r2, result); + + needSubtract = +(compareDigits(result, m) > 0); + cryptoMath.subtract(result, m, temp); + ctSetArray(needSubtract, result, temp); + + normalizeDigitArray(result); + + return; + } + + function computeContext(modulus) { + + var s = modulus.length; + + var m0 = modulus[0]; + + var ctx = { + m: modulus, + mPrime: computeM0Prime(m0), + m0: m0, + temp1: createArray(2 * s + 1), + temp2: createArray(2 * s + 1) + }; + + var R = createArray(modulus.length * 2); R[R.length] = 1; + ctx.mu = []; divRem(R, modulus, ctx.mu, []); + + var quotient = createArray(2 * s + 1); + var rRemainder = createArray(s + 1); + var temp1 = createArray(2 * s + 1); + var temp2 = createArray(2 * s + 1); + var rDigits = rRemainder; + rDigits[s] = 1; + divRem(rDigits, modulus, quotient, rRemainder, temp1, temp2); + ctx.rModM = normalizeDigitArray(rRemainder, s, true); + + var rSquaredModm = createArray(2 * s + 1); + var rSquaredDigits = rSquaredModm; + rSquaredDigits[s * 2] = 1; + divRem(rSquaredDigits, modulus, quotient, rSquaredModm, temp1, temp2); + ctx.rSquaredModm = normalizeDigitArray(rSquaredModm, s, true); + + ctx.rCubedModm = createArray(s); + montgomeryMultiply(rSquaredModm, rSquaredModm, ctx.rCubedModm, ctx); + + return ctx; + } + + context = context || computeContext(modulus); + + + var m = context.m; + + var mu = context.mu; + + var m0 = context.m0; + + var s = m.length; + + var zeros = createArray(s + 1); + + var one = zeros.slice(0, s); + one[0] = 1; + + var mPrime = context.mPrime; + + var rModM = context.rModM; + + var rSquaredModm = context.rSquaredModm; + + var rCubedModm = context.rCubedModm; + + var temp1 = createArray(2 * s + 1); + var temp2 = createArray(2 * s + 1); + + var baseTable = new Array(4); + baseTable[0] = rModM; + baseTable[1] = new Array(s); + baseTable[2] = new Array(s); + baseTable[3] = new Array(s); + + return { + m: m, + + m0: m0, + + mPrime: mPrime, + mu: mu, + + rSquaredModm: rSquaredModm, + s: s, + rModM: rModM, + rCubedModm: rCubedModm, + one: one, + temp1: temp1, + temp2: temp2, + + convertToMontgomeryForm: convertToMontgomeryForm, + convertToStandardForm: convertToStandardForm, + montgomeryMultiply: montgomeryMultiply, + modExp: modExp, + reduce: reduce, + + ctx: context + }; + } + + function IntegerGroup(modulusBytes) { + + var m_modulus = bytesToDigits(modulusBytes); + + var m_digitWidth = m_modulus.length; + + var m_zero = intToDigits(0, m_digitWidth); + var m_one = intToDigits(1, m_digitWidth); + + var temp0 = createArray(m_digitWidth); + var temp1 = createArray(m_digitWidth); + + var montmul = new MontgomeryMultiplier(m_modulus); + + function createElementFromBytes(bytes) { + var digits = bytesToDigits(bytes); + + if (cryptoMath.compareDigits(digits, this.m_modulus) >= 0) { + throw new Error("The number provided is not an element of this group"); + } + + normalizeDigitArray(digits, this.m_digitWidth, true); + return integerGroupElement(digits, this); + } + + function createElementFromInteger(integer) { + var digits = intToDigits(integer, this.m_digitWidth); + return integerGroupElement(digits, this); + } + + function createElementFromDigits(digits) { + cryptoMath.normalizeDigitArray(digits, this.m_digitWidth, true); + return integerGroupElement(digits, this); + } + + function equals(otherGroup) { + + return compareDigits(this.m_modulus, otherGroup.m_modulus) === 0; + } + + function add(addend1, addend2, sum) { + + var i; + var s = this.m_digitWidth; + var result = sum.m_digits; + cryptoMath.add(addend1.m_digits, addend2.m_digits, result); + var mask = (compareDigits(result, this.m_modulus) >>> 31) - 1 & DIGIT_MASK; + + var carry = 0; + for (i = 0; i < s; i += 1) { + carry = result[i] - (this.m_modulus[i] & mask) + carry; + result[i] = carry & DIGIT_MASK; + carry = (carry >> DIGIT_BITS); + } + + result.length = s; + } + + function subtract(leftElement, rightElement, outputElement) { + + var i, s = this.m_digitWidth; + var result = outputElement.m_digits; + var carry = cryptoMath.subtract(leftElement.m_digits, rightElement.m_digits, outputElement.m_digits); + + if (carry === -1) { + carry = 0; + for (i = 0; i < s; i += 1) { + carry += result[i] + this.m_modulus[i]; + result[i] = carry & DIGIT_MASK; + carry = carry >> DIGIT_BITS; + } + } + } + + function inverse(element, outputElement) { + cryptoMath.modInv(element.m_digits, this.m_modulus, outputElement.m_digits); + } + + function multiply(multiplicand, multiplier, product) { + + return cryptoMath.modMul(multiplicand.m_digits, multiplier.m_digits, this.m_modulus, + product.m_digits, temp0, temp1); + } + + function modexp(valueElement, exponent, outputElement) { + + outputElement = outputElement || integerGroupElement([], this); + + if (compareDigits(exponent, m_zero) === 0) { + outputElement.m_digits = intToDigits(1, this.m_digitWidth); + } else if (compareDigits(exponent, m_one) === 0) { + for (var i = 0; i < valueElement.m_digits.length; i++) { + outputElement.m_digits[i] = valueElement.m_digits[i]; + } + outputElement.m_digits.length = valueElement.m_digits.length; + } else { + this.montmul.modExp( + valueElement.m_digits, + exponent, + outputElement.m_digits); + outputElement.m_digits.length = this.montmul.s; + } + + return outputElement; + } + + function integerGroupElement(digits, group) { + + + return { + m_digits: digits, + m_group: group, + + equals: function(element) { + return (compareDigits(this.m_digits, element.m_digits) === 0) && + this.m_group.equals(this.m_group, element.m_group); + } + }; + } + + return { + m_modulus: m_modulus, + m_digitWidth: m_digitWidth, + montmul: montmul, + + createElementFromInteger: createElementFromInteger, + createElementFromBytes: createElementFromBytes, + createElementFromDigits: createElementFromDigits, + equals: equals, + add: add, + subtract: subtract, + multiply: multiply, + inverse: inverse, + modexp: modexp + }; + } + + return { + DIGIT_BITS: DIGIT_BITS, + DIGIT_NUM_BYTES: DIGIT_NUM_BYTES, + DIGIT_MASK: DIGIT_MASK, + DIGIT_BASE: DIGIT_BASE, + DIGIT_MAX: DIGIT_MAX, + Zero: Zero, + One: One, + + normalizeDigitArray: normalizeDigitArray, + bytesToDigits: bytesToDigits, + stringToDigits: stringToDigits, + digitsToString: digitsToString, + intToDigits: intToDigits, + digitsToBytes: digitsToBytes, + isZero: isZero, + isEven: isEven, + + shiftRight: shiftRight, + shiftLeft: shiftLeft, + compareDigits: compareDigits, + bitLength: highestSetBit, + + fixedWindowRecode: fixedWindowRecode, + IntegerGroup: IntegerGroup, + + add: add, + subtract: subtract, + multiply: multiply, + divRem: divRem, + reduce: reduce, + modInv: modInv, + modInvCT: modInvCT, + modExp: modExp, + modMul: modMul, + MontgomeryMultiplier: MontgomeryMultiplier, + gcd: gcd, + + sequenceEqual: sequenceEqual, + swapEndianness: function(bytes) { return bytes.reverse(); }, + computeBitArray: computeBitArray + }; +} + +var cryptoMath = cryptoMath || msrcryptoMath(); + +function MsrcryptoECC() { + + var btd = cryptoMath.bytesToDigits; + + function createArray(parameter) { + var i, array = null; + if (!arguments.length || typeof arguments[0] === "number") { + array = []; + for (i = 0; i < parameter; i += 1) { + array[i] = 0; + } + } else if (typeof arguments[0] === "object") { + array = []; + for (i = 0; i < parameter.length; i += 1) { + array[i] = parameter[i]; + } + } + return array; + } + + var EllipticCurveFp = function(p1, a1, b1, order, gx, gy) { + + var fieldStorageBitLength = p1.length; + + var generator = EllipticCurvePointFp(this, false, gx, gy, null, false); + + return { + p: p1, + a: a1, + b: b1, + order: order, + generator: generator, + allocatePointStorage: function() { + return EllipticCurvePointFp( + this, + false, + cryptoMath.intToDigits(0, fieldStorageBitLength), + cryptoMath.intToDigits(0, fieldStorageBitLength) + ); + }, + createPointAtInfinity: function() { + return EllipticCurvePointFp( + this, + true, + cryptoMath.intToDigits(0, fieldStorageBitLength), + cryptoMath.intToDigits(0, fieldStorageBitLength) + ); + } + }; + }; + + var createWeierstrassCurve = function(curveData) { + + var newCurve = new EllipticCurveFp( + btd(curveData.p), + btd(curveData.a), + btd(curveData.b), + btd(curveData.order), + btd(curveData.gx), + btd(curveData.gy) + ); + + newCurve.type = curveData.type; + newCurve.name = curveData.name; + newCurve.generator.curve = newCurve; + + return newCurve; + }; + + var createTedCurve = function(curveData) { + + + var newCurve = new EllipticCurveFp( + btd(curveData.p), + btd(curveData.a), + btd(curveData.d), + btd(curveData.order), + btd(curveData.gx), + btd(curveData.gy) + ); + + newCurve.type = curveData.type; + + if (newCurve.type === 1) { + newCurve.d = newCurve.b.slice(); + delete newCurve.b; + } + + newCurve.rbits = curveData.info[2]; + newCurve.name = curveData.name; + newCurve.generator.curve = newCurve; + + return newCurve; + }; + + var EllipticCurvePointFp = function(curve, isInfinity, x, y, z, isInMontgomeryForm) { + + var returnObj; + + if (typeof z === "undefined") { + z = null; + } + + if (typeof isInMontgomeryForm === "undefined") { + isInMontgomeryForm = false; + } + + function equals(ellipticCurvePointFp) { + + if (!ellipticCurvePointFp) { + return false; + } + + if (returnObj.isInfinity && ellipticCurvePointFp.isInfinity) { + return true; + } + + + if (returnObj.z === null && ellipticCurvePointFp.z !== null) { + return false; + } + + if (returnObj.z !== null && ellipticCurvePointFp.z === null) { + return false; + } + + if (returnObj.z === null) { + return cryptoMath.compareDigits(returnObj.x, ellipticCurvePointFp.x) === 0 && + cryptoMath.compareDigits(returnObj.y, ellipticCurvePointFp.y) === 0 && + returnObj.isInMontgomeryForm === ellipticCurvePointFp.isInMontgomeryForm; + } + + return cryptoMath.compareDigits(returnObj.x, ellipticCurvePointFp.x) === 0 && + cryptoMath.compareDigits(returnObj.y, ellipticCurvePointFp.y) === 0 && + cryptoMath.compareDigits(returnObj.z, ellipticCurvePointFp.z) === 0 && + returnObj.isInMontgomeryForm === ellipticCurvePointFp.isInMontgomeryForm; + } + + function copyTo( source, destination) { + + destination.curve = source.curve; + destination.x = source.x.slice(); + destination.y = source.y.slice(); + + if (source.z !== null) { + destination.z = source.z.slice(); + } else { + destination.z = null; + } + + setterSupport || (destination.isAffine = source.isAffine); + destination.isInMontgomeryForm = source.isInMontgomeryForm; + destination.isInfinity = source.isInfinity; + + if (!destination.equals(source)) { + throw new Error("Instances should be equal."); + } + + } + + function clone() { + + var clonePoint = EllipticCurvePointFp( + returnObj.curve, + returnObj.isInfinity, + createArray(returnObj.x), + createArray(returnObj.y), + returnObj.z ? createArray(returnObj.z) : null, + returnObj.isInMontgomeryForm); + + returnObj.ta && (clonePoint.ta = createArray(returnObj.ta)); + returnObj.tb && (clonePoint.tb = createArray(returnObj.tb)); + + return clonePoint; + } + + returnObj = { + equals: function(ellipticCurvePointFp) { + return equals(ellipticCurvePointFp); + }, + copy: function(destination) { + copyTo(this, destination); + return; + }, + clone: function() { + return clone(); + } + }; + + createProperty(returnObj, "curve", curve, function() { return curve; }, function(val) { curve = val; }); + + createProperty(returnObj, "x", x, function() { return x; }, function(val) { x = val; }); + createProperty(returnObj, "y", y, function() { return y; }, function(val) { y = val; }); + createProperty(returnObj, "z", z, function() { return z; }, function(val) { z = val; }); + + createProperty(returnObj, "isInMontgomeryForm", isInMontgomeryForm, + function() { return isInMontgomeryForm; }, function(val) { isInMontgomeryForm = val; }); + createProperty(returnObj, "isInfinity", isInfinity, + function() { return isInfinity; }, function(val) { isInfinity = val; }); + createProperty(returnObj, "isAffine", z === null, function() { return z === null; }); + + return returnObj; + }; + + var EllipticCurveOperatorFp = function(curve) { + + var m_curve = curve; + + var tedCurve = curve.type === 1; + + var fieldElementWidth = curve.p.length; + + var montgomeryMultiplier = cryptoMath.MontgomeryMultiplier(curve.p); + + var montgomerizedA = curve.a.slice(); + montgomeryMultiplier.convertToMontgomeryForm(montgomerizedA); + + var aequalsZero = cryptoMath.isZero(curve.a); + + var one = cryptoMath.One; + + var onemontgomery = createArray(fieldElementWidth); + onemontgomery[0] = 1; + montgomeryMultiplier.convertToMontgomeryForm(onemontgomery); + + var group = cryptoMath.IntegerGroup(cryptoMath.digitsToBytes(montgomeryMultiplier.m), true); + + var temp0 = createArray(fieldElementWidth); + var temp1 = createArray(fieldElementWidth); + var temp2 = createArray(fieldElementWidth); + var temp3 = createArray(fieldElementWidth); + var temp4 = createArray(fieldElementWidth); + var temp5 = createArray(fieldElementWidth); + var temp6 = createArray(fieldElementWidth); + var temp7 = createArray(fieldElementWidth); + var swap0 = createArray(fieldElementWidth); + + var conversionTemp0 = createArray(fieldElementWidth); + var conversionTemp1 = createArray(fieldElementWidth); + var conversionTemp2 = createArray(fieldElementWidth); + + function modSub(left, right, result) { + var resultElement = group.createElementFromInteger(0); + resultElement.m_digits = result; + group.subtract( + group.createElementFromDigits(left), + group.createElementFromDigits(right), + resultElement); + } + + function modAdd(left, right, result) { + var resultElement = group.createElementFromInteger(0); + resultElement.m_digits = result; + group.add( + group.createElementFromDigits(left), + group.createElementFromDigits(right), + resultElement); + } + + function modInv(number, result) { + cryptoMath.modInv(number, m_curve.p, result); + } + + function modDivByTwo( dividend, result) { + + var s = dividend.length; + + var modulus = curve.p; + + if ((dividend[0] & 0x1) === 0x1) { + var carry = 0; + + for (var i = 0; i < s; i += 1) { + carry += dividend[i] + modulus[i]; + result[i] = carry & cryptoMath.DIGIT_MASK; + carry = carry >>> cryptoMath.DIGIT_BITS; + } + + carry = carry << cryptoMath.DIGIT_BITS - 1; + + cryptoMath.shiftRight(result, result); + + result[s - 1] |= carry; + } else { + cryptoMath.shiftRight(dividend, result); + } + + } + + function montgomeryMultiply(left, right, result) { + montgomeryMultiplier.montgomeryMultiply( + left, + right, + result); + } + + function montgomerySquare(left, result) { + montgomeryMultiplier.montgomeryMultiply( + left, + left, + result); + } + + function correctInversion(digits) { + var results = createArray(digits.length); + montgomeryMultiply(digits, montgomeryMultiplier.rCubedModm, results); + for (var i = 0; i < results.length; i += 1) { + digits[i] = results[i]; + } + } + + function doubleAequalsNeg3(point, outputPoint) { + + if (point.isInfinity) { + outputPoint.isInfinity = true; + return; + } + + montgomerySquare(point.z, temp1); + + montgomeryMultiply(point.z, point.y, temp4); + + modAdd(point.x, temp1, temp2); + + modSub(point.x, temp1, temp1); + + outputPoint.z = temp4.slice(); + + montgomeryMultiply(temp1, temp2, temp3); + + modDivByTwo(temp3, temp2); + + modAdd(temp3, temp2, temp1); + + montgomerySquare(point.y, temp2); + + montgomerySquare(temp1, temp4); + + montgomeryMultiply(point.x, temp2, temp3); + + modSub(temp4, temp3, temp4); + + modSub(temp4, temp3, outputPoint.x); + + modSub(temp3, outputPoint.x, temp4); + + montgomerySquare(temp2, temp3); + + montgomeryMultiply(temp1, temp4, temp2); + + modSub(temp2, temp3, outputPoint.y); + + outputPoint.isInfinity = false; + outputPoint.isInMontgomeryForm = true; + } + + function doubleAequals0(point, outputPoint) { + + if (point.isInfinity) { + outputPoint.isInfinity = true; + return; + } + + montgomerySquare(point.y, temp3); + + montgomerySquare(point.x, temp4); + + modAdd(temp4, temp4, temp0); + modAdd(temp0, temp4, temp4); + + montgomeryMultiply(point.x, temp3, temp5); + + montgomerySquare(temp3, temp0); + + modDivByTwo(temp4, temp1); + + montgomerySquare(temp1, temp3); + + montgomeryMultiply(point.y, point.z, swap0); + for (var i = 0; i < swap0.length; i += 1) { + outputPoint.z[i] = swap0[i]; + } + + modSub(temp3, temp5, outputPoint.x); + modSub(outputPoint.x, temp5, outputPoint.x); + + modSub(temp5, outputPoint.x, temp4); + + montgomeryMultiply(temp1, temp4, temp2); + + modSub(temp2, temp0, outputPoint.y); + + outputPoint.isInfinity = false; + outputPoint.isInMontgomeryForm = true; + } + + function generatePrecomputationTable(w, generatorPoint) { + + var validationPoint = generatorPoint.clone(); + convertToStandardForm(validationPoint); + if (!validatePoint(validationPoint)) { + throw new Error("Invalid Parameter"); + } + + var pointJac = generatorPoint.clone(); + convertToJacobianForm(pointJac); + + var tablePos = [generatorPoint.clone()]; + + var qJac = pointJac.clone(); + + var px2 = pointJac.clone(); + double(pointJac, px2); + convertToAffineForm(px2); + + var qAff; + + for (var i = 1; i < Math.pow(2, w - 2); i++) { + + mixedAdd(qJac, px2, qJac); + + qAff = qJac.clone(); + convertToAffineForm(qAff); + + tablePos[i] = qAff; + } + + return tablePos; + } + + function double(point, outputPoint) { + + if (typeof point === "undefined") { + throw new Error("point undefined"); + } + if (typeof outputPoint === "undefined") { + throw new Error("outputPoint undefined"); + } + + + if (point.isAffine) { + throw new Error("Given point was in Affine form. Use convertToJacobian() first."); + } + + if (!point.isInMontgomeryForm) { + throw new Error("Given point must be in Montgomery form. Use montgomeryize() first."); + } + if (aequalsZero) { + doubleAequals0(point, outputPoint); + } else { + doubleAequalsNeg3(point, outputPoint); + } + + } + + function mixedDoubleAdd(jacobianPoint, affinePoint, outputPoint) { + + if (jacobianPoint.isInfinity) { + affinePoint.copy(outputPoint); + this.convertToJacobianForm(outputPoint); + return; + } + + if (affinePoint.isInfinity) { + jacobianPoint.copy(outputPoint); + return; + } + + + + montgomerySquare(jacobianPoint.z, temp5); + + montgomeryMultiply(jacobianPoint.z, temp5, temp6); + + montgomeryMultiply(affinePoint.x, temp5, temp4); + + montgomeryMultiply(affinePoint.y, temp6, temp5); + + modSub(temp4, jacobianPoint.x, temp1); + + modSub(temp5, jacobianPoint.y, temp2); + + if (cryptoMath.isZero(temp1)) { + if (cryptoMath.isZero(temp2)) { + double(jacobianPoint, outputPoint); + mixedAdd(outputPoint, affinePoint, outputPoint); + return; + } else { + outputPoint.x = jacobianPoint.x.slice(0); + outputPoint.y = jacobianPoint.y.slice(0); + outputPoint.z = jacobianPoint.z.slice(0); + return; + } + } + + montgomerySquare(temp2, temp4); + + montgomerySquare(temp1, temp6); + + montgomeryMultiply(temp6, jacobianPoint.x, temp5); + + montgomeryMultiply(temp1, temp6, temp0); + + modSub(temp4, temp5, temp3); + modSub(temp3, temp5, temp3); + + montgomeryMultiply(jacobianPoint.z, temp1, temp4); + + modSub(temp3, temp5, temp3); + + montgomeryMultiply(temp0, jacobianPoint.y, temp6); + + modSub(temp3, temp0, temp3); + + + + if (cryptoMath.isZero(temp3)) { + for (i = 0; i < outputPoint.x.length; i++) { + outputPoint.x[i] = 0; + outputPoint.y[i] = 0; + outputPoint.z[i] = 0; + } + outputPoint.y[0] = 1; + return; + } + + modAdd(temp6, temp6, temp1); + + montgomeryMultiply(temp4, temp3, outputPoint.z); + + montgomeryMultiply(temp2, temp3, temp4); + + montgomerySquare(temp3, temp0); + + modAdd(temp1, temp4, temp1); + + montgomeryMultiply(temp0, temp5, temp4); + + montgomerySquare(temp1, temp7); + + montgomeryMultiply(temp0, temp3, temp5); + + modSub(temp7, temp4, outputPoint.x); + modSub(outputPoint.x, temp4, outputPoint.x); + + modSub(outputPoint.x, temp5, outputPoint.x); + + modSub(outputPoint.x, temp4, temp3); + + montgomeryMultiply(temp5, temp6, temp0); + + montgomeryMultiply(temp1, temp3, temp4); + + modSub(temp4, temp0, outputPoint.y); + + outputPoint.isInfinity = false; + outputPoint.isInMontgomeryForm = true; + + } + + function mixedAdd(jacobianPoint, affinePoint, outputPoint) { + + if (jacobianPoint === null) { + throw new Error("jacobianPoint"); + } + + if (affinePoint === null) { + throw new Error("affinePoint"); + } + + if (outputPoint === null) { + throw new Error("outputPoint"); + } + + if (jacobianPoint.curve !== affinePoint.curve || + jacobianPoint.curve !== outputPoint.curve) { + throw new Error("All points must be from the same curve object."); + } + + if (jacobianPoint.isAffine) { + throw new Error( + "Given jacobianPoint was in Affine form. Use ConvertToJacobian()\ + before calling DoubleJacobianAddAffinePoints()."); + } + + if (!affinePoint.isAffine) { + throw new Error( + "Given affinePoint was in Jacobian form. Use ConvertToAffine() before \ + calling DoubleJacobianAddAffinePoints()."); + } + + if (outputPoint.isAffine) { + throw new Error( + "Given jacobianPoint was in Jacobian form. Use ConvertToJacobian() before \ + calling DoubleJacobianAddAffinePoints()."); + } + + if (!jacobianPoint.isInMontgomeryForm) { + throw new Error("Jacobian point must be in Montgomery form"); + } + + if (!affinePoint.isInMontgomeryForm) { + throw new Error("Affine point must be in Montgomery form"); + } + + if (jacobianPoint.isInfinity) { + affinePoint.copy(outputPoint); + this.convertToJacobianForm(outputPoint); + return; + } + + if (affinePoint.isInfinity) { + jacobianPoint.copy(outputPoint); + return; + } + + + + + montgomerySquare(jacobianPoint.z, temp1); + + montgomeryMultiply(temp1, jacobianPoint.z, temp2); + + montgomeryMultiply(temp1, affinePoint.x, temp3); + + montgomeryMultiply(temp2, affinePoint.y, temp4); + + modSub(temp3, jacobianPoint.x, temp1); + + modSub(temp4, jacobianPoint.y, temp2); + + var i; + for (i = 0; i < temp1.length; i += 1) { + if (temp1[i] !== 0) { + + montgomeryMultiply(jacobianPoint.z, temp1, temp0); + for (var j = 0; j < fieldElementWidth; j += 1) { + outputPoint.z[j] = temp0[j]; + } + + montgomerySquare(temp1, temp3); + + montgomeryMultiply(temp3, temp1, temp4); + + montgomeryMultiply(temp3, jacobianPoint.x, temp5); + + modAdd(temp5, temp5, temp1); + + montgomerySquare(temp2, outputPoint.x); + + modSub(outputPoint.x, temp1, outputPoint.x); + + modSub(outputPoint.x, temp4, outputPoint.x); + + modSub(temp5, outputPoint.x, temp3); + + montgomeryMultiply(temp2, temp3, temp5); + + montgomeryMultiply(jacobianPoint.y, temp4, temp6); + + modSub(temp5, temp6, outputPoint.y); + + outputPoint.isInfinity = false; + outputPoint.isInMontgomeryForm = true; + + return; + } + } + + for (i = 0; i < temp2.length; i += 1) { + if (temp2[i] !== 0) { + outputPoint.isInfinity = true; + outputPoint.isInMontgomeryForm = true; + return; + } + } + affinePoint.copy(outputPoint); + this.convertToJacobianForm(outputPoint); + this.double(outputPoint, outputPoint); + outputPoint.isInMontgomeryForm = true; + + } + + function scalarMultiply(k, point, outputPoint, multiplyBy4) { + + if (point.isInfinity || cryptoMath.isZero(k)) { + outputPoint.isInfinity = true; + return; + } + + if (cryptoMath.compareDigits(k, curve.order) >= 0) { + throw new Error("The scalar k must be in the range 1 <= k < order."); + } + + k = k.slice(); + + if (point.curve.type === 1 ) { + + var pointIsEP = typeof point.ta !== "undefined"; + + if (!pointIsEP) { + convertToExtendedProjective(point); + } + + scalarMultiplyTed(k, point, outputPoint, multiplyBy4); + + if (!pointIsEP) { + normalizeTed(point); + } + + } else { + + var pointIsMF = point.isInMontgomeryForm, + outputIsMF = outputPoint.isInMontgomeryForm, + outputIsAffine = outputPoint.isAffine; + + if (!pointIsMF) { + convertToMontgomeryForm(point); + } + + if (!outputIsMF) { + convertToMontgomeryForm(outputPoint); + } + + scalarMultiplyW(k, point, outputPoint); + + if (outputIsAffine) { + convertToAffineForm(outputPoint); + } + + if (!pointIsMF) { + convertToStandardForm(point); + } + + if (!outputIsMF) { + convertToStandardForm(outputPoint); + } + } + + return; + + } + + function scalarMultiplyW(k, point, outputPoint) { + + var validationPoint = point.clone(); + convertToStandardForm(validationPoint); + + if (!validatePoint(validationPoint)) { + throw new Error("Invalid Parameters."); + } + + var odd = k[0] & 1, + tempk = []; + + modSub(point.curve.order, k, tempk); + for (i = 0; i < k.length; i++) { + k[i] = odd - 1 & (k[i] ^ tempk[i]) ^ k[i]; + } + + var w = fieldElementWidth <= 8 ? 5 : 6; + var m = point.curve.p.length * cryptoMath.DIGIT_BITS; + var t = Math.ceil(m / (w - 1)); + + var kDigits = cryptoMath.fixedWindowRecode(k, w, t); + + var Tm = generatePrecomputationTable(w, point); + + var position = + Math.floor(Math.abs(kDigits[t]) - 1) / 2; + + var Q = Tm[position].clone(); + convertToJacobianForm(Q); + + for (var i = t - 1; i >= 0; i--) { + + for (var j = 0; j < w - 2; j++) { + double(Q, Q); + } + + position = Math.floor((Math.abs(kDigits[i]) - 1) / 2); + + var L = tableLookupW(Tm, position); + + modSub(L.curve.p, L.y, tempk); + var mask = -(kDigits[i] >>> 31); + for (var n = 0; n < L.y.length; n++) { + L.y[n] = (L.y[n] & ~mask) | (tempk[n] & mask); + } + + mixedDoubleAdd(Q, L, Q); + + } + + modSub(point.curve.p, Q.y, tempk); + for (i = 0; i < Q.y.length; i++) { + Q.y[i] = odd - 1 & (Q.y[i] ^ tempk[i]) ^ Q.y[i]; + } + + Q.copy(outputPoint); + + return; + + } + + function tableLookupW(table, index) { + + var mask, + L; + + for (var i = 0; i < table.length; i++) { + mask = +(i === index); + L = [L, table[i].clone()][mask]; + } + + return L; + } + + function tableLookupW0(table, index) { + + var pos = (index + 1) % table.length; + + for (var i = 0; i < table.length; i++) { + var L = table[pos].clone(); + pos = (pos + 1) % table.length; + } + + return L; + } + + function negate(point, outputPoint) { + + if (point !== outputPoint) { + point.copy(outputPoint); + } + modSub(point.curve.p, point.y, outputPoint.y); + } + + function convertToMontgomeryForm(point) { + + if (point.isInMontgomeryForm) { + throw new Error("The given point is already in Montgomery form."); + } + + if (!point.isInfinity) { + montgomeryMultiplier.convertToMontgomeryForm(point.x); + montgomeryMultiplier.convertToMontgomeryForm(point.y); + + if (point.z !== null) { + montgomeryMultiplier.convertToMontgomeryForm(point.z); + } + + if (typeof point.ta !== "undefined") { + montgomeryMultiplier.convertToMontgomeryForm(point.ta); + montgomeryMultiplier.convertToMontgomeryForm(point.tb); + } + } + + point.isInMontgomeryForm = true; + } + + function convertToStandardForm(point) { + + if (!point.isInMontgomeryForm) { + throw new Error("The given point is not in montgomery form."); + } + + if (!point.isInfinity) { + montgomeryMultiplier.convertToStandardForm(point.x); + montgomeryMultiplier.convertToStandardForm(point.y); + if (point.z !== null) { + montgomeryMultiplier.convertToStandardForm(point.z); + } + if (typeof point.ta !== "undefined") { + montgomeryMultiplier.convertToStandardForm(point.ta); + montgomeryMultiplier.convertToStandardForm(point.tb); + } + } + + point.isInMontgomeryForm = false; + + } + + function convertToAffineForm(point) { + + if (point.isInfinity) { + point.z = null; + setterSupport || (point.isAffine = true); + return; + } + + + cryptoMath.modInv(point.z, curve.p, conversionTemp2, true); + + if (point.isInMontgomeryForm) { + montgomeryMultiply(conversionTemp2, montgomeryMultiplier.rCubedModm, conversionTemp1); + var swap = conversionTemp2; + conversionTemp2 = conversionTemp1; + conversionTemp1 = swap; + } + + + montgomerySquare(conversionTemp2, conversionTemp0); + + montgomeryMultiply(point.x, conversionTemp0, conversionTemp1); + for (var i = 0; i < fieldElementWidth; i += 1) { + point.x[i] = conversionTemp1[i]; + } + + montgomeryMultiply(point.y, conversionTemp0, conversionTemp1); + montgomeryMultiply(conversionTemp1, conversionTemp2, point.y); + + point.z = null; + + delete point.ta; + delete point.tb; + + setterSupport || (point.isAffine = true); + } + + function convertToJacobianForm(point) { + + if (!point.isAffine) { + throw new Error("The given point is not in Affine form."); + } + + setterSupport || (point.isAffine = false); + + var clonedDigits, + i, + zOne = point.isInMontgomeryForm ? onemontgomery : one; + + clonedDigits = createArray(zOne.length); + for (i = 0; i < zOne.length; i += 1) { + clonedDigits[i] = zOne[i]; + } + + point.z = clonedDigits; + + return; + } + + function validatePoint(point) { + + if (point.isInfinity) { + return false; + } + + cryptoMath.modMul(point.y, point.y, point.curve.p, temp1); + + cryptoMath.modMul(point.x, point.x, point.curve.p, temp2); + cryptoMath.modMul(point.x, temp2, point.curve.p, temp3); + modAdd(temp3, point.curve.b, temp2); + cryptoMath.modMul(point.x, point.curve.a, point.curve.p, temp3); + modAdd(temp2, temp3, temp2); + modSub(temp1, temp2, temp1); + + if (cryptoMath.isZero(temp1) === false) { + return false; + } + + return true; + } + + + function validatePointTed(point) { + + if (point.ta) { + point = point.clone(); + normalizeTed(point); + } + + cryptoMath.modMul(point.y, point.y, point.curve.p, temp3); + cryptoMath.modMul(point.x, point.x, point.curve.p, temp2); + + cryptoMath.add(temp2, temp3, temp1); + cryptoMath.reduce(temp4, point.curve.p, temp4); + + cryptoMath.modMul(temp2, temp3, point.curve.p, temp4); + cryptoMath.modMul(point.curve.d, temp4, point.curve.p, temp3); + + cryptoMath.add(temp3, [1], temp2); + cryptoMath.reduce(temp2, point.curve.p, temp2); + + cryptoMath.subtract(temp1, temp2, temp1); + + if (cryptoMath.isZero(temp1) === false) { + cryptoMath.reduce(temp1, point.curve.p, temp1); + if (cryptoMath.isZero(temp1) === false) { + return false; + } + } + + return true; + } + + function generatePrecomputationTableTed(npoints, point) { + + + var Q = point.clone(), + P2 = Q.clone(), + T = []; + + T[0] = convert_R1_to_R2(point); + doubleTed(Q, Q); + P2 = convert_R1_to_R2(Q); + Q = point.clone(); + + for (var i = 1; i < npoints; i++) { + addTedExtended(P2, Q, Q); + T[i] = convert_R1_to_R2(Q); + } + + return T; + } + + function convertToExtendedProjective(affinePoint) { + affinePoint.ta = affinePoint.x.slice(); + affinePoint.tb = affinePoint.y.slice(); + affinePoint.z = [1]; + } + + function scalarMultiplyTed(k, point, outputPoint, multiplyBy4) { + + if (!validatePointTed(point)) { + throw new Error("Invalid Parameter"); + } + + var rbits = point.curve.rbits; + multiplyBy4 = typeof multiplyBy4 === "undefined" ? true : multiplyBy4; + + var w = fieldElementWidth <= 8 ? 5 : 6; + + var t = Math.floor((rbits + (w - 2)) / (w - 1)); + var i, j; + + k = k.slice(); + + var T = point.clone(); + + convertToExtendedProjective(T); + + if (multiplyBy4) { + doubleTed(T, T); + doubleTed(T, T); + } + + var precomputationTable = generatePrecomputationTableTed(1 << w - 2, T); + + var odd = k[0] & 1, + tempk = [], + kisNeg; + + modSub(point.curve.order, k, tempk); + for (i = 0; i < k.length; i++) { + k[i] = odd - 1 & (k[i] ^ tempk[i]) ^ k[i]; + } + + var kDigits = cryptoMath.fixedWindowRecode(k, w, t); + + var position = + Math.floor(Math.abs(kDigits[t]) - 1) / 2; + + var R = precomputationTable[position]; + + T.x = R.x.slice(); + T.y = R.y.slice(); + T.z = R.z.slice(); + + for (i = t - 1; i >= 0; i--) { + + for (j = 0; j < w - 1; j++) { + doubleTed(T, T); + } + + position = Math.floor((Math.abs(kDigits[i]) - 1) / 2); + + var L = tableLookupTed(precomputationTable, position); + + + var mask = -(kDigits[i] >>> 31); + + modSub(point.curve.p, L.x, tempk); + for (var m = 0; m < L.x.length; m++) { + L.x[m] = (L.x[m] & ~mask) | (tempk[m] & mask); + } + + modSub(point.curve.p, L.td, tempk); + for (m = 0; m < L.td.length; m++) { + L.td[m] = (L.td[m] & ~mask) | (tempk[m] & mask); + } + + addTedExtended(L, T, T); + } + + modSub(point.curve.p, T.x, tempk); + for (i = 0; i < T.x.length; i++) { + T.x[i] = odd - 1 & (T.x[i] ^ tempk[i]) ^ T.x[i]; + } + + normalizeTed(T); + + outputPoint.x = T.x.slice(); + outputPoint.y = T.y.slice(); + + return; + + } + + function tableLookupTed(table, index) { + + var pos = (index + 1) % table.length; + + for (var i = 0; i < table.length; i++) { + var L = { + x: table[pos].x.slice(), + y: table[pos].y.slice(), + z: table[pos].z.slice(), + td: table[pos].td.slice() + }; + pos = (pos + 1) % table.length; + } + + return L; + } + + function normalizeTed(point) { + + cryptoMath.modInv(point.z, curve.p, conversionTemp2, true); + + cryptoMath.modMul(point.x, conversionTemp2, curve.p, point.x); + + cryptoMath.modMul(point.y, conversionTemp2, curve.p, point.y); + + delete point.ta; + delete point.tb; + + point.z = null; + + return; + } + + function doubleTed(point, outputPoint) { + + if (typeof point.ta === "undefined") { + throw new Error("Point should be in Extended Projective form."); + } + + cryptoMath.modMul(point.x, point.x, point.curve.p, temp0); + + cryptoMath.modMul(point.y, point.y, point.curve.p, temp1); + + cryptoMath.modMul(point.z, point.z, point.curve.p, point.ta); + modSub(temp1, temp0, outputPoint.tb); + modAdd(temp0, temp1, temp0); + + modAdd(point.ta, point.ta, point.ta); + + modAdd(point.y, point.y, point.y); + + modSub(point.ta, temp0, temp1); + + cryptoMath.modMul(point.x, point.y, point.curve.p, outputPoint.ta); + + cryptoMath.modMul(temp0, outputPoint.tb, point.curve.p, outputPoint.y); + + cryptoMath.modMul(temp1, outputPoint.ta, point.curve.p, outputPoint.x); + + cryptoMath.modMul(temp0, temp1, point.curve.p, outputPoint.z); + + return; + } + + function addTed(point1 , point2 , outputPoint) { + + var cm = cryptoMath; + + + if (typeof point1.ta === "undefined") { + throw new Error("Point1 should be in Extended Projective form."); + } + + if (typeof point2.ta === "undefined") { + throw new Error("Point2 should be in Extended Projective form."); + } + var qq = convert_R1_to_R2(point1); + + addTedExtended(qq, point2, outputPoint); + + return; + } + + function convert_R1_to_R2(point) { + + var curve = point.curve, + modulus = curve.p, + qq = { + x: point.x.slice(), + y: point.y.slice(), + z: point.z.slice(), + td: [], + curve: point.curve + }; + + cryptoMath.modMul(point.ta, point.tb, modulus, conversionTemp0); + + cryptoMath.modMul(conversionTemp0, curve.d, modulus, qq.td); + + return qq; + } + + function addTedExtended(qq , point2 , outputPoint) { + + + var cm = cryptoMath; + var modulus = point2.curve.p; + + temp1 = []; temp2 = []; temp3 = []; + + cm.modMul(point2.z, qq.z, modulus, temp3); + + cm.modMul(point2.ta, point2.tb, modulus, temp1); + + modAdd(point2.x, point2.y, point2.ta); + + cm.modMul(temp1, qq.td, modulus, temp2); + + modAdd(qq.x, qq.y, point2.tb); + + modSub(temp3, temp2, temp1); + + modAdd(temp3, temp2, temp3); + + cm.modMul(point2.ta, point2.tb, modulus, temp2); + + cm.modMul(point2.x, qq.x, modulus, point2.z); + + cm.modMul(point2.y, qq.y, modulus, point2.x); + + modSub(temp2, point2.z, temp2); + + modSub(point2.x, point2.z, outputPoint.ta); + + modSub(temp2, point2.x, outputPoint.tb); + + cm.modMul(outputPoint.ta, temp3, modulus, outputPoint.y); + + cm.modMul(outputPoint.tb, temp1, modulus, outputPoint.x); + + cm.modMul(temp3, temp1, modulus, outputPoint.z); + + return; + } + + function convertTedToWeierstrass(tedPoint, wPoint) { + + var a = tedPoint.curve.a.slice(), + d = tedPoint.curve.d.slice(), + p = tedPoint.curve.p, + modMul = cryptoMath.modMul, + modInv = cryptoMath.modInv; + + temp1 = [5]; + + modMul(a, temp1, p, temp2); + + modSub(temp2, d, temp2); + + modMul(d, temp1, p, temp3); + + modSub(a, temp3, temp1); + + modMul(tedPoint.y, temp1, p, temp3); + + modAdd(temp3, temp2, temp2); + + temp1 = [1]; + + modSub(temp1, tedPoint.y, temp3); + + temp1 = [12]; + + modMul(temp1, temp3, p, temp4); + + modInv(temp4, p, temp4, true); + + modMul(tedPoint.x, temp3, p, temp1); + + modAdd(temp1, temp1, temp3); + + modAdd(temp3, temp3, temp3); + + modInv(temp3, p, temp3, true); + + modMul(temp4, temp2, p, wPoint.x); + + temp1 = [1]; + + modAdd(tedPoint.y, temp1, temp1); + + modSub(a, d, temp2); + + modMul(temp1, temp2, p, temp4); + + modMul(temp4, temp3, p, wPoint.y); + + return; + } + + function convertWeierstrassToTed(wPoint, tedPoint) { + + var a = tedPoint.curve.a.slice(), + d = tedPoint.curve.d.slice(), + p = tedPoint.curve.p, + modMul = cryptoMath.modMul, + modInv = cryptoMath.modInv; + + modAdd(wPoint.x, wPoint.x, temp1); + + modAdd(wPoint.x, temp1, temp1); + + modAdd(temp1, temp1, temp1); + + modSub(temp1, a, temp2); + + modSub(temp2, d, temp2); + + modAdd(wPoint.y, wPoint.y, temp3); + + modAdd(wPoint.y, temp3, temp3); + + modAdd(temp3, temp3, temp3); + + modInv(temp3, p, temp3, true); + + modMul(temp2, temp3, p, tedPoint.x); + + modAdd(temp1, temp1, temp1); + + modAdd(temp1, d, temp2); + + modAdd(temp1, a, temp1); + + modAdd(a, a, temp3); + + modSub(temp2, temp3, temp2); + + modSub(temp2, temp3, temp2); + + modSub(temp2, a, temp2); + + modAdd(d, d, temp3); + + modSub(temp1, temp3, temp1); + + modSub(temp1, temp3, temp1); + + modSub(temp1, d, temp1); + + modInv(temp1, p, temp1, true); + + modMul(temp1, temp2, p, tedPoint.y); + + return; + } + + var methods = { + + convertToMontgomeryForm: convertToMontgomeryForm, + + convertToStandardForm: convertToStandardForm, + + convertToAffineForm: convertToAffineForm, + + convertToJacobianForm: convertToJacobianForm, + + generatePrecomputationTable: function(w, generatorPoint) { + + return generatePrecomputationTable(w, generatorPoint); + } + + }; + + if (tedCurve) { + + methods.double = doubleTed; + methods.add = addTed; + methods.scalarMultiply = scalarMultiply; + methods.normalize = normalizeTed; + methods.convertToExtendedProjective = convertToExtendedProjective; + methods.convertTedToWeierstrass = convertTedToWeierstrass; + methods.convertWeierstrassToTed = convertWeierstrassToTed; + methods.validatePoint = validatePointTed; + methods.generatePrecomputationTable = function(w, generatorPoint) { + + return generatePrecomputationTableTed(w, generatorPoint); + }; + } else { + + methods.double = double; + methods.mixedDoubleAdd = mixedDoubleAdd; + methods.mixedAdd = mixedAdd; + methods.scalarMultiply = scalarMultiply; + methods.negate = negate; + methods.validatePoint = validatePoint; + } + + return methods; + + }; + + var sec1EncodingFp = function() { + return { + encodePoint: function( point) { + + if (!point) { + throw new Error("point"); + } + + if (!point.isAffine) { + throw new Error("Point must be in affine form."); + } + + if (point.isInMontgomeryForm) { + throw new Error("Point must not be in Montgomery form."); + } + + if (point.isInfinity) { + return createArray(1); + } else { + var xOctetString = cryptoMath.digitsToBytes(point.x); + var yOctetString = cryptoMath.digitsToBytes(point.y); + var pOctetString = cryptoMath.digitsToBytes(point.curve.p); + var mlen = pOctetString.length; + if (mlen < xOctetString.length || mlen < yOctetString.length) { + throw new Error("Point coordinate(s) are bigger than the field order."); + } + var output = createArray(2 * mlen + 1); + + output[0] = 0x04; + var offset = mlen - xOctetString.length; + for (var i = 0; i < xOctetString.length; i++) { + output[i + 1 + offset] = xOctetString[i]; + } + offset = mlen - yOctetString.length; + for (i = 0; i < yOctetString.length; i++) { + output[mlen + i + 1 + offset] = yOctetString[i]; + } + + return output; + } + + }, + decodePoint: function(encoded, curve) { + + if (encoded.length < 1) { + throw new Error("Byte array must have non-zero length"); + } + + var pOctetString = cryptoMath.digitsToBytes(curve.p); + var mlen = pOctetString.length; + + if (encoded[0] === 0x0 && encoded.length === 1) { + return curve.createPointAtInfinity(); + } else if (encoded[0] === 0x04 && encoded.length === 1 + 2 * mlen) { + var xbytes = createArray(mlen); + var ybytes = createArray(mlen); + + for (var i = 0; i < mlen; i++) { + xbytes[i] = encoded[i + 1]; + ybytes[i] = encoded[mlen + i + 1]; + } + + var x = cryptoMath.bytesToDigits(xbytes); + var y = cryptoMath.bytesToDigits(ybytes); + + return EllipticCurvePointFp(curve, false, x, y); + } else { + throw new Error("Unsupported encoding format"); + } + } + }; + }; + + var ModularSquareRootSolver = function(modulus) { + + var p = modulus; + + var specialK = []; + + if (typeof modulus === "undefined") { + throw new Error("modulus"); + } + + if (cryptoMath.isEven(modulus)) { + throw new Error("Only odd moduli are supported"); + } + + var mul = cryptoMath.MontgomeryMultiplier(p); + + if (p[0] % 4 === 3) { + cryptoMath.add(p, cryptoMath.One, specialK); + cryptoMath.shiftRight(specialK, specialK, 2); + } else { + specialK = null; + } + + var temp0 = new Array(p.length); + var temp1 = new Array(p.length); + + function squareRootNistCurves(a) { + + var beta = cryptoMath.intToDigits(0, 16); + mul.modExp(a, specialK, beta); + + var aPrime = [0]; + cryptoMath.modMul(beta, beta, mul.m, aPrime); + + if (cryptoMath.compareDigits(a, aPrime) !== 0) { + return null; + } + + return beta; + } + + var publicMethods = { + + squareRoot: function(a) { + if (specialK !== null) { + return squareRootNistCurves(a); + } else { + throw new Error("GeneralCase not supported."); + } + }, + + jacobiSymbol: function(a) { + + var modEightMask = 0x7, + modFourMask = 0x3, + aPrime, + pPrime; + + aPrime = a.slice(); + pPrime = p.slice(); + + cryptoMath.reduce(aPrime, pPrime, aPrime, temp0, temp1); + + var t = 1; + + while (!cryptoMath.isZero(aPrime)) { + while (cryptoMath.isEven(aPrime)) { + cryptoMath.shiftRight(aPrime, aPrime); + + var pMod8 = pPrime[0] & modEightMask; + if (pMod8 === 3 || pMod8 === 5) { + t = -t; + } + } + + var tmp = aPrime; + aPrime = pPrime; + pPrime = tmp; + + var aMod4 = aPrime[0] & modFourMask; + var pMod4 = pPrime[0] & modFourMask; + if (aMod4 === 3 && pMod4 === 3) { + t = -t; + } + + cryptoMath.reduce(aPrime, pPrime, aPrime, temp0, temp1); + } + + if (cryptoMath.compareDigits(pPrime, cryptoMath.One) === 0) { + return t; + } else { + return 0; + } + } + + }; + + return publicMethods; + }; + + var curvesInternal = {}; + + var createCurve = function(curveName) { + + var curveData = curvesInternal[curveName.toUpperCase()]; + + if (!curveData) { + throw new Error(curveName + " Unsupported curve."); + } + + if (curveData.type === 0) { + return createWeierstrassCurve(curveData); + } + + if (curveData.type === 1) { + return createTedCurve(curveData); + } + + throw new Error(curveName + " Unsupported curve type."); + }; + + var validateEccPoint = function(curveName, x, y, z) { + var curve = createCurve(curveName); + var point = new EllipticCurvePointFp(curve, false, btd(x), btd(y), z && btd(z), false); + var opp = new EllipticCurveOperatorFp(curve); + return opp.validatePoint(point); + }; + + return { + createCurve: createCurve, + curves: curvesInternal, + sec1EncodingFp: sec1EncodingFp, + validatePoint: validateEccPoint, + EllipticCurvePointFp: EllipticCurvePointFp, + EllipticCurveOperatorFp: EllipticCurveOperatorFp, + ModularSquareRootSolver: ModularSquareRootSolver + }; +} + +var cryptoECC = cryptoECC || MsrcryptoECC(); + +var curve_P256 = { + name: "P-256", + type: 0, + p: [0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], + a: [0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC], + b: [0x5A, 0xC6, 0x35, 0xD8, 0xAA, 0x3A, 0x93, 0xE7, 0xB3, 0xEB, 0xBD, 0x55, 0x76, 0x98, 0x86, 0xBC, 0x65, 0x1D, 0x06, 0xB0, 0xCC, 0x53, 0xB0, 0xF6, 0x3B, 0xCE, 0x3C, 0x3E, 0x27, 0xD2, 0x60, 0x4B], + order: [0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, 0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51], + gx: [0x6B, 0x17, 0xD1, 0xF2, 0xE1, 0x2C, 0x42, 0x47, 0xF8, 0xBC, 0xE6, 0xE5, 0x63, 0xA4, 0x40, 0xF2, 0x77, 0x03, 0x7D, 0x81, 0x2D, 0xEB, 0x33, 0xA0, 0xF4, 0xA1, 0x39, 0x45, 0xD8, 0x98, 0xC2, 0x96], + gy: [0x4F, 0xE3, 0x42, 0xE2, 0xFE, 0x1A, 0x7F, 0x9B, 0x8E, 0xE7, 0xEB, 0x4A, 0x7C, 0x0F, 0x9E, 0x16, 0x2B, 0xCE, 0x33, 0x57, 0x6B, 0x31, 0x5E, 0xCE, 0xCB, 0xB6, 0x40, 0x68, 0x37, 0xBF, 0x51, 0xF5], + cf: 1 +}; + +var curve_P384 = { + name: "P-384", + type: 0, + p: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF], + a: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFC], + b: [0xB3, 0x31, 0x2F, 0xA7, 0xE2, 0x3E, 0xE7, 0xE4, 0x98, 0x8E, 0x05, 0x6B, 0xE3, 0xF8, 0x2D, 0x19, 0x18, 0x1D, 0x9C, 0x6E, 0xFE, 0x81, 0x41, 0x12, 0x03, 0x14, 0x08, 0x8F, 0x50, 0x13, 0x87, 0x5A, 0xC6, 0x56, 0x39, 0x8D, 0x8A, 0x2E, 0xD1, 0x9D, 0x2A, 0x85, 0xC8, 0xED, 0xD3, 0xEC, 0x2A, 0xEF], + order: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC7, 0x63, 0x4D, 0x81, 0xF4, 0x37, 0x2D, 0xDF, 0x58, 0x1A, 0x0D, 0xB2, 0x48, 0xB0, 0xA7, 0x7A, 0xEC, 0xEC, 0x19, 0x6A, 0xCC, 0xC5, 0x29, 0x73], + gx: [0xAA, 0x87, 0xCA, 0x22, 0xBE, 0x8B, 0x05, 0x37, 0x8E, 0xB1, 0xC7, 0x1E, 0xF3, 0x20, 0xAD, 0x74, 0x6E, 0x1D, 0x3B, 0x62, 0x8B, 0xA7, 0x9B, 0x98, 0x59, 0xF7, 0x41, 0xE0, 0x82, 0x54, 0x2A, 0x38, 0x55, 0x02, 0xF2, 0x5D, 0xBF, 0x55, 0x29, 0x6C, 0x3A, 0x54, 0x5E, 0x38, 0x72, 0x76, 0x0A, 0xB7], + gy: [0x36, 0x17, 0xDE, 0x4A, 0x96, 0x26, 0x2C, 0x6F, 0x5D, 0x9E, 0x98, 0xBF, 0x92, 0x92, 0xDC, 0x29, 0xF8, 0xF4, 0x1D, 0xBD, 0x28, 0x9A, 0x14, 0x7C, 0xE9, 0xDA, 0x31, 0x13, 0xB5, 0xF0, 0xB8, 0xC0, 0x0A, 0x60, 0xB1, 0xCE, 0x1D, 0x7E, 0x81, 0x9D, 0x7A, 0x43, 0x1D, 0x7C, 0x90, 0xEA, 0x0E, 0x5F], + cf: 1 +}; + +var curve_P521 = { + name: "P-521", + type: 0, + p: [0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], + a: [0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC], + b: [0x00, 0x51, 0x95, 0x3E, 0xB9, 0x61, 0x8E, 0x1C, 0x9A, 0x1F, 0x92, 0x9A, 0x21, 0xA0, 0xB6, 0x85, 0x40, 0xEE, 0xA2, 0xDA, 0x72, 0x5B, 0x99, 0xB3, 0x15, 0xF3, 0xB8, 0xB4, 0x89, 0x91, 0x8E, 0xF1, 0x09, 0xE1, 0x56, 0x19, 0x39, 0x51, 0xEC, 0x7E, 0x93, 0x7B, 0x16, 0x52, 0xC0, 0xBD, 0x3B, 0xB1, 0xBF, 0x07, 0x35, 0x73, 0xDF, 0x88, 0x3D, 0x2C, 0x34, 0xF1, 0xEF, 0x45, 0x1F, 0xD4, 0x6B, 0x50, 0x3F, 0x00], + order: [0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFA, 0x51, 0x86, 0x87, 0x83, 0xBF, 0x2F, 0x96, 0x6B, 0x7F, 0xCC, 0x01, 0x48, 0xF7, 0x09, 0xA5, 0xD0, 0x3B, 0xB5, 0xC9, 0xB8, 0x89, 0x9C, 0x47, 0xAE, 0xBB, 0x6F, 0xB7, 0x1E, 0x91, 0x38, 0x64, 0x09], + gx: [0x00, 0xC6, 0x85, 0x8E, 0x06, 0xB7, 0x04, 0x04, 0xE9, 0xCD, 0x9E, 0x3E, 0xCB, 0x66, 0x23, 0x95, 0xB4, 0x42, 0x9C, 0x64, 0x81, 0x39, 0x05, 0x3F, 0xB5, 0x21, 0xF8, 0x28, 0xAF, 0x60, 0x6B, 0x4D, 0x3D, 0xBA, 0xA1, 0x4B, 0x5E, 0x77, 0xEF, 0xE7, 0x59, 0x28, 0xFE, 0x1D, 0xC1, 0x27, 0xA2, 0xFF, 0xA8, 0xDE, 0x33, 0x48, 0xB3, 0xC1, 0x85, 0x6A, 0x42, 0x9B, 0xF9, 0x7E, 0x7E, 0x31, 0xC2, 0xE5, 0xBD, 0x66], + gy: [0x01, 0x18, 0x39, 0x29, 0x6A, 0x78, 0x9A, 0x3B, 0xC0, 0x04, 0x5C, 0x8A, 0x5F, 0xB4, 0x2C, 0x7D, 0x1B, 0xD9, 0x98, 0xF5, 0x44, 0x49, 0x57, 0x9B, 0x44, 0x68, 0x17, 0xAF, 0xBD, 0x17, 0x27, 0x3E, 0x66, 0x2C, 0x97, 0xEE, 0x72, 0x99, 0x5E, 0xF4, 0x26, 0x40, 0xC5, 0x50, 0xB9, 0x01, 0x3F, 0xAD, 0x07, 0x61, 0x35, 0x3C, 0x70, 0x86, 0xA2, 0x72, 0xC2, 0x40, 0x88, 0xBE, 0x94, 0x76, 0x9F, 0xD1, 0x66, 0x50], + cf: 1 +}; + +if (typeof cryptoECC !== "undefined") { + cryptoECC.curves["P-256"] = curve_P256; + cryptoECC.curves["P-384"] = curve_P384; + cryptoECC.curves["P-521"] = curve_P521; +} + +var curve_BN254 = { + name: "BN-254", + type: 0, + p: [0x25, 0x23, 0x64, 0x82, 0x40, 0x00, 0x00, 0x01, 0xBA, 0x34, 0x4D, 0x80, 0x00, 0x00, 0x00, 0x08, 0x61, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xA7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13], + a: [0x00], + b: [0x02], + order: [0x25, 0x23, 0x64, 0x82, 0x40, 0x00, 0x00, 0x01, 0xBA, 0x34, 0x4D, 0x80, 0x00, 0x00, 0x00, 0x07, 0xFF, 0x9F, 0x80, 0x00, 0x00, 0x00, 0x00, 0x10, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D], + gx: [0x25, 0x23, 0x64, 0x82, 0x40, 0x00, 0x00, 0x01, 0xBA, 0x34, 0x4D, 0x80, 0x00, 0x00, 0x00, 0x08, 0x61, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xA7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12], + gy: [0x01], + cf: 1 +}; + +if (typeof cryptoECC !== "undefined") { + cryptoECC.curves["BN-254"] = curve_BN254; +} + +var curve_numsp256d1 = { + info: ["numsp256d1", 256, 256, 256], + type: 0, + p: [0x43, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), + a: [0x40, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), + b: [0x81, 0x55, 0x02].reverse(), + order: [0x25, 0xa8, 0x51, 0x47, 0x29, 0x20, 0xab, 0x20, 0x60, 0x5c, 0x26, 0xea, 0x75, 0x82, 0x3c, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), + gx: [0xB1, 0xAC, 0x1A, 0xB2, 0x1E, 0xEE, 0x52, 0xBC, 0x3A, 0xC7, 0xD4, 0x03, 0x09, 0x9B, 0x57, 0x83, 0x09, 0xCB, 0x42, 0x4F, 0xA0, 0x95, 0x7A, 0x29, 0x61, 0xDB, 0xAA, 0x5A, 0xB6, 0xD6, 0x9E, 0xBC].reverse(), + gy: [0x9F, 0xDE, 0x84, 0x21, 0xCB, 0xB9, 0xB5, 0x80, 0xBB, 0x0F, 0x31, 0x15, 0xD1, 0xC3, 0x55, 0xC9, 0x35, 0xE0, 0x04, 0x7E, 0xF7, 0x8B, 0x44, 0x73, 0xA6, 0xB6, 0x99, 0x33, 0xF1, 0xC0, 0x8F, 0xD0].reverse(), + cf: 1 +}; + +var curve_numsp256t1 = { + info: ["numsp256t1", 256, 255, 256], + name: "numsp256t1", + type: 1, + p: [0x43, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), + a: [0x01], + d: [0x55, 0xC3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), + order: [0xF5, 0x4A, 0xDD, 0xEE, 0x90, 0xB1, 0x47, 0x1A, 0x9B, 0x43, 0x59, 0x2F, 0xA5, 0x5A, 0x95, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40].reverse(), + gx: [0xDA, 0x13, 0xED, 0x2E, 0x90, 0xC0, 0xDE, 0xA0, 0x86, 0x35, 0x08, 0xE3, 0x0E, 0x8A, 0x39, 0x0C, 0xD6, 0x9B, 0x20, 0x69, 0x5F, 0x3D, 0x1E, 0xCD, 0x7D, 0x23, 0xEA, 0x6A, 0xFB, 0x14, 0x75, 0x8A].reverse(), + gy: [0xE6, 0x89, 0x8A, 0x79, 0xE7, 0x16, 0xA6, 0x2F, 0xD3, 0x6E, 0x85, 0x10, 0xD8, 0x61, 0x5F, 0x71, 0x10, 0x80, 0x4B, 0xA6, 0xD9, 0x65, 0x96, 0xCE, 0xC7, 0x25, 0xD9, 0xD9, 0x9F, 0x3E, 0xD5, 0x44].reverse(), + cf: 4 +}; + +var curve_numsp384d1 = { + info: ["numsp384d1", 384, 384, 384], + name: "numsp384d1", + type: 0, + p: [0xC3, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), + a: [0xC0, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), + b: [0xBB, 0x77, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), + order: [0xb9, 0x61, 0x0e, 0x7b, 0xf6, 0x81, 0x4d, 0x60, 0x7a, 0xe2, 0x37, 0x4c, 0x3d, 0x9d, 0xda, 0xbe, 0x81, 0x68, 0x5d, 0xeb, 0x1e, 0xaf, 0x1e, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), + gx: [0x2A, 0x15, 0x98, 0x20, 0x04, 0xBA, 0x9C, 0xEB, 0x7B, 0xC4, 0x61, 0x0F, 0x10, 0xED, 0x2E, 0x52, 0x42, 0xC7, 0x6C, 0x2A, 0x1B, 0x29, 0xBD, 0xF3, 0xF4, 0xF9, 0x81, 0xFB, 0xCD, 0xC1, 0x25, 0x02, + 0xA6, 0xF1, 0x05, 0x41, 0x22, 0xCA, 0x80, 0x48, 0x1C, 0x18, 0x6F, 0xB1, 0xF0, 0x56, 0x79, 0x75].reverse(), + gy: [0x16, 0x07, 0x18, 0x66, 0xEC, 0xB8, 0x74, 0x5C, 0x26, 0xAD, 0xF4, 0xBF, 0xDB, 0xB4, 0xD6, 0xBC, 0x7E, 0x83, 0x1A, 0x12, 0x7D, 0x83, 0x20, 0xB9, 0x9C, 0x73, 0x7F, 0xF8, 0x77, 0x69, 0x04, 0xB0, + 0x7E, 0xCF, 0x84, 0x05, 0x30, 0x3D, 0xE3, 0xD7, 0x38, 0x8E, 0x9B, 0xE1, 0x68, 0xE3, 0xDE, 0xAC].reverse(), + cf: 1 +}; + +var curve_numsp384t1 = { + info: ["numsp384t1", 384, 382, 384], + name: "numsp384t1", + type: 1, + p: [ 0xC3, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ].reverse(), + a: [ 0x01 ], + d: [ 0x9F, 0xD1, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF ].reverse(), + order: [ 0x7D, 0x89, 0xA3, 0xE6, 0xC4, 0xDC, 0xB9, 0x20, 0x79, 0xC8, 0x35, 0xAB, 0x5A, 0x55, 0xE4, 0x61, 0xCF, 0xE1, 0x6B, 0xB4, 0x1C, 0x1A, 0x47, 0xE2, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F ].reverse(), + gx: [ 0xDE, 0x6B, 0x20, 0x6C, 0xE4, 0x40, 0xD5, 0x50, 0x13, 0x94, 0x45, 0x65, 0xB1, 0x92, 0xF2, 0x6F, 0x40, 0x63, 0x31, 0xF3, 0xA8, 0xFF, 0x63, 0x57, 0x00, 0x4C, 0xBE, 0xE5, 0x46, 0xF4, 0x0B, 0xB3, + 0xB5, 0x5D, 0xE5, 0x9A, 0x12, 0xA2, 0xB6, 0xC0, 0x6C, 0x26, 0xA9, 0x45, 0xFB, 0x11, 0xB1, 0x61 ].reverse(), + gy: [ 0x92, 0x93, 0x72, 0xF0, 0xE1, 0x03, 0x8D, 0x9D, 0xDC, 0x48, 0xEC, 0x46, 0xF9, 0xB0, 0x72, 0x00, 0x4B, 0x96, 0x45, 0xF6, 0xF7, 0x98, 0x0F, 0x83, 0x56, 0x5F, 0x42, 0xF1, 0x74, 0x82, 0xAD, 0x16, + 0xD7, 0x0D, 0xB1, 0x23, 0xA4, 0xB1, 0x38, 0x87, 0xB0, 0xEE, 0xA6, 0xB9, 0x67, 0x3E, 0x98, 0x82 ].reverse(), + cf: 4 +}; + +var curve_numsp512d1 = { + info: ["numsp512d1", 512, 512, 512], + name: "numsp512d1", + type: 0, + p: [0xC7, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), + a: [0xC4, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), + b: [0x9B, 0xD9, 0x01].reverse(), + order: [0x5d, 0x55, 0x33, 0x04, 0x39, 0x3f, 0x15, 0xce, 0x43, 0xd2, 0x7c, 0x60, 0x36, 0x8b, 0x56, 0x3b, 0xc6, 0xbd, 0xd0, 0x97, 0xed, 0x58, 0xc2, 0x4f, 0x1b, 0x83, 0xe7, 0x94, 0xfb, 0xa4, 0x3c, 0x5b, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), + gx: [0x57, 0xAE, 0xAB, 0x8C, 0x95, 0x87, 0x82, 0xDC, 0xE2, 0x5D, 0x6F, 0x7D, 0x13, 0x60, 0x5D, 0x1D, 0x83, 0x15, 0x56, 0x25, 0x86, 0x42, 0x79, 0x93, 0x9E, 0x35, 0x6B, 0x07, 0x51, 0xA1, 0x21, 0x50, + 0xF9, 0xD9, 0x06, 0x53, 0xC2, 0xE0, 0x06, 0x45, 0x85, 0xF6, 0x01, 0xB5, 0x3B, 0xD8, 0xCA, 0x98, 0x52, 0x3B, 0x3D, 0xA0, 0x02, 0x70, 0x2B, 0xDA, 0x93, 0x0A, 0x1D, 0x14, 0x47, 0x34, 0xC0, 0x3A].reverse(), + gy: [0xA6, 0x27, 0x35, 0x38, 0x60, 0x87, 0xA0, 0x23, 0xE9, 0x0F, 0xFD, 0x4C, 0x1E, 0x5C, 0x2B, 0xCF, 0x02, 0x56, 0x5A, 0xB2, 0x40, 0xA8, 0x21, 0xC1, 0xE9, 0xED, 0x0E, 0x8B, 0xDA, 0x15, 0x84, 0xA2, + 0x14, 0x4F, 0xD1, 0x7B, 0x0C, 0x26, 0x4B, 0x8F, 0x8C, 0xBB, 0xBC, 0xAB, 0xDE, 0xDB, 0x97, 0x4B, 0x00, 0xB1, 0xEB, 0x63, 0xDC, 0xEE, 0x0E, 0xCE, 0xB3, 0x56, 0xAD, 0x29, 0xCA, 0x54, 0x3A, 0x94].reverse(), + cf: 4 +}; + +var curve_numsp512t1 = { + info: ["numsp512t1", 512, 510, 512], + name: "numsp512t1", + type: 1, + p: [0xC7, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), + a: [0x01].reverse(), + d: [0xEF, 0xCB, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), + order: [0x6D, 0xD4, 0xEE, 0x1B, 0xF5, 0x8C, 0x46, 0x67, 0xFF, 0xEC, 0xEF, 0x6D, 0x78, 0x05, 0x46, 0x2A, 0xF5, 0x86, 0xB6, 0x70, 0xC9, 0xD8, 0x3F, 0x9E, 0xBA, 0x91, 0xCF, 0x2F, 0x6D, 0x63, 0xF0, 0xB4, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F].reverse(), + gx: [0xFE, 0x57, 0xEC, 0x99, 0x29, 0xAB, 0xB9, 0xC5, 0x15, 0xF0, 0xC4, 0x7C, 0x42, 0x25, 0xE5, 0x0F, 0xAD, 0x04, 0x89, 0x56, 0x92, 0xC9, 0xBD, 0x78, 0x0F, 0x73, 0x46, 0xEE, 0x4E, 0xC1, 0x21, 0x46, + 0x47, 0x81, 0x3B, 0x27, 0xBE, 0x7E, 0xA1, 0x27, 0x82, 0xA3, 0xC4, 0x4D, 0x9F, 0xE7, 0xD1, 0x2F, 0x33, 0xC5, 0xD3, 0x88, 0x78, 0xCB, 0x18, 0x7A, 0x9C, 0xB6, 0x8D, 0x12, 0x6D, 0x31, 0x8E, 0xDF].reverse(), + gy: [0xE1, 0xF5, 0xE2, 0xC1, 0xC0, 0xDE, 0x6D, 0x32, 0x1F, 0xD0, 0xF1, 0x9B, 0x8A, 0xD3, 0x66, 0x02, 0xFD, 0xC1, 0xEC, 0x2A, 0x86, 0x06, 0x1A, 0x60, 0x62, 0x35, 0x96, 0xE9, 0xF2, 0x53, 0xCA, 0x20, + 0x41, 0x83, 0x9E, 0x90, 0x95, 0x6B, 0x2B, 0xA9, 0x22, 0x9D, 0x25, 0xD8, 0x26, 0xF7, 0x76, 0xE4, 0x6E, 0x25, 0x2A, 0xA8, 0x77, 0xF5, 0xB0, 0x98, 0x71, 0xCA, 0x49, 0x9D, 0xF3, 0xBF, 0x09, 0x6D].reverse(), + cf: 4 +}; + +if (typeof cryptoECC !== "undefined") { + cryptoECC.curves.NUMSP256D1 = curve_numsp256d1; + cryptoECC.curves.NUMSP384D1 = curve_numsp384d1; + cryptoECC.curves.NUMSP512D1 = curve_numsp512d1; + cryptoECC.curves.NUMSP256T1 = curve_numsp256t1; + cryptoECC.curves.NUMSP384T1 = curve_numsp384t1; + cryptoECC.curves.NUMSP512T1 = curve_numsp512t1; +} + +var msrcryptoSha = function(name, der, h, k, blockBytes, blockFunction, truncateTo) { + + var utils = msrcryptoUtilities; + + var hv = h.slice(), + w = new Array(blockBytes), + buffer = [], + blocksProcessed = 0; + + function hashBlocks(message) { + + var blockCount = Math.floor(message.length / blockBytes); + + for (var block = 0; block < blockCount; block++) { + blockFunction(message, block, hv, k, w); + } + + blocksProcessed += blockCount; + + return message.slice(blockCount * blockBytes); + } + + function hashToBytes() { + + var hash = []; + + for (var i = 0; i < hv.length; i++) { + hash = hash.concat(utils.int32ToBytes(hv[i])); + } + + hash.length = truncateTo / 8; + + return hash; + } + + function addPadding(messageBytes) { + + var padLen = blockBytes - messageBytes.length % blockBytes; + + (padLen <= (blockBytes / 8)) && (padLen += blockBytes); + + var padding = utils.getVector(padLen); + + padding[0] = 128; + + var messageLenBits = (messageBytes.length + blocksProcessed * blockBytes) * 8; + + + for (var i = 1; i <= 8; i++) { + padding[padLen - i] = messageLenBits % 0x100; + messageLenBits = Math.floor(messageLenBits / 0x100); + } + return messageBytes.concat(padding); + } + + function computeHash(messageBytes) { + + buffer = hashBlocks(messageBytes); + + return finish(); + } + + function process(messageBytes) { + + buffer = buffer.concat(messageBytes); + + if (buffer.length >= blockBytes) { + + buffer = hashBlocks(buffer); + } + + return; + } + + function finish() { + + if (hashBlocks(addPadding(buffer)).length !== 0) { + throw new Error("buffer.length !== 0"); + } + + var result = hashToBytes(); + + buffer = []; + + hv = h.slice(); + + blocksProcessed = 0; + + return result; + } + + return { + name: name, + computeHash: computeHash, + process: process, + finish: finish, + der: der, + hashLen: truncateTo, + maxMessageSize: 0xFFFFFFFF + }; + +}; + +var msrcryptoSha1 = (function() { + + function hashBlock(message, blockIndex, hv, k, w) { + + var t, i, temp, x0, blockSize = 64, mask = 0xFFFFFFFF; + + var ra = hv[0], + rb = hv[1], + rc = hv[2], + rd = hv[3], + re = hv[4]; + + for (i = 0; i < 16; i++) { + w[i] = utils.bytesToInt32(message, blockIndex * blockSize + i * 4); + } + + for (t = 16; t < 80; t++) { + x0 = w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16]; + w[t] = (x0 << 1) | (x0 >>> 31); + } + + for (i = 0; i < 80; i++) { + + temp = ((ra << 5) | (ra >>> 27)); + + temp += + i >= 60 ? (rb ^ rc ^ rd) : + i >= 40 ? ((rb & rc) ^ (rb & rd) ^ (rc & rd)) : + i >= 20 ? (rb ^ rc ^ rd) : + ((rb & rc) ^ ((~rb) & rd)); + + temp += (re + k[i] + w[i]); + + re = rd; + rd = rc; + rc = ((rb << 30) | (rb >>> 2)); + rb = ra; + ra = temp; + } + + hv[0] += ra & mask; + hv[1] += rb & mask; + hv[2] += rc & mask; + hv[3] += rd & mask; + hv[4] += re & mask; + + return hv; + } + + var utils = msrcryptoUtilities, + upd = utils.unpackData, + h = upd("Z0UjAe/Nq4mYutz+EDJUdsPS4fA=", 4, 1), + k = upd("WoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroY8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdY", 4, 1), + der = upd("MCEwCQYFKw4DAhoFAAQU"); + + return { + sha1: function() { + return msrcryptoSha("SHA-1", der, h, k, 64, hashBlock, 160); + } + }; + +})(); + +if (typeof operations !== "undefined") { + + msrcryptoSha1.instances = {}; + + msrcryptoSha1.getInstance = function(id) { + return msrcryptoSha1.instances[id] || (msrcryptoSha1.instances[id] = msrcryptoSha1.sha1()); + }; + + msrcryptoSha1.deleteInstance = function(id) { + msrcryptoSha1.instances[id] = null; + delete msrcryptoSha1.instances[id]; + }; + + msrcryptoSha1.hash = function(p) { + + if (p.operationSubType === "process") { + msrcryptoSha1.sha1.process(p.buffer); + return; + } + + if (p.operationSubType === "finish") { + return msrcryptoSha1.sha1.finish(); + } + + return msrcryptoSha1.sha1().computeHash(p.buffer); + + }; + + operations.register("digest", "SHA-1", msrcryptoSha1.hash); + +} + +msrcryptoHashFunctions["SHA-1"] = msrcryptoSha1.sha1; + +var msrcryptoSha256 = (function() { + + var utils = msrcryptoUtilities; + + function hashBlock(message, blockIndex, hv, k, w) { + + var t, i, temp, x0, x1, blockSize = 64, mask = 0xFFFFFFFF; + + var ra = hv[0], + rb = hv[1], + rc = hv[2], + rd = hv[3], + re = hv[4], + rf = hv[5], + rg = hv[6], + rh = hv[7]; + + for (i = 0; i < 16; i++) { + w[i] = utils.bytesToInt32(message, blockIndex * blockSize + i * 4); + } + + for (t = 16; t < 64; t++) { + + x0 = w[t - 15]; + x1 = w[t - 2]; + + w[t] = (((x1 >>> 17) | (x1 << 15)) ^ ((x1 >>> 19) | (x1 << 13)) ^ (x1 >>> 10)) + + w[t - 7] + + (((x0 >>> 7) | (x0 << 25)) ^ ((x0 >>> 18) | (x0 << 14)) ^ (x0 >>> 3)) + + w[t - 16]; + + w[t] = w[t] & mask; + } + + for (i = 0; i < 64; i++) { + + temp = rh + + ((re >>> 6 | re << 26) ^ (re >>> 11 | re << 21) ^ (re >>> 25 | re << 7)) + + ((re & rf) ^ ((~re) & rg)) + + k[i] + w[i]; + + rd += temp; + + temp += ((ra >>> 2 | ra << 30) ^ (ra >>> 13 | ra << 19) ^ (ra >>> 22 | ra << 10)) + + ((ra & (rb ^ rc)) ^ (rb & rc)); + + rh = rg; + rg = rf; + rf = re; + re = rd; + rd = rc; + rc = rb; + rb = ra; + ra = temp; + + } + + hv[0] = (hv[0] + ra) >>> 0; + hv[1] = (hv[1] + rb) >>> 0; + hv[2] = (hv[2] + rc) >>> 0; + hv[3] = (hv[3] + rd) >>> 0; + hv[4] = (hv[4] + re) >>> 0; + hv[5] = (hv[5] + rf) >>> 0; + hv[6] = (hv[6] + rg) >>> 0; + hv[7] = (hv[7] + rh) >>> 0; + + return hv; + } + + var k256, h224, h256, der224, der256, upd = utils.unpackData; + + h224 = upd("wQWe2DZ81QcwcN0X9w5ZOf/ACzFoWBURZPmPp776T6Q", 4, 1); + + h256 = upd("agnmZ7tnroU8bvNypU/1OlEOUn+bBWiMH4PZq1vgzRk", 4, 1); + + k256 = upd("QoovmHE3RJG1wPvP6bXbpTlWwltZ8RHxkj+CpKscXtXYB6qYEoNbASQxhb5VDH3Dcr5ddIDesf6b3AanwZvxdOSbacHvvkeGD8GdxiQMocwt6SxvSnSEqlywqdx2+YjamD5RUqgxxm2wAyfIv1l/x8bgC/PVp5FHBspjURQpKWcntwqFLhshOE0sbfxTOA0TZQpzVHZqCruBwskuknIshaK/6KGoGmZLwkuLcMdsUaPRkugZ1pkGJPQONYUQaqBwGaTBFh43bAgnSHdMNLC8tTkcDLNO2KpKW5zKT2gub/N0j4LueKVjb4TIeBSMxwIIkL7/+qRQbOu++aP3xnF48g", 4, 1); + + der224 = upd("MC0wDQYJYIZIAWUDBAIEBQAEHA"); + + der256 = upd("MDEwDQYJYIZIAWUDBAIBBQAEIA"); + + return { + sha224: function() { + return msrcryptoSha("SHA-224", der224, h224, k256, 64, hashBlock, 224); + }, + sha256: function() { + return msrcryptoSha("SHA-256", der256, h256, k256, 64, hashBlock, 256); + } + }; +})(); + +if (typeof operations !== "undefined") { + + msrcryptoSha256.instance224 = msrcryptoSha256.instance224 || msrcryptoSha256.sha224(); + msrcryptoSha256.instance256 = msrcryptoSha256.instance256 || msrcryptoSha256.sha256(); + + msrcryptoSha256.instances = {}; + + msrcryptoSha256.getInstance224 = function(id) { + return msrcryptoSha256.instances[id] || (msrcryptoSha256.instances[id] = msrcryptoSha256.sha224()); + }; + + msrcryptoSha256.getInstance256 = function(id) { + return msrcryptoSha256.instances[id] || (msrcryptoSha256.instances[id] = msrcryptoSha256.sha256()); + }; + + msrcryptoSha256.deleteInstance = function(id) { + msrcryptoSha256.instances[id] = null; + delete msrcryptoSha256.instances[id]; + }; + + msrcryptoSha256.hash256 = function(p) { + + if (p.operationSubType === "process") { + msrcryptoSha256.getInstance256(p.workerid).process(p.buffer); + return null; + } + + if (p.operationSubType === "finish") { + + var result = msrcryptoSha256.getInstance256(p.workerid).finish(); + msrcryptoSha256.deleteInstance(p.workerid); + return result; + } + + if (p.operationSubType === "abort") { + msrcryptoSha256.deleteInstance(p.workerid); + return; + } + + return msrcryptoSha256.instance256.computeHash(p.buffer); + + }; + + msrcryptoSha256.hash224 = function(p) { + + if (p.operationSubType === "process") { + msrcryptoSha256.getInstance224(p.workerid).process(p.buffer); + return; + } + + if (p.operationSubType === "finish") { + var result = msrcryptoSha256.getInstance224(p.workerid).finish(); + } + + if (p.operationSubType === "abort") { + msrcryptoSha224.deleteInstance(p.workerid); + return; + } + + return msrcryptoSha256.instance224.computeHash(p.buffer); + + }; + + operations.register("digest", "SHA-224", msrcryptoSha256.hash224); + operations.register("digest", "SHA-256", msrcryptoSha256.hash256); +} + +msrcryptoHashFunctions["SHA-224"] = msrcryptoSha256.sha224; +msrcryptoHashFunctions["SHA-256"] = msrcryptoSha256.sha256; + +var msrcryptoSha512 = (function() { + + var utils = msrcryptoUtilities; + + function add(x0, x1, y0, y1, resultArray) { + + var lowSum = (x1 + y1) | 0; + + var carry = (lowSum >>> 0 < y1 >>> 0); + + resultArray[0] = (x0 + y0 + carry) | 0; + resultArray[1] = lowSum; + + return; + } + + function hashBlock(message, blockIndex, hv, k, w) { + + var t, i, blockBytes = 128, + tah, tal, tbh, tbl, xh, xl, + tc = [], td = [], te = [], index; + + var ah = hv[0], al = hv[1], + bh = hv[2], bl = hv[3], + ch = hv[4], cl = hv[5], + dh = hv[6], dl = hv[7], + eh = hv[8], el = hv[9], + fh = hv[10], fl = hv[11], + gh = hv[12], gl = hv[13], + hh = hv[14], hl = hv[15]; + + for (t = 0; t < 32; t++) { + index = blockIndex * blockBytes + t * 4; + w[t] = message.slice(index, index + 4); + w[t] = (w[t][0] << 24) | (w[t][1] << 16) | (w[t][2] << 8) | w[t][3]; + } + + for (t = 32; t < 160; t += 2) { + + xh = w[t - 30]; + xl = w[t - 29]; + + tah = (xh >>> 1 | xl << 31) ^ (xh >>> 8 | xl << 24) ^ (xh >>> 7); + tal = (xl >>> 1 | xh << 31) ^ (xl >>> 8 | xh << 24) ^ (xl >>> 7 | xh << 25); + + xh = w[t - 4]; + xl = w[t - 3]; + + tbh = (xh >>> 19 | xl << 13) ^ (xl >>> 29 | xh << 3) ^ (xh >>> 6); + tbl = (xl >>> 19 | xh << 13) ^ (xh >>> 29 | xl << 3) ^ (xl >>> 6 | xh << 26); + + add(tbh, tbl, w[t - 14], w[t - 13], tc); + + add(tah, tal, tc[0], tc[1], tc); + + add(w[t - 32], w[t - 31], tc[0], tc[1], tc); + + w[t] = tc[0]; w[t + 1] = tc[1]; + } + + for (i = 0; i < 160; i += 2) { + + tah = (eh >>> 14 | el << 18) ^ (eh >>> 18 | el << 14) ^ (el >>> 9 | eh << 23); + tal = (el >>> 14 | eh << 18) ^ (el >>> 18 | eh << 14) ^ (eh >>> 9 | el << 23); + + tbh = (eh & fh) ^ (gh & ~eh); + tbl = (el & fl) ^ (gl & ~el); + + add(hh, hl, tah, tal, tc); + + add(tbh, tbl, k[i], k[i + 1], td); + + add(tc[0], tc[1], w[i], w[i + 1], te); + + add(td[0], td[1], te[0], te[1], te); + + add(te[0], te[1], dh, dl, tc); + dh = tc[0]; dl = tc[1]; + + tal = (al >>> 28 | ah << 4) ^ (ah >>> 2 | al << 30) ^ (ah >>> 7 | al << 25); + tah = (ah >>> 28 | al << 4) ^ (al >>> 2 | ah << 30) ^ (al >>> 7 | ah << 25); + + tbl = (al & (bl ^ cl)) ^ (bl & cl); + tbh = (ah & (bh ^ ch)) ^ (bh & ch); + + add(te[0], te[1], tah, tal, tc); + tah = tc[0]; tal = tc[1]; + + add(tbh, tbl, tah, tal, tc); + tah = tc[0]; tal = tc[1]; + + hh = gh; + hl = gl; + gh = fh; + gl = fl; + fh = eh; + fl = el; + eh = dh; + el = dl; + dh = ch; + dl = cl; + ch = bh; + cl = bl; + bh = ah; + bl = al; + ah = tah; + al = tal; + } + + + add(hv[0], hv[1], ah, al, tc); + hv[0] = tc[0]; hv[1] = tc[1]; + + add(hv[2], hv[3], bh, bl, tc); + hv[2] = tc[0]; hv[3] = tc[1]; + + add(hv[4], hv[5], ch, cl, tc); + hv[4] = tc[0]; hv[5] = tc[1]; + + add(hv[6], hv[7], dh, dl, tc); + hv[6] = tc[0]; hv[7] = tc[1]; + + add(hv[8], hv[9], eh, el, tc); + hv[8] = tc[0]; hv[9] = tc[1]; + + add(hv[10], hv[11], fh, fl, tc); + hv[10] = tc[0]; hv[11] = tc[1]; + + add(hv[12], hv[13], gh, gl, tc); + hv[12] = tc[0]; hv[13] = tc[1]; + + add(hv[14], hv[15], hh, hl, tc); + hv[14] = tc[0]; hv[15] = tc[1]; + + return hv; + } + + var h384, h512, k512, + der384, der512, der512_224, der512_256, + upd = utils.unpackData; + + h384 = upd("y7udXcEFnthimikqNnzVB5FZAVowcN0XFS/s2PcOWTlnMyZn/8ALMY60SodoWBUR2wwuDWT5j6dHtUgdvvpPpA==", 4, 1); + + h512 = upd("agnmZ/O8yQi7Z66FhMqnOzxu83L+lPgrpU/1Ol8dNvFRDlJ/reaC0ZsFaIwrPmwfH4PZq/tBvWtb4M0ZE34heQ", 4, 1); + + k512 = upd( + "QoovmNcoriJxN0SRI+9lzbXA+8/sTTsv6bXbpYGJ27w5VsJb80i1OFnxEfG2BdAZkj+CpK8ZT5urHF7" + + "V2m2BGNgHqpijAwJCEoNbAUVwb74kMYW+TuSyjFUMfcPV/7Ticr5ddPJ7iW+A3rH+OxaWsZvcBqclxx" + + "I1wZvxdM9pJpTkm2nBnvFK0u++R4Y4TyXjD8GdxouM1bUkDKHMd6ycZS3pLG9ZKwJ1SnSEqm6m5INcs" + + "KncvUH71Hb5iNqDEVO1mD5RUu5m36uoMcZtLbQyELADJ8iY+yE/v1l/x77vDuTG4AvzPaiPwtWnkUeT" + + "CqclBspjUeADgm8UKSlnCg5ucCe3CoVG0i/8LhshOFwmySZNLG38WsQq7VM4DROdlbPfZQpzVIuvY95" + + "2agq7PHeyqIHCyS5H7a7mknIshRSCNTuiv+ihTPEDZKgaZku8QjABwkuLcND4l5HHbFGjBlS+MNGS6B" + + "nW71IY1pkGJFVlqRD0DjWFV3EgKhBqoHAyu9G4GaTBFrjS0MgeN2wIUUGrUydId0zfjuuZNLC8teGbS" + + "Kg5HAyzxclaY07YqkrjQYrLW5zKT3dj43NoLm/z1rK4o3SPgu5d77L8eKVjb0MXL2CEyHgUofCrcozH" + + "AggaZDnskL7/+iNjHiikUGzr3oK96b75o/eyxnkVxnF48uNyUyvKJz7O6iZhnNGGuMchwMIH6tp91s3" + + "g6x71fU9/7m7ReAbwZ6pyF2+6CmN9xaLImKYRP5gEvvkNrhtxCzUTHEcbKNt39SMEfYQyyqt7QMckkz" + + "yevgoVyb68Qx1nxJwQDUxMxdS+yz5Ctll/KZz8ZX4qX8tvqzrW+uxsRBmMSkdYFw==", 4, 1); + + der384 = upd("MEEwDQYJYIZIAWUDBAICBQAEMA"); + der512 = upd("MFEwDQYJYIZIAWUDBAIDBQAEQA"); + der512_224 = upd("MC0wDQYJYIZIAWUDBAIFBQAEHA"); + der512_256 = upd("MDEwDQYJYIZIAWUDBAIGBQAEIA"); + + return { + sha384: function() { return msrcryptoSha("SHA-384", der384, h384, k512, 128, hashBlock, 384); }, + sha512: function() { return msrcryptoSha("SHA-512", der512, h512, k512, 128, hashBlock, 512); }, + sha512_224: function() { return msrcryptoSha("SHA-512.224", der512_224, h512, k512, 128, hashBlock, 224); }, + sha512_256: function() { return msrcryptoSha("SHA-512.256", der512_256, h512, k512, 128, hashBlock, 256); } + }; + +})(); + +if (typeof operations !== "undefined") { + + msrcryptoSha512.instances = {}; + + msrcryptoSha512.getInstance384 = function(id) { + return msrcryptoSha512.instances[id] || (msrcryptoSha512.instances[id] = msrcryptoSha512.sha384()); + }; + + msrcryptoSha512.getInstance512 = function(id) { + return msrcryptoSha512.instances[id] || (msrcryptoSha512.instances[id] = msrcryptoSha512.sha512()); + }; + + msrcryptoSha512.deleteInstance = function(id) { + msrcryptoSha512.instances[id] = null; + delete msrcryptoSha512.instances[id]; + }; + + msrcryptoSha512.hash384 = function(p) { + + if (p.operationSubType === "process") { + msrcryptoSha512.sha384.process(p.buffer); + return; + } + + if (p.operationSubType === "finish") { + return msrcryptoSha512.sha384.finish(); + } + + return msrcryptoSha512.sha384().computeHash(p.buffer); + + }; + + msrcryptoSha512.hash512 = function(p) { + + if (p.operationSubType === "process") { + msrcryptoSha512.sha512.process(p.buffer); + return; + } + + if (p.operationSubType === "finish") { + return msrcryptoSha512.sha512.finish(); + } + + return msrcryptoSha512.sha512().computeHash(p.buffer); + + }; + + operations.register("digest", "SHA-384", msrcryptoSha512.hash384); + operations.register("digest", "SHA-512", msrcryptoSha512.hash512); +} + +msrcryptoHashFunctions["SHA-384"] = msrcryptoSha512.sha384; +msrcryptoHashFunctions["SHA-512"] = msrcryptoSha512.sha512; + +var msrcryptoHmac = function( keyBytes, hashFunction ) { + + var blockSize = { "384": 128, "512": 128 }[hashFunction.name.replace( /SHA-/, "" )] || 64; + var ipad; + var opad; + var paddedKey = padKey(); + var keyXorOpad; + var keyXorIpad; + var k0IpadText; + + function xorArrays( array1, array2 ) { + var newArray = new Array( array1 ); + for ( var j = 0; j < array1.length; j++ ) { + newArray[j] = array1[j] ^ array2[j]; + } + return newArray; + } + + function padZeros( bytes, paddedLength ) { + var paddedArray = bytes.slice(); + for ( var j = bytes.length; j < paddedLength; j++ ) { + paddedArray.push( 0 ); + } + return paddedArray; + } + + function padKey() { + + if ( keyBytes.length === blockSize ) { + return keyBytes; + } + + if ( keyBytes.length > blockSize ) { + return padZeros( hashFunction.computeHash( keyBytes ), blockSize ); + } + + return padZeros( keyBytes, blockSize ); + + } + + function processHmac( messageBytes ) { + + if ( !k0IpadText ) { + k0IpadText = keyXorIpad.concat( messageBytes ); + hashFunction.process( k0IpadText ); + } else { + hashFunction.process( messageBytes ); + } + return; + } + + function finishHmac() { + + var hashK0IpadText = hashFunction.finish(); + + var k0IpadK0OpadText = keyXorOpad.concat( hashK0IpadText ); + + return hashFunction.computeHash( k0IpadK0OpadText ); + } + + function clearState() { + keyBytes = null; + hashFunction = null; + paddedKey = null; + } + + ipad = new Array( blockSize ); + opad = new Array( blockSize ); + for ( var i = 0; i < blockSize; i++ ) { ipad[i] = 0x36; opad[i] = 0x5c; } + keyXorIpad = xorArrays( paddedKey, ipad ); + keyXorOpad = xorArrays( paddedKey, opad ); + return { + + computeHmac: function( dataBytes, key, hashAlgorithm ) { + + processHmac( dataBytes ); + var result = finishHmac(); + clearState(); + return result; + }, + + process: function( dataBytes, key, hashAlgorithm ) { + + processHmac( dataBytes ); + return null; + }, + + finish: function( key, hashAlgorithm ) { + + var result = finishHmac(); + clearState(); + return result; + } + + }; +}; + +if ( typeof operations !== "undefined" ) { + + var hmacInstances = {}; + + msrcryptoHmac.signHmac = function( p ) { + + var hashName = p.keyHandle.algorithm.hash.name.toUpperCase(), + hashAlg = msrcryptoHashFunctions[hashName](), + result, + id = p.workerid; + + if ( !hmacInstances[id] ) { + hmacInstances[id] = msrcryptoHmac( p.keyData, hashAlg ); + } + + if ( p.operationSubType === "process" ) { + hmacInstances[id].process( p.buffer ); + return null; + } + + if ( p.operationSubType === "finish" ) { + result = hmacInstances[id].finish(); + hmacInstances[id] = null; + return result; + } + + result = hmacInstances[id].computeHmac( p.buffer ); + hmacInstances[id] = null; + return result; + }; + + msrcryptoHmac.verifyHmac = function( p ) { + + var hashName = p.keyHandle.algorithm.hash.name.toUpperCase(), + hashAlg = msrcryptoHashFunctions[hashName](), + result, + id = p.workerid; + + if ( !hmacInstances[id] ) { + hmacInstances[id] = msrcryptoHmac( p.keyData, hashAlg ); + } + + if ( p.operationSubType === "process" ) { + hmacInstances[id].process( p.buffer ); + return null; + } + + if ( p.operationSubType === "finish" ) { + result = hmacInstances[id].finish(); + result = msrcryptoUtilities.arraysEqual( result, p.signature ); + hmacInstances[id] = null; + return result; + } + + result = hmacInstances[id].computeHmac( p.buffer ); + result = msrcryptoUtilities.arraysEqual( result, p.signature ); + hmacInstances[id] = null; + return result; + }; + + msrcryptoHmac.generateKey = function( p ) { + + var defaultKeyLengthBits = { "SHA-1": 512, "SHA-224": 512, "SHA-256": 512, "SHA-384": 1024, "SHA-512": 1024 }; + + var keyLengthBits = p.algorithm.length || defaultKeyLengthBits[p.algorithm.hash.name.toUpperCase()]; + + var keyData = msrcryptoPseudoRandom.getBytes( Math.ceil( keyLengthBits / 8 ) ); + + var unusedBits = ( keyData.length * 8 ) - keyLengthBits; + if ( unusedBits > 0 ) { + keyData[keyData.length - 1] &= ( 0xFF << unusedBits ) & 0xFF; + } + + return { + type: "keyGeneration", + keyData: keyData, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: null || p.usages, + type: "secret" + } + }; + }; + + msrcryptoHmac.importKey = function( p ) { + var keyObject, + keyBits = p.keyData.length * 8; + + if ( p.format === "jwk" ) { + keyObject = msrcryptoJwk.jwkToKey( p.keyData, p.algorithm, ["k"] ); + keyObject.alg = keyObject.alg.replace( "HS", "SHA-" ); + } else if ( p.format === "raw" ) { + keyObject = { k: msrcryptoUtilities.toArray( p.keyData ) }; + } else { + throw new Error( "unsupported import format" ); + } + + return { + type: "keyImport", + keyData: keyObject.k, + keyHandle: { + algorithm: { name: "HMAC", hash: { name: p.algorithm.hash.name } }, + extractable: p.extractable || keyObject.extractable, + usages: p.usages, + type: "secret" + } + }; + + }; + + msrcryptoHmac.exportKey = function( p ) { + + if ( p.format === "jwk" ) { + return { type: "keyExport", keyHandle: msrcryptoJwk.keyToJwk( p.keyHandle, p.keyData ) }; + } + + if ( p.format === "raw" ) { + return { type: "keyExport", keyHandle: p.keyData }; + } + + throw new Error( "unsupported export format" ); + }; + + operations.register( "importKey", "HMAC", msrcryptoHmac.importKey ); + operations.register( "exportKey", "HMAC", msrcryptoHmac.exportKey ); + operations.register( "generateKey", "HMAC", msrcryptoHmac.generateKey ); + operations.register( "sign", "HMAC", msrcryptoHmac.signHmac ); + operations.register( "verify", "HMAC", msrcryptoHmac.verifyHmac ); +} + +var msrcryptoBlockCipher = (function() { + + var aesConstants, + x2, + x3, + x14, + x13, + x11, + x9, + sBoxTable, + invSBoxTable, + rConTable; + + return { + + aes: function( keyBytes) { + + if (!aesConstants) { + aesConstants = msrcryptoUtilities.unpackData("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", 256, false); + x2 = aesConstants[0]; + x3 = aesConstants[1]; + x14 = aesConstants[2]; + x13 = aesConstants[3]; + x11 = aesConstants[4]; + x9 = aesConstants[5]; + sBoxTable = aesConstants[6]; + invSBoxTable = aesConstants[7]; + rConTable = aesConstants[8]; + } + + var blockSize = 128, + keyLength, + nK, + nB = 4, + nR, + key; + + keyLength = keyBytes.length * 8; + + switch (keyLength) { + case 128: + case 192: + case 256: + break; + default: + throw new Error("Unsupported keyLength"); + } + + nK = keyLength / 32; + nR = nK + 6; + + var shiftRows = function(a) { + var tmp = a[1]; a[1] = a[5]; a[5] = a[9]; a[9] = a[13]; a[13] = tmp; + tmp = a[2]; a[2] = a[10]; a[10] = tmp; + tmp = a[6]; a[6] = a[14]; a[14] = tmp; + tmp = a[15]; a[15] = a[11]; a[11] = a[7]; a[7] = a[3]; a[3] = tmp; + }; + + var invShiftRows = function(a) { + var tmp = a[13]; a[13] = a[9]; a[9] = a[5]; a[5] = a[1]; a[1] = tmp; + tmp = a[10]; a[10] = a[2]; a[2] = tmp; + tmp = a[14]; a[14] = a[6]; a[6] = tmp; + tmp = a[3]; a[3] = a[7]; a[7] = a[11]; a[11] = a[15]; a[15] = tmp; + }; + + var mixColumns = function(state) { + var a = state[0], b = state[1], c = state[2], d = state[3], + e = state[4], f = state[5], g = state[6], h = state[7], + i = state[8], j = state[9], k = state[10], l = state[11], + m = state[12], n = state[13], o = state[14], p = state[15]; + + state[0] = x2[a] ^ x3[b] ^ c ^ d; + state[1] = a ^ x2[b] ^ x3[c] ^ d; + state[2] = a ^ b ^ x2[c] ^ x3[d]; + state[3] = x3[a] ^ b ^ c ^ x2[d]; + state[4] = x2[e] ^ x3[f] ^ g ^ h; + state[5] = e ^ x2[f] ^ x3[g] ^ h; + state[6] = e ^ f ^ x2[g] ^ x3[h]; + state[7] = x3[e] ^ f ^ g ^ x2[h]; + state[8] = x2[i] ^ x3[j] ^ k ^ l; + state[9] = i ^ x2[j] ^ x3[k] ^ l; + state[10] = i ^ j ^ x2[k] ^ x3[l]; + state[11] = x3[i] ^ j ^ k ^ x2[l]; + state[12] = x2[m] ^ x3[n] ^ o ^ p; + state[13] = m ^ x2[n] ^ x3[o] ^ p; + state[14] = m ^ n ^ x2[o] ^ x3[p]; + state[15] = x3[m] ^ n ^ o ^ x2[p]; + }; + + var invMixColumns = function(state) { + var a = state[0], b = state[1], c = state[2], d = state[3], + e = state[4], f = state[5], g = state[6], h = state[7], + i = state[8], j = state[9], k = state[10], l = state[11], + m = state[12], n = state[13], o = state[14], p = state[15]; + + state[0] = x14[a] ^ x11[b] ^ x13[c] ^ x9[d]; + state[1] = x9[a] ^ x14[b] ^ x11[c] ^ x13[d]; + state[2] = x13[a] ^ x9[b] ^ x14[c] ^ x11[d]; + state[3] = x11[a] ^ x13[b] ^ x9[c] ^ x14[d]; + state[4] = x14[e] ^ x11[f] ^ x13[g] ^ x9[h]; + state[5] = x9[e] ^ x14[f] ^ x11[g] ^ x13[h]; + state[6] = x13[e] ^ x9[f] ^ x14[g] ^ x11[h]; + state[7] = x11[e] ^ x13[f] ^ x9[g] ^ x14[h]; + state[8] = x14[i] ^ x11[j] ^ x13[k] ^ x9[l]; + state[9] = x9[i] ^ x14[j] ^ x11[k] ^ x13[l]; + state[10] = x13[i] ^ x9[j] ^ x14[k] ^ x11[l]; + state[11] = x11[i] ^ x13[j] ^ x9[k] ^ x14[l]; + state[12] = x14[m] ^ x11[n] ^ x13[o] ^ x9[p]; + state[13] = x9[m] ^ x14[n] ^ x11[o] ^ x13[p]; + state[14] = x13[m] ^ x9[n] ^ x14[o] ^ x11[p]; + state[15] = x11[m] ^ x13[n] ^ x9[o] ^ x14[p]; + }; + + var xorWord = function(a, b) { + return [a[0] ^ b[0], a[1] ^ b[1], a[2] ^ b[2], a[3] ^ b[3]]; + }; + + var addRoundKey = function(state, keySchedule, offset) { + for (var i = 0; i < state.length; i += 1) { + state[i] ^= keySchedule[i + offset]; + } + }; + + var rotWord = function(word) { + var a = word[0]; + word[0] = word[1]; word[1] = word[2]; word[2] = word[3]; word[3] = a; + }; + + var subWord = function(word) { + for (var i = 0; i < word.length; i += 1) { + word[i] = sBoxTable[word[i]]; + } + }; + + var invSubWord = function(word) { + for (var i = 0; i < word.length; i += 1) { + word[i] = invSBoxTable[word[i]]; + } + }; + + var getWord = function(tab, i) { + return [tab[4 * i], tab[4 * i + 1], tab[4 * i + 2], tab[4 * i + 3]]; + }; + + var setWord = function(left, right, indexL, indexR) { + left[4 * indexL] = right[4 * indexR]; + left[4 * indexL + 1] = right[4 * indexR + 1]; + left[4 * indexL + 2] = right[4 * indexR + 2]; + left[4 * indexL + 3] = right[4 * indexR + 3]; + }; + + var expandKey = function(keyIn) { + var temp, res = [], i = 0; + while (i < 4 * nK) { + res.push( keyIn[i++]); + } + + i = nK; + while (i < nB * (nR + 1)) { + temp = getWord(res, i - 1); + if (i % nK === 0) { + var index = i / nK; + var rcon = [rConTable[index], 0, 0, 0]; + rotWord(temp); + subWord(temp); + temp = xorWord(temp, rcon); + } else if (nK > 6 && i % nK === 4) { + subWord(temp); + } + var newWord = xorWord(getWord(res, i - nK), temp); + setWord(res, newWord, i, 0); + i += 1; + } + return res; + }; + + key = expandKey(keyBytes); + + return { + + encrypt: function(dataBytes) { + var state = dataBytes, + round; + + addRoundKey(state, key, 0); + for (round = 1; round <= nR - 1; round += 1) { + subWord(state); + shiftRows(state); + mixColumns(state); + addRoundKey(state, key, 4 * round * nB); + } + subWord(state); + shiftRows(state); + addRoundKey(state, key, 4 * nR * nB); + + return state; + }, + + decrypt: function(dataBytes) { + var state = dataBytes, + round; + + addRoundKey(state, key, 4 * nR * nB); + for (round = nR - 1; round >= 1; round -= 1) { + invShiftRows(state); + invSubWord(state); + addRoundKey(state, key, 4 * round * nB); + invMixColumns(state); + } + invShiftRows(state); + invSubWord(state); + addRoundKey(state, key, 0); + + return state; + }, + + clear: function() { + }, + + keyLength: keyLength, + + blockSize: blockSize + + }; + } + + }; + +})(); + +var msrcryptoPadding = msrcryptoPadding || {}; + +msrcryptoPadding.pkcsv7 = function(blockSize) { + + function pad(messageBlocks) { + + var lastIndex = messageBlocks.length - 1 >= 0 ? messageBlocks.length - 1 : 0; + var lastBlock = messageBlocks[lastIndex]; + var lastBlockLength = lastBlock.length; + var createNewBlock = lastBlockLength === blockSize; + + if (createNewBlock) { + var newBlock = []; + var i; + for (i = 0; i < blockSize; i += 1) { + newBlock.push(blockSize); + } + messageBlocks.push(newBlock); + } else { + var byteToAdd = blockSize - lastBlockLength & 0xff; + while (lastBlock.length !== blockSize) { + lastBlock.push(byteToAdd); + } + } + + } + + function unpad(messageBytes) { + + var verified = true; + + if (messageBytes.length % blockSize !== 0) { + verified = false; + } + + var lastBlock = messageBytes.slice(-blockSize); + + var padLen = lastBlock[lastBlock.length - 1]; + + for (var i = 0; i < blockSize; i++) { + var isPaddingElement = blockSize - i <= padLen; + var isCorrectValue = lastBlock[i] === padLen; + verified = (isPaddingElement ? isCorrectValue : true) && verified; + } + + var trimLen = verified ? padLen : 0; + + messageBytes.length -= trimLen; + + return verified; + } + + return { + pad: pad, + unpad: unpad + }; + +}; + +var msrcryptoCbc = function(blockCipher) { + + var blockSize = blockCipher.blockSize / 8; + + var paddingScheme = msrcryptoPadding.pkcsv7(blockSize); + + var mergeBlocks = function(tab) { + var res = [], i, j; + for (i = 0; i < tab.length; i += 1) { + var block = tab[i]; + for (j = 0; j < block.length; j += 1) { + res.push(block[j]); + } + } + return res; + }; + + function getBlocks(dataBytes) { + + var blocks = []; + + mBuffer = mBuffer.concat(dataBytes); + + var blockCount = Math.floor(mBuffer.length / blockSize); + + for (var i = 0; i < blockCount; i++) { + blocks.push(mBuffer.slice(i * blockSize, (i + 1) * blockSize)); + } + + mBuffer = mBuffer.slice(blockCount * blockSize); + + return blocks; + } + + function encryptBlocks(blocks) { + + var result = [], + toEncrypt; + + for (var i = 0; i < blocks.length; i++) { + toEncrypt = msrcryptoUtilities.xorVectors(mIvBytes, blocks[i]); + result.push(blockCipher.encrypt(toEncrypt)); + mIvBytes = result[i]; + } + + return result; + } + + function decryptBlocks(blocks) { + + var result = [], + toDecrypt, + decrypted; + + for (var i = 0; i < blocks.length; i += 1) { + toDecrypt = blocks[i].slice(0, blocks[i].length); + decrypted = blockCipher.decrypt(toDecrypt); + result.push(msrcryptoUtilities.xorVectors(mIvBytes, decrypted)); + mIvBytes = blocks[i]; + } + + return result; + } + + function clearState() { + mBuffer = []; + mResultBuffer = []; + mIvBytes = null; + } + + var mBuffer = [], + mResultBuffer = [], + mIvBytes; + + return { + + init: function(ivBytes) { + + if (ivBytes.length !== blockSize) { + throw new Error("Invalid iv size"); + } + + mIvBytes = ivBytes.slice(); + }, + + encrypt: function(plainBytes) { + + var result = encryptBlocks(getBlocks(plainBytes)); + mResultBuffer = mResultBuffer.concat(mergeBlocks(result)); + + return this.finishEncrypt(); + }, + + processEncrypt: function(plainBytes) { + + var result = mergeBlocks(encryptBlocks(getBlocks(plainBytes))); + + return result; + }, + + finishEncrypt: function() { + + var blocks = mBuffer.length === 1 ? [[mBuffer[0]]] : [mBuffer]; + + paddingScheme.pad(blocks); + + var result = mResultBuffer.concat(mergeBlocks(encryptBlocks(blocks))); + + clearState(); + + return result; + }, + + decrypt: function(cipherBytes) { + + this.processDecrypt(cipherBytes); + + return this.finishDecrypt(); + }, + + processDecrypt: function(cipherBytes) { + + var result = decryptBlocks(getBlocks(cipherBytes)); + + mResultBuffer = mResultBuffer.concat(mergeBlocks(result)); + + return; + }, + + finishDecrypt: function() { + + var result = mResultBuffer; + + var verified = paddingScheme.unpad(result); + + clearState(); + + return result; + } + + }; +}; + +if (typeof operations !== "undefined") { + + var cbcInstances = {}; + + msrcryptoCbc.workerEncrypt = function(p) { + + var result, + id = p.workerid; + + if (!cbcInstances[id]) { + cbcInstances[id] = msrcryptoCbc(msrcryptoBlockCipher.aes(p.keyData)); + cbcInstances[id].init(p.algorithm.iv); + } + + if (p.operationSubType === "process") { + return cbcInstances[id].processEncrypt(p.buffer); + } + + if (p.operationSubType === "finish") { + result = cbcInstances[id].finishEncrypt(); + cbcInstances[id] = null; + return result; + } + + result = cbcInstances[id].encrypt(p.buffer); + cbcInstances[id] = null; + return result; + }; + + msrcryptoCbc.workerDecrypt = function(p) { + + var result, + id = p.workerid; + + if (!cbcInstances[id]) { + cbcInstances[id] = msrcryptoCbc(msrcryptoBlockCipher.aes(p.keyData)); + cbcInstances[id].init(p.algorithm.iv); + } + + if (p.operationSubType === "process") { + cbcInstances[id].processDecrypt(p.buffer); + return; + } + + if (p.operationSubType === "finish") { + result = cbcInstances[id].finishDecrypt(); + cbcInstances[id] = null; + return result; + } + + result = cbcInstances[id].decrypt(p.buffer); + cbcInstances[id] = null; + return result; + }; + + msrcryptoCbc.generateKey = function(p) { + + if (p.algorithm.length !== 128 && p.algorithm.length !== 192 && p.algorithm.length !== 256) { + throw new Error("invalid key length (should be 128, 192, or 256 bits)"); + } + + return { + type: "keyGeneration", + keyData: msrcryptoPseudoRandom.getBytes(Math.floor(p.algorithm.length / 8)), + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: null || p.usages, + type: "secret" + } + }; + }; + + msrcryptoCbc.importKey = function(p) { + + var keyObject; + var keyBits = p.keyData.length * 8; + + if (p.format === "jwk") { + keyObject = msrcryptoJwk.jwkToKey(p.keyData, p.algorithm, ["k"]); + } else if (p.format === "raw") { + if (keyBits !== 128 && keyBits !== 192 && keyBits !== 256) { + throw new Error("invalid key length (should be 128, 192, or 256 bits)"); + } + keyObject = { k: msrcryptoUtilities.toArray(p.keyData) }; + } else { + throw new Error("unsupported import format"); + } + + p.algorithm.length = keyObject.k.length * 8; + + return { + keyData: keyObject.k, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable || keyObject.extractable, + usages: null || p.usages, + type: "secret" + }, + type: "keyImport" + }; + }; + + msrcryptoCbc.exportKey = function(p) { + + if (p.format === "jwk") { + return { type: "keyExport", keyHandle: msrcryptoJwk.keyToJwk(p.keyHandle, p.keyData) }; + } + + if (p.format === "raw") { + return { type: "keyExport", keyHandle: p.keyData }; + } + + throw new Error("unsupported export format"); + }; + + operations.register("importKey", "AES-CBC", msrcryptoCbc.importKey); + operations.register("exportKey", "AES-CBC", msrcryptoCbc.exportKey); + operations.register("generateKey", "AES-CBC", msrcryptoCbc.generateKey); + operations.register("encrypt", "AES-CBC", msrcryptoCbc.workerEncrypt); + operations.register("decrypt", "AES-CBC", msrcryptoCbc.workerDecrypt); +} + +var msrcryptoGcm = function(blockCipher) { + + var utils = msrcryptoUtilities; + + var mBuffer = [], + mIvBytes, + mAdditionalBytes, + mTagLength, + mJ0, + mJ0inc, + mH = blockCipher.encrypt(utils.getVector(16)), + mGHashState = utils.getVector(16), + mGHashBuffer = [], + mCipherText = [], + mGctrCb, + mBytesProcessed = 0; + + function ghash(hashSubkey, dataBytes) { + + var blockCount = Math.floor(dataBytes.length / 16), + dataBlock; + + for (var i = 0; i < blockCount; i++) { + dataBlock = dataBytes.slice(i * 16, i * 16 + 16); + mGHashState = blockMultiplication(utils.xorVectors(mGHashState, dataBlock), hashSubkey); + } + + mGHashBuffer = dataBytes.slice(blockCount * 16); + + return mGHashState; + } + + function finishGHash() { + + var u = 16 * Math.ceil(mBytesProcessed / 16) - mBytesProcessed; + + var lenA = numberTo8Bytes(mAdditionalBytes.length * 8), + lenC = numberTo8Bytes(mBytesProcessed * 8); + + var p = mGHashBuffer.concat(utils.getVector(u)).concat(lenA).concat(lenC); + + return ghash(mH, p); + + } + + function blockMultiplication(blockX, blockY) { + + var z = utils.getVector(16), + v = blockY.slice(0), + mask, + j, i; + + for (i = 0; i < 128; i++) { + + mask = -getBit(blockX, i) & 0xff; + + for (j = 0; j < 16; j++) { + z[j] = z[j] ^ v[j] & mask; + } + + mask = -(v[15] & 1) & 0xff; + + shiftRight(v); + + v[0] ^= 0xe1 & mask; + } + + return z; + } + + function shiftRight(dataBytes) { + + for (var i = dataBytes.length - 1; i > 0; i--) { + dataBytes[i] = (dataBytes[i - 1] & 1) << 7 | dataBytes[i] >>> 1; + } + dataBytes[0] = dataBytes[0] >>> 1; + + return dataBytes; + } + + function getBit(byteArray, bitNumber) { + var byteIndex = Math.floor(bitNumber / 8); + return byteArray[byteIndex] >> 7 - bitNumber % 8 & 1; + } + + function inc(dataBytes) { + + var carry = 256; + for (var i = 1; i <= 4; i++) { + carry = (carry >>> 8) + dataBytes[dataBytes.length - i]; + dataBytes[dataBytes.length - i] = carry & 255; + } + + return dataBytes; + } + + function gctr(icb, dataBytes) { + + var blockCount = Math.ceil(dataBytes.length / 16), + dataBlock, + result = []; + + if (mGctrCb !== icb) { + mGctrCb = icb.slice(); + } + + for (var block = 0; block < blockCount; block++) { + + dataBlock = dataBytes.slice(block * 16, block * 16 + 16); + + var e = blockCipher.encrypt(mGctrCb.slice()); + + result = result.concat(utils.xorVectors(dataBlock, e)); + + mGctrCb = inc(mGctrCb); + } + + return result; + } + + function numberTo8Bytes(integer) { + return [ + 0, 0, 0, 0, + integer >>> 24 & 255, + integer >>> 16 & 255, + integer >>> 8 & 255, + integer & 255 + ]; + } + + function padBlocks(dataBytes) { + var padLen = 16 * Math.ceil(mAdditionalBytes.length / 16) - mAdditionalBytes.length; + return dataBytes.concat(utils.getVector(padLen)); + } + + function clearState() { + mBytesProcessed = 0; + mBuffer = []; + mCipherText = []; + mGHashState = utils.getVector(16); + mGHashBuffer = []; + mGctrCb = mIvBytes = mAdditionalBytes = null; + } + + function init(ivBytes, additionalBytes, tagLength) { + + mAdditionalBytes = additionalBytes || []; + + mTagLength = isNaN(tagLength) ? 128 : tagLength; + if (mTagLength % 8 !== 0) { + throw msrcryptoUtilities.error("DataError", "tagLength must be a multiple of 8"); + } + + mIvBytes = ivBytes; + + if (mIvBytes.length === 12) { + mJ0 = mIvBytes.concat([0, 0, 0, 1]); + + } else { + var l = 16 * Math.ceil(mIvBytes.length / 16) - mIvBytes.length; + + mJ0 = ghash(mH, + mIvBytes + .concat(utils.getVector(l + 8)) + .concat(numberTo8Bytes(mIvBytes.length * 8))); + + mGHashState = utils.getVector(16); + } + + mJ0inc = inc(mJ0.slice()); + + ghash(mH, padBlocks(mAdditionalBytes)); + } + + function encrypt(plainBytes) { + + mBytesProcessed = plainBytes.length; + + var c = gctr(mJ0inc, plainBytes); + + ghash(mH, c); + + var s = finishGHash(); + + var t = gctr(mJ0, s).slice(0, mTagLength / 8); + + clearState(); + + return c.slice().concat(t); + } + + function decrypt(cipherBytes, tagBytes) { + + mBytesProcessed = cipherBytes.length; + + var p = gctr(mJ0inc, cipherBytes); + + ghash(mH, cipherBytes); + + var s = finishGHash(); + + var t = gctr(mJ0, s).slice(0, mTagLength / 8); + + clearState(); + + if (utils.arraysEqual(t, tagBytes)) { + return p; + } else { + return null; + } + } + + function processEncrypt(plainBytes) { + + mBuffer = mBuffer.concat(plainBytes); + + var fullBlocks = mBuffer.slice(0, Math.floor(mBuffer.length / 16) * 16); + + mBytesProcessed += fullBlocks.length; + + mBuffer = mBuffer.slice(fullBlocks.length); + + var c = gctr(mGctrCb || mJ0inc, fullBlocks); + + mCipherText = mCipherText.concat(c); + + ghash(mH, c); + } + + function processDecrypt(cipherBytes) { + + mBuffer = mBuffer.concat(cipherBytes); + + var fullBlocks = mBuffer.slice(0, Math.floor((mBuffer.length - mTagLength / 8) / 16) * 16); + + mBytesProcessed += fullBlocks.length; + + mBuffer = mBuffer.slice(fullBlocks.length); + + var c = gctr(mGctrCb || mJ0inc, fullBlocks); + + mCipherText = mCipherText.concat(c); + + ghash(mH, fullBlocks); + } + + function finishEncrypt() { + + var c = gctr(mGctrCb, mBuffer); + + mCipherText = mCipherText.concat(c); + + mBytesProcessed += mBuffer.length; + + var s = finishGHash(); + + var t = gctr(mJ0, s).slice(0, mTagLength / 8); + + var result = mCipherText.slice().concat(t); + + clearState(); + + return result; + } + + function finishDecrypt() { + + var tagLength = Math.floor(mTagLength / 8); + + var tagBytes = mBuffer.slice(-tagLength); + + mBuffer = mBuffer.slice(0, mBuffer.length - tagLength); + + var c = gctr(mGctrCb, mBuffer); + + mCipherText = mCipherText.concat(c); + + mBytesProcessed += mBuffer.length; + + var s = finishGHash(); + + var t = gctr(mJ0, s).slice(0, mTagLength / 8); + + var result = mCipherText.slice(); + + clearState(); + + if (utils.arraysEqual(t, tagBytes)) { + return result; + } else { + return null; + } + } + + return { + init: init, + encrypt: encrypt, + decrypt: decrypt, + processEncrypt: processEncrypt, + processDecrypt: processDecrypt, + finishEncrypt: finishEncrypt, + finishDecrypt: finishDecrypt + }; + +}; + +if (typeof operations !== "undefined") { + + var gcmInstances = {}; + + msrcryptoGcm.encrypt = function( p) { + + + var result, + id = p.workerid; + + if (!gcmInstances[id]) { + gcmInstances[id] = msrcryptoGcm(msrcryptoBlockCipher.aes(p.keyData)); + gcmInstances[id].init(p.algorithm.iv, p.algorithm.additionalData, p.algorithm.tagLength); + } + + if (p.operationSubType === "process") { + gcmInstances[id].processEncrypt(p.buffer); + return; + } + + if (p.operationSubType === "finish") { + result = gcmInstances[id].finishEncrypt(); + gcmInstances[id] = null; + return result; + } + + result = gcmInstances[id].encrypt(p.buffer); + gcmInstances[id] = null; + return result; + }; + + msrcryptoGcm.decrypt = function( p) { + + var result, + id = p.workerid; + + if (!gcmInstances[id]) { + gcmInstances[id] = msrcryptoGcm(msrcryptoBlockCipher.aes(p.keyData)); + gcmInstances[id].init(p.algorithm.iv, p.algorithm.additionalData, p.algorithm.tagLength); + } + + if (p.operationSubType === "process") { + gcmInstances[id].processDecrypt(p.buffer); + return; + } + + if (p.operationSubType === "finish") { + result = gcmInstances[id].finishDecrypt(); + gcmInstances[id] = null; + if (result === null) { throw msrcryptoUtilities.error("OperationError", ""); } + return result; + } + + var tagLength = p.algorithm.tagLength ? Math.floor(p.algorithm.tagLength / 8) : 16; + var cipherBytes = p.buffer.slice(0, p.buffer.length - tagLength); + var tagBytes = p.buffer.slice(-tagLength); + + result = gcmInstances[id].decrypt(cipherBytes, tagBytes); + gcmInstances[id] = null; + + if (result === null) { throw msrcryptoUtilities.error("OperationError", ""); } + + return result; + }; + + msrcryptoGcm.generateKey = function( p) { + + if (p.algorithm.length !== 128 && p.algorithm.length !== 192 && p.algorithm.length !== 256) { + throw new Error("invalid key length (should be 128, 192, or 256 bits)"); + } + + return { + type: "keyGeneration", + keyData: msrcryptoPseudoRandom.getBytes(Math.floor(p.algorithm.length / 8)), + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: null || p.usages, + type: "secret" + } + }; + }; + + msrcryptoGcm.importKey = function( p) { + + var keyObject, + keyBits = p.keyData.length * 8; + + if (p.format === "jwk") { + keyObject = msrcryptoJwk.jwkToKey(p.keyData, p.algorithm, ["k"]); + } else if (p.format === "raw") { + if (keyBits !== 128 && keyBits !== 192 && keyBits !== 256) { + throw new Error("invalid key length (should be 128, 192, or 256 bits)"); + } + keyObject = { k: msrcryptoUtilities.toArray(p.keyData) }; + } else { + throw new Error("unsupported import format"); + } + + return { + type: "keyImport", + keyData: keyObject.k, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable || keyObject.extractable, + usages: null || p.usages, + type: "secret" + } + }; + }; + + msrcryptoGcm.exportKey = function( p) { + + if (p.format === "jwk") { + return { type: "keyExport", keyHandle: msrcryptoJwk.keyToJwk(p.keyHandle, p.keyData) }; + } + + if (p.format === "raw") { + return { type: "keyExport", keyHandle: p.keyData }; + } + + throw new Error("unsupported export format"); + }; + + operations.register("importKey", "AES-GCM", msrcryptoGcm.importKey); + operations.register("exportKey", "AES-GCM", msrcryptoGcm.exportKey); + operations.register("generateKey", "AES-GCM", msrcryptoGcm.generateKey); + operations.register("encrypt", "AES-GCM", msrcryptoGcm.encrypt); + operations.register("decrypt", "AES-GCM", msrcryptoGcm.decrypt); +} + +var msrcryptoAESKW = function (blockCipher) { + function encrypt(buffer) { + + var plain = [[0]]; + for (var i = 0; i < buffer.length; i += 8) { + plain.push(buffer.slice(i, i + 8)); + } + + + var A = [166, 166, 166, 166, 166, 166, 166, 166]; + var n = plain.length - 1; + var registers = []; + + for (var i = 1; i <= n; i++) { + registers[i] = plain[i]; + } + + + for (var j = 0; j <= 5; j++) { + for (var i = 1; i <= n; i++) { + var t = n * j + i; + + var enc = blockCipher.encrypt(A.concat(registers[i])); + + registers[i] = enc.slice(8); + + A = enc.slice(0, 8); + for (var ai = 7; t > 0; ai--, t >>>= 8) { + A[ai] ^= t & 255; + } + } + } + + var C = A; + for (var i = 1; i <= n; i++) { + C = C.concat(registers[i]); + } + + return C; + } + + function decrypt(buffer) { + var cipher = []; + for (var i = 0; i < buffer.length; i += 8) { + cipher.push(buffer.slice(i, i + 8)); + } + + var n = cipher.length - 1; + var registers = []; + var plain = []; + + var A = cipher[0]; + for (var i = 1; i <= n; i++) { + registers[i] = cipher[i]; + } + + for (var j = 5; j >= 0; j--) { + for (var i = n; i >= 1; i--) { + var t = n * j + i; + for (var ai = 7; t > 0; ai--, t >>>= 8) { + A[ai] ^= t & 255; + } + var B = blockCipher.decrypt(A.concat(registers[i])); + A = B.slice(0, 8); + registers[i] = B.slice(8); + } + } + + if (A.join(",") !== "166,166,166,166,166,166,166,166") { + throw msrcryptoUtilities.error("OperationError", ""); + } + + for (var i = 1; i <= n; i++) { + plain = plain.concat(registers[i]); + } + + return plain; + } + + return { + encrypt: encrypt, + decrypt: decrypt + }; +}; + +if (typeof operations !== "undefined") { + var aeskwInstances = {}; + + msrcryptoAESKW.workerEncrypt = function (p) { + var result, + id = p.workerid; + + if (p.buffer.length % 8 !== 0) { + throw msrcryptoUtilities.error( + "DataError", + "The AES-KW input data length is invalid: not a multiple of 8 bytes" + ); + } + + if (!aeskwInstances[id]) { + aeskwInstances[id] = msrcryptoAESKW(msrcryptoBlockCipher.aes(p.keyData)); + } + + result = aeskwInstances[id].encrypt(p.buffer); + aeskwInstances[id] = null; + return result; + }; + + msrcryptoAESKW.workerDecrypt = function (p) { + var result, + id = p.workerid; + + if (p.buffer.length % 8 !== 0) { + throw msrcryptoUtilities.error( + "DataError", + "The AES-KW input data length is invalid: not a multiple of 8 bytes" + ); + } + + if (!aeskwInstances[id]) { + aeskwInstances[id] = msrcryptoAESKW(msrcryptoBlockCipher.aes(p.keyData)); + } + + result = aeskwInstances[id].decrypt(p.buffer); + aeskwInstances[id] = null; + return result; + }; + + msrcryptoAESKW.generateKey = function (p) { + if (p.algorithm.length !== 128 && p.algorithm.length !== 192 && p.algorithm.length !== 256) { + throw msrcryptoUtilities.error("OperationError", "AES key length must be 128, 192, or 256 bits"); + } + + return { + type: "keyGeneration", + keyData: msrcryptoPseudoRandom.getBytes(Math.floor(p.algorithm.length / 8)), + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: null || p.usages, + type: "secret" + } + }; + }; + + msrcryptoAESKW.importKey = function (p) { + var keyObject; + var keyBits = p.keyData.length * 8; + + if (p.format === "jwk") { + keyObject = msrcryptoJwk.jwkToKey(p.keyData, p.algorithm, ["k"]); + } else if (p.format === "raw") { + if (keyBits !== 128 && keyBits !== 192 && keyBits !== 256) { + throw msrcryptoUtilities.error("OperationError", "AES key length must be 128, 192, or 256 bits"); + } + keyObject = { k: msrcryptoUtilities.toArray(p.keyData) }; + } else { + throw new TypeError("Invalid keyFormat argument"); + } + + p.algorithm.length = keyObject.k.length * 8; + + return { + keyData: keyObject.k, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable || keyObject.extractable, + usages: null || p.usages, + type: "secret" + }, + type: "keyImport" + }; + }; + + msrcryptoAESKW.exportKey = function (p) { + if (p.format === "jwk") { + return { type: "keyExport", keyHandle: msrcryptoJwk.keyToJwk(p.keyHandle, p.keyData) }; + } + + if (p.format === "raw") { + return { type: "keyExport", keyHandle: p.keyData }; + } + + throw new TypeError("Invalid keyFormat argument"); + }; + + operations.register("importKey", "AES-KW", msrcryptoAESKW.importKey); + operations.register("exportKey", "AES-KW", msrcryptoAESKW.exportKey); + operations.register("generateKey", "AES-KW", msrcryptoAESKW.generateKey); + operations.register("encrypt", "AES-KW", msrcryptoAESKW.workerEncrypt); + operations.register("decrypt", "AES-KW", msrcryptoAESKW.workerDecrypt); +} + +function MsrcryptoPrng() { + + if (!(this instanceof MsrcryptoPrng)) { + throw new Error("create MsrcryptoPrng object with new keyword"); + } + + var initialized = false; + + var key; + var v; + var keyLen; + var seedLen; + var reseedCounter = 1; + var reseedInterval = Math.pow(2, 48); + + initialize(); + + function addOne(counter) { + var i; + for (i = counter.length - 1; i >= 0; i -= 1) { + counter[i] += 1; + if (counter[i] >= 256) { + counter[i] = 0; + } + if (counter[i]) { + break; + } + } + } + + function initialize() { + key = msrcryptoUtilities.getVector(32); + v = msrcryptoUtilities.getVector(16); + keyLen = 32; + seedLen = 48; + reseedCounter = 1; + } + + function reseed(entropy, additionalEntropy) { + additionalEntropy = additionalEntropy || [0]; + if (additionalEntropy.length > seedLen) { + throw new Error("Incorrect entropy or additionalEntropy length"); + } + additionalEntropy = additionalEntropy.concat(msrcryptoUtilities.getVector(seedLen - additionalEntropy.length)); + + entropy = entropy.concat(msrcryptoUtilities.getVector((seedLen - (entropy.length % seedLen)) % seedLen)); + for (var i = 0; i < entropy.length; i += seedLen) { + var seedMaterial = msrcryptoUtilities.xorVectors(entropy.slice(i, i + seedLen), additionalEntropy); + update(seedMaterial); + } + reseedCounter = 1; + } + + function update(providedData) { + var temp = []; + var blockCipher = new msrcryptoBlockCipher.aes(key); + while (temp.length < seedLen) { + addOne(v); + var toEncrypt = v.slice(0, 16); + var outputBlock = blockCipher.encrypt(toEncrypt); + temp = temp.concat(outputBlock); + } + temp = msrcryptoUtilities.xorVectors(temp, providedData); + key = temp.slice(0, keyLen); + v = temp.slice(keyLen); + } + + function generate(requestedBytes, additionalInput) { + if (requestedBytes >= 65536) { + throw new Error("too much random requested"); + } + if (reseedCounter > reseedInterval) { + throw new Error("Reseeding is required"); + } + if (additionalInput && additionalInput.length > 0) { + while (additionalInput.length < seedLen) { + additionalInput = additionalInput.concat( + msrcryptoUtilities.getVector(seedLen - additionalInput.length)); + } + update(additionalInput); + } else { + additionalInput = msrcryptoUtilities.getVector(seedLen); + } + var temp = []; + var blockCipher = new msrcryptoBlockCipher.aes(key); + while (temp.length < requestedBytes) { + addOne(v); + var toEncrypt = v.slice(0, v.length); + var outputBlock = blockCipher.encrypt(toEncrypt); + temp = temp.concat(outputBlock); + } + temp = temp.slice(0, requestedBytes); + update(additionalInput); + reseedCounter += 1; + return temp; + } + + return { + reseed: reseed, + + getBytes: function(length, additionalInput) { + if (!initialized) { + throw new Error("can't get randomness before initialization"); + } + return generate(length, additionalInput); + }, + getNonZeroBytes: function(length, additionalInput) { + if (!initialized) { + throw new Error("can't get randomness before initialization"); + } + var result = []; + var buff; + while (result.length < length) { + buff = generate(length, additionalInput); + for (var i = 0; i < buff.length; i += 1) { + if (buff[i] !== 0) { + result.push(buff[i]); + } + } + } + return result.slice(0, length); + }, + init: function(entropy, personalization) { + if (entropy.length < seedLen) { + throw new Error("Initial entropy length too short"); + } + initialize(); + reseed(entropy, personalization); + initialized = true; + } + }; +} + + var msrcryptoPseudoRandom = new MsrcryptoPrng(); + +function MsrcryptoEntropy(global) { + + var poolLength = 48; + var collectorPool = []; + var collectorPoolLength = 128; + var collectorsRegistered = 0; + var entropyPoolPrng = new MsrcryptoPrng(); + var initialized = false; + var cryptographicPRNGPresent = false; + var globalScope = global; + + function collectEntropy() { + + var headerList = ["Cookie", "RedirectUri", "ETag", "x-ms-client-antiforgery-id", "x-ms-client-request-id", + "x-ms-client-session-id", "SubscriptionPool"]; + + + var i, pool = []; + + for (i = 0; i < poolLength; i += 1) { + pool[i] = Math.floor(Math.random() * 256); + } + + var prngCrypto = globalScope.crypto || globalScope.msCrypto; + if (prngCrypto && typeof prngCrypto.getRandomValues === "function") { + if (global.Uint8Array) { + var res = new global.Uint8Array(poolLength); + prngCrypto.getRandomValues(res); + pool = pool.concat(Array.apply(null, res)); + cryptographicPRNGPresent = true; + } + } + + if (typeof XMLHttpRequest !== "undefined") { + var req = new XMLHttpRequest(); + for (i = 0; i < headerList.length; i += 1) { + try { + var header = req.getResponseHeader(headerList[i]); + if (header) { + var arr = msrcryptoUtilities.stringToBytes(header); + pool = pool.concat(arr); + } + } catch (err) { + } + } + } + if (!cryptographicPRNGPresent && canCollect) { + pool = pool.concat(collectorPool.splice(0, collectorPool.length)); + collectors.startCollectors(); + } + + initialized ? entropyPoolPrng.reseed(pool) : entropyPoolPrng.init(pool); + initialized = true; + } + + function updatePool(entropyData) { + for (var i = 0; i < entropyData.length; ++i) { + collectorPool.push(entropyData[i]); + } + if (collectorPool.length >= collectorPoolLength) { + collectors.stopCollectors(); + } + } + + var canCollect = (global && global.addEventListener) || + (typeof document !== "undefined" && document.attachEvent); + var collectors = (function() { + return { + startCollectors: function() { + if (!this.collectorsRegistered) { + if (global.addEventListener) { + global.addEventListener("mousemove", this.MouseEventCallBack, true); + global.addEventListener("load", this.LoadTimeCallBack, true); + } else if (document.attachEvent) { + document.attachEvent("onmousemove", this.MouseEventCallBack); + document.attachEvent("onload", this.LoadTimeCallBack); + } else { + throw new Error("Can't attach events for entropy collection"); + } + + this.collectorsRegistered = 1; + } + }, + stopCollectors: function() { + if (this.collectorsRegistered) { + if (global.removeEventListener) { + global.removeEventListener("mousemove", this.MouseEventCallBack, 1); + global.removeEventListener("load", this.LoadTimeCallBack, 1); + } else if (global.detachEvent) { + global.detachEvent("onmousemove", this.MouseEventCallBack); + global.detachEvent("onload", this.LoadTimeCallBack); + } + + this.collectorsRegistered = 0; + } + }, + MouseEventCallBack: function(eventData) { + var d = (new Date()).valueOf(); + var x = eventData.x || eventData.clientX || eventData.offsetX || 0; + var y = eventData.y || eventData.clientY || eventData.offsetY || 0; + var arr = [d & 0x0ff, (d >> 8) & 0x0ff, (d >> 16) & 0x0ff, (d >> 24) & 0x0ff, + x & 0x0ff, (x >> 8) & 0x0ff, y & 0x0ff, (y >> 8) & 0x0ff]; + + updatePool(arr); + }, + LoadTimeCallBack: function() { + var d = (new Date()).valueOf(); + var dateArray = [d & 0x0ff, (d >> 8) & 0x0ff, (d >> 16) & 0x0ff, (d >> 24) & 0x0ff]; + + updatePool(dateArray); + } + }; + })(); + + return { + init: function() { + collectEntropy(); + + if (!cryptographicPRNGPresent && !collectorsRegistered && canCollect) { + try { + collectors.startCollectors(); + } catch (e) { + } + } + }, + + reseed: function(entropy) { + entropyPoolPrng.reseed(entropy); + }, + + read: function(length) { + if (!initialized) { + throw new Error("Entropy pool is not initialized."); + } + + var ret = entropyPoolPrng.getBytes(length); + + collectEntropy(); + + return ret; + } + }; +} + +var prime = (function() { + + var smallPrimes = []; + + var trialValues = []; + + var MAX_SMALL_PRIMES = 4096 * 4; + + function primeSieve(max) { + + var numbers = new Array(max + 1), + results = [], + i, j, + limit = Math.sqrt(max) | 0; + + for (i = 3; i <= limit; i += 2) { + for (j = i * i; j <= max; j += i * 2) { + numbers[j] = 0; + } + } + + for (i = 3; i <= max; i += 2) { + if (numbers[i] !== 0) { + results.push(i); + } + } + + return results; + } + + function incrementalTrialDivision(increment) { + + var i, + len = trialValues.length; + + for (i = 0; i < len; i++) { + if ((trialValues[i] + increment) % smallPrimes[i] === 0) { + return false; + } + } + + return true; + } + + function setupIncrementalTrialDivision(candidate) { + + var i, j, r, p, y, + primeCount, + len = candidate.length - 1, + db = cryptoMath.DIGIT_BASE, + h = candidate[len]; + + if (smallPrimes.length === 0) { smallPrimes = primeSieve(MAX_SMALL_PRIMES); } + primeCount = smallPrimes.length; + + trialValues = new Array(primeCount); + + for (i = 0; i < primeCount; i++) { + + j = len; + y = smallPrimes[i]; + + if (h < y) { r = h; j--; } else { r = 0; } + + while (j >= 0) { + p = r * db + candidate[j--]; + r = p - (p / y | 0) * y; + } + + trialValues[i] = r; + } + + return; + } + + function largestDivisibleByPowerOfTwo(number) { + + var k = 0, i = 0, s = 0, j; + if (cryptoMath.isZero(number)) { return 0; } + for (k = 0; number[k] === 0; k++) { } + for (i = 0, j = 2; number[k] % j === 0; j *= 2, i++) { } + return k * cryptoMath.DIGIT_BITS + i; + } + + function sizeInBits(digits) { + + var k = 0, i = 0, j = 0; + if (cryptoMath.isZero(digits)) { return 0; } + for (k = digits.length - 1; digits[k] === 0; k--) { } + for (i = cryptoMath.DIGIT_BITS - 1, j = (1 << i); i > 0; j = j >>> 1, i--) { + if ((digits[k] & j) !== 0) { + break; + } + } + return k * cryptoMath.DIGIT_BITS + i; + } + + function millerRabin(number, iterations) { + + var w = number; + var wminus1 = []; + cryptoMath.subtract(w, [1], wminus1); + + var a = largestDivisibleByPowerOfTwo(wminus1); + + var m = []; + cryptoMath.shiftRight(wminus1, m, a); + + var wlen = sizeInBits(w); + var b; + var montmul = cryptoMath.MontgomeryMultiplier(w); + + for (var i = 1; i <= iterations; i++) { + + var status = false; + + do { + b = getRandomOddNumber(wlen); + } while (cryptoMath.compareDigits(b, wminus1) >= 0); + + var z = []; + + montmul.modExp(b, m, z, true); + + if (cryptoMath.compareDigits(z, [1]) === 0 || cryptoMath.compareDigits(z, wminus1) === 0) { continue; } + + for (var j = 1; j < a; j++) { + + montmul.montgomeryMultiply(z, z, z); + + if (cryptoMath.compareDigits(z, wminus1) === 0) { + status = true; + break; + } + + if (cryptoMath.compareDigits(z, [1]) === 0) { + return false; + } + } + + if (status === false) { return false; } + } + + return true; + } + + function generatePrime(bits) { + + var candidate = getRandomOddNumber(bits), + inc = 0, + possiblePrime, + isPrime = false, + candidatePlusInc = []; + + setupIncrementalTrialDivision(candidate); + + while (true) { + + possiblePrime = incrementalTrialDivision(inc); + + if (possiblePrime) { + cryptoMath.add(candidate, [inc], candidatePlusInc); + if (millerRabin(candidatePlusInc, 6) === true) { return candidatePlusInc; } + } + + inc += 2; + } + + } + + function getRandomOddNumber(bits) { + + var numBytes = Math.ceil(bits / 8), + bytes = msrcryptoPseudoRandom.getBytes(numBytes), + digits; + + bytes[0] |= 128; + bytes[bytes.length - 1] |= 1; + + return cryptoMath.bytesToDigits(bytes); + + } + + return { + generatePrime: generatePrime + }; + +})(); + +var msrcryptoRsaBase = function(keyStruct) { + + var utils = msrcryptoUtilities, + keyIsPrivate = keyStruct.hasOwnProperty("n") && keyStruct.hasOwnProperty("d"), + keyIsCrt = keyStruct.hasOwnProperty("p") && keyStruct.hasOwnProperty("q"), + modulusLength = keyStruct.n.length; + + function toBytes(digits) { + + var bytes = cryptoMath.digitsToBytes(digits); + + utils.padFront(bytes, 0, modulusLength); + + return bytes; + } + + function modExp(dataBytes, expBytes, modulusBytes) { + var exponent = cryptoMath.bytesToDigits(expBytes); + + var group = cryptoMath.IntegerGroup(modulusBytes); + var base = group.createElementFromBytes(dataBytes); + var result = group.modexp(base, exponent); + + return result.m_digits; + } + + function decryptModExp(cipherBytes) { + + var resultElement = modExp(cipherBytes, keyStruct.d, keyStruct.n); + + return toBytes(resultElement); + } + + function decryptCrt(cipherBytes) { + + var b2d = cryptoMath.bytesToDigits, + p = keyStruct.p, + q = keyStruct.q, + dp = keyStruct.dp, + dq = keyStruct.dq, + invQ = keyStruct.qi, + pDigits = b2d(p), + qDigits = b2d(q), + temp = new Array(pDigits.length + qDigits.length), + m1Digits = new Array(pDigits.length + 1), + m2Digits = new Array(qDigits.length + 1), + cDigits = b2d(cipherBytes), + mm = cryptoMath.MontgomeryMultiplier, + mmp = new mm(keyStruct.ctxp ? undefined : pDigits, keyStruct.ctxp), + mmq = new mm(keyStruct.ctxq ? undefined : qDigits, keyStruct.ctxq); + + mmp.reduce(cDigits, temp); + mmp.modExp(temp, b2d(dp), m1Digits); + + mmq.reduce(cDigits, temp); + mmq.modExp(temp, b2d(dq), m2Digits); + + var carry = cryptoMath.subtract(m1Digits, m2Digits, temp); + if (carry !== 0) { + cryptoMath.subtract(m2Digits, m1Digits, temp); + } + + cryptoMath.modMul(temp, b2d(invQ), pDigits, cDigits); + if (carry !== 0) { + cryptoMath.subtract(pDigits, cDigits, cDigits); + } + + cryptoMath.multiply(cDigits, qDigits, temp); + cryptoMath.add(m2Digits, temp, m1Digits); + + return toBytes(m1Digits); + } + + return { + + encrypt: function(messageBytes) { + + var bytes = toBytes(modExp(messageBytes, keyStruct.e, keyStruct.n, true)); + return bytes; + + }, + + decrypt: function(cipherBytes) { + + if (keyIsCrt) { + return decryptCrt(cipherBytes); + } + + if (keyIsPrivate) { + return decryptModExp(cipherBytes); + } + + throw new Error("missing private key"); + } + }; + +}; + +var rsaShared = { + + mgf1: function(seedBytes, maskLen, hashFunction) { + + var t = [], + bytes, hash, counter, + hashByteLen = hashFunction.hashLen / 8; + + for (counter = 0; counter <= Math.floor(maskLen / hashByteLen); counter += 1) { + + bytes = [ + counter >>> 24 & 0xff, + counter >>> 16 & 0xff, + counter >>> 8 & 0xff, + counter & 0xff + ]; + + hash = hashFunction.computeHash(seedBytes.concat(bytes)); + + t = t.concat(hash); + } + + return t.slice(0, maskLen); + }, + + checkMessageVsMaxHash: function(messageBytes, hashFunction) { + + if (messageBytes.length > (hashFunction.maxMessageSize || 0xFFFFFFFF)) { + throw new Error("message too long"); + } + + return; + } + +}; + +var rsaMode = rsaMode || {}; + +rsaMode.oaep = function(keyStruct, hashFunction) { + + var utils = msrcryptoUtilities, + random = msrcryptoPseudoRandom, + size = keyStruct.n.length; + + if (hashFunction === null) { + throw new Error("must supply hashFunction"); + } + + function pad( message, label) { + + var lHash, psLen, psArray, i, db, seed; + var dbMask, maskeddb, seedMask, maskedSeed; + var encodedMessage; + + if (message.length > (size - 2 * (hashFunction.hashLen / 8) - 2)) { + throw new Error("Message too long."); + } + + if (label == null) { label = []; } + + lHash = hashFunction.computeHash(label); + + psLen = size - message.length - (2 * lHash.length) - 2; + psArray = utils.getVector(psLen); + + db = lHash.concat(psArray, [1], message); + + seed = random.getBytes(lHash.length); + + dbMask = rsaShared.mgf1(seed, size - lHash.length - 1, hashFunction); + + maskeddb = utils.xorVectors(db, dbMask); + + seedMask = rsaShared.mgf1(maskeddb, lHash.length, hashFunction); + + maskedSeed = utils.xorVectors(seed, seedMask); + + encodedMessage = [0].concat(maskedSeed).concat(maskeddb); + + message = encodedMessage.slice(); + + return message; + } + + function unpad( encodedBytes, labelBytes) { + + var lHash, maskedSeed, maskeddb, seedMask; + var seed, dbMask, db; + var lHashp, i = 0; + var valid = encodedBytes[0] === 0; + + if (!labelBytes) { + labelBytes = []; + } + + lHash = hashFunction.computeHash(labelBytes); + + maskedSeed = encodedBytes.slice(1, lHash.length + 1); + maskeddb = encodedBytes.slice(lHash.length + 1); + + seedMask = rsaShared.mgf1(maskeddb, lHash.length, hashFunction); + seed = utils.xorVectors(maskedSeed, seedMask); + dbMask = rsaShared.mgf1(seed, size - lHash.length - 1, hashFunction); + + db = utils.xorVectors(maskeddb, dbMask); + + lHashp = db.slice(0, lHash.length); + + valid = valid && utils.arraysEqual(lHash, lHashp); + + db = db.slice(lHash.length); + + while (!db[i++]) { } + + return { + valid: valid, + data: db.slice(i) + }; + } + + return { + + pad: function( messageBytes, labelBytes) { + return pad(messageBytes, labelBytes); + }, + + unpad: function( encodedBytes, labelBytes) { + return unpad(encodedBytes, labelBytes); + } + }; + +}; + +var rsaMode = rsaMode || {}; + +rsaMode.pkcs1Encrypt = function(keyStruct) { + + var random = msrcryptoPseudoRandom, + size = keyStruct.n.length; + + function pad(data) { + + var randomness; + + if (data.length > size - 11) { + throw new Error("message too long"); + } + + randomness = random.getNonZeroBytes(size - data.length - 3); + + return [0, 2].concat(randomness, [0], data); + } + + function validatePadding(paddedData) { + + var paddingValid = paddedData[0] === 0 && paddedData[1] === 2; + + for (var i = 2; i < 10; i++) { + paddingValid = paddingValid && !!paddedData[i]; + } + + return paddingValid; + } + + function unpad(paddedData) { + + var i, + paddingIsValid = validatePadding(paddedData), + startOfData = 0; + + for (i = 1; i < paddedData.length; i += 1) { + startOfData = startOfData || +!paddedData[i] && i + 1; + } + + startOfData = (-paddingIsValid && startOfData); + + return { + data: paddedData.slice(startOfData), + valid: paddingIsValid + }; + } + + return { + + pad: function(messageBytes) { + return pad(messageBytes); + }, + + unpad: function(encodedBytes) { + return unpad(encodedBytes); + } + }; + +}; + +rsaMode.pkcs1Sign = function(keyStruct, hashFunction) { + + var utils = msrcryptoUtilities, + size = keyStruct.n.length; + + function emsa_pkcs1_v15_encode(messageBytes) { + + var paddedData, + hash, + tlen; + + hash = hashFunction.computeHash(messageBytes.slice()); + + paddedData = hashFunction.der.concat(hash); + + tlen = paddedData.length; + + if (size < tlen + 11) { + throw new Error("intended encoded message length too short"); + } + + return [0x00, 0x01].concat( + utils.getVector(size - tlen - 3, 0xFF), + [0], + paddedData); + } + + return { + + sign: function(messageBytes) { + return emsa_pkcs1_v15_encode(messageBytes); + }, + + verify: function(signatureBytes, messageBytes) { + var emp = emsa_pkcs1_v15_encode(messageBytes); + + return utils.arraysEqual(signatureBytes, emp); + + } + }; +}; + +var rsaMode = rsaMode || {}; + +rsaMode.pss = function(keyStruct, hashFunction) { + var utils = msrcryptoUtilities, + random = msrcryptoPseudoRandom; + + function emsa_pss_encode(messageBytes, saltLength, salt) { + var modulusBits = cryptoMath.bitLength(keyStruct.n), + emBits = modulusBits - 1, + emLen = Math.ceil(emBits / 8), + mHash = hashFunction.computeHash(messageBytes); + + saltLength = salt ? salt.length : saltLength == null ? mHash.length : saltLength; + + if (emLen < mHash.length + saltLength + 2) { + throw new Error("encoding error"); + } + + salt = salt || random.getBytes(saltLength); + + var mp = [ 0, 0, 0, 0, 0, 0, 0, 0 ].concat(mHash, salt); + + var h = hashFunction.computeHash(mp); + + var ps = utils.getVector(emLen - salt.length - h.length - 2); + + var db = ps.concat([ 1 ], salt); + + var dbMask = rsaShared.mgf1(h, emLen - h.length - 1, hashFunction); + + var maskedDb = utils.xorVectors(db, dbMask); + + var mask = 0; + for (var i = 0; i < 8 - (8 * emLen - emBits); i++) { + mask += 1 << i; + } + maskedDb[0] &= mask; + + var em = maskedDb.concat(h, [ 0xbc ]); + + return em; + } + + function emsa_pss_verify(signatureBytes, messageBytes, saltLength) { + var modulusBits = cryptoMath.bitLength(keyStruct.n); + + var emBits = modulusBits - 1; + + var emLen = Math.ceil(emBits / 8); + + var mHash = hashFunction.computeHash(messageBytes); + + var hLen = mHash.length; + + saltLength = saltLength == null ? hLen : saltLength; + + if (emLen < hLen + saltLength + 2) { + return false; + } + + var maskedDb = signatureBytes.slice(0, emLen - hLen - 1); + + var h = signatureBytes.slice(maskedDb.length, maskedDb.length + hLen); + + var dbMask = rsaShared.mgf1(h, emLen - hLen - 1, hashFunction); + + var db = utils.xorVectors(maskedDb, dbMask); + + db[0] &= 0xff >>> (8 - (8 * emLen - emBits)); + + for (var i = 0; i < emLen - hLen - saltLength - 2; i++) { + if (db[i] !== 0) { + return false; + } + } + + if (db[emLen - hLen - saltLength - 2] !== 0x01) { + return false; + } + + var salt = db.slice(db.length - saltLength); + + var mp = [ 0, 0, 0, 0, 0, 0, 0, 0 ].concat(mHash, salt); + + var hp = hashFunction.computeHash(mp); + + return utils.arraysEqual(hp, h); + } + + return { + sign : function(messageBytes, saltLength, salt) { + return emsa_pss_encode(messageBytes, saltLength, salt); + }, + + verify : function(signatureBytes, messageBytes, saltLength) { + return emsa_pss_verify(signatureBytes, messageBytes, saltLength); + } + }; +}; + +var msrcryptoRsa = function(keyStruct, mode, hashFunction) { + var rsaBase = msrcryptoRsaBase(keyStruct); + + if (!mode) { + throw new Error("padding mode"); + } + + function checkHash() { + if (!hashFunction || !hashFunction.computeHash) { + throw new Error("missing hash function"); + } + } + + var paddingFunction = null, + unPaddingFunction = null; + + var padding; + + switch (mode) { + + case "RSAES-PKCS1-V1_5": + padding = rsaMode.pkcs1Encrypt(keyStruct); + break; + + case "RSASSA-PKCS1-V1_5": + checkHash(); + padding = rsaMode.pkcs1Sign(keyStruct, hashFunction); + break; + + case "RSA-OAEP": + checkHash(); + padding = rsaMode.oaep(keyStruct, hashFunction); + break; + + case "RSA-PSS": + checkHash(); + padding = rsaMode.pss(keyStruct, hashFunction); + break; + + case "raw": + padding = { + pad: function(mb) { + return mb; + }, + unpad: function(eb) { + return eb; + } + }; + break; + + default: + throw new Error("invalid mode"); + } + + if (padding) { + paddingFunction = padding.pad || padding.sign; + unPaddingFunction = padding.unpad || padding.verify; + } + + var returnObj = { + encrypt: function( dataBytes, labelBytes) { + var paddedData; + var encryptedData; + + if (paddingFunction !== null) { + paddedData = paddingFunction(dataBytes, labelBytes); + } else { + paddedData = dataBytes.slice(); + } + + encryptedData = rsaBase.encrypt(paddedData); + + return encryptedData; + }, + + decrypt: function( cipherBytes, labelBytes) { + var decryptedData = rsaBase.decrypt(cipherBytes); + + if (unPaddingFunction !== null) { + decryptedData = unPaddingFunction(decryptedData, labelBytes); + + if (decryptedData.valid === false) { + throw msrcryptoUtilities.error("OperationError", ""); + } + + decryptedData = decryptedData.data; + + } else { + decryptedData = decryptedData.slice(0); + } + + return decryptedData; + }, + + signData: function( messageBytes, saltLength, salt) { + return rsaBase.decrypt(paddingFunction(messageBytes, saltLength, salt)); + }, + + verifySignature: function( + signature, + messageBytes, + saltLength + ) { + var decryptedSig = rsaBase.encrypt(signature); + + return unPaddingFunction(decryptedSig, messageBytes, saltLength); + }, + + generateKeyPair: function(bits) { + var keyPair = genRsaKeyFromRandom(bits); + }, + + mode: mode + }; + + return returnObj; +}; + +if (typeof operations !== "undefined") { + msrcryptoRsa.sign = function( p) { + var rsaObj, + hashName = p.keyHandle.algorithm.hash.name, + hashFunc = msrcryptoHashFunctions[hashName.toUpperCase()](), + saltLength = p.algorithm.saltLength, + salt = p.algorithm.salt; + + rsaObj = msrcryptoRsa(p.keyData, p.algorithm.name, hashFunc); + + return rsaObj.signData(p.buffer, saltLength, salt); + }; + + msrcryptoRsa.verify = function( p) { + var hashName = p.keyHandle.algorithm.hash.name, + hashFunc = msrcryptoHashFunctions[hashName.toUpperCase()](), + rsaObj, + saltLength = p.algorithm.saltLength; + + rsaObj = msrcryptoRsa(p.keyData, p.algorithm.name, hashFunc); + + return rsaObj.verifySignature(p.signature, p.buffer, saltLength); + }; + + msrcryptoRsa.workerEncrypt = function( p) { + var result, rsaObj, hashFunc, hashName; + + switch (p.algorithm.name) { + + case "RSAES-PKCS1-V1_5": + rsaObj = msrcryptoRsa(p.keyData, p.algorithm.name); + result = rsaObj.encrypt(p.buffer); + break; + + case "RSA-OAEP": + hashName = p.keyHandle.algorithm.hash.name; + if (!hashName) { + throw new Error("unsupported hash algorithm"); + } + hashFunc = msrcryptoHashFunctions[hashName.toUpperCase()](); + rsaObj = msrcryptoRsa(p.keyData, p.algorithm.name, hashFunc); + result = rsaObj.encrypt(p.buffer); + break; + + default: + throw new Error("unsupported algorithm"); + } + + return result; + }; + + msrcryptoRsa.workerDecrypt = function( p) { + var result, rsaObj, hashFunc; + + switch (p.algorithm.name) { + + case "RSAES-PKCS1-V1_5": + rsaObj = msrcryptoRsa(p.keyData, p.algorithm.name); + result = rsaObj.decrypt(p.buffer); + break; + + case "RSA-OAEP": + var hashName = p.keyHandle.algorithm.hash.name; + if (!hashName) { + throw new Error("unsupported hash algorithm"); + } + hashFunc = msrcryptoHashFunctions[hashName.toUpperCase()](); + rsaObj = msrcryptoRsa(p.keyData, p.algorithm.name, hashFunc); + result = rsaObj.decrypt(p.buffer); + break; + + default: + throw new Error("unsupported algorithm"); + } + + return result; + }; + + msrcryptoRsa.importKey = function( p) { + + var keyObject; + + if (p.format === "jwk") { + + keyObject = msrcryptoJwk.jwkToKey(p.keyData, p.algorithm, ["n", "e", "d", "p", "q", "dp", "dq", "qi"]); + + if (keyObject.d) { + keyObject.ctxp = new cryptoMath.MontgomeryMultiplier(cryptoMath.bytesToDigits(keyObject.p)).ctx; + keyObject.ctxq = new cryptoMath.MontgomeryMultiplier(cryptoMath.bytesToDigits(keyObject.q)).ctx; + } + + } else if (p.format === "spki") { + + var publicKeyInfo = asn1.parse(p.keyData); + + if (publicKeyInfo == null) { + throw new Error("invalid key data."); + } + + var octetString = publicKeyInfo[1]; + var keySequence = asn1.parse(octetString.data.slice(octetString.header + 1), true); + + if (keySequence == null) { + throw new Error("invalid key data."); + } + + var n = keySequence[0], + e = keySequence[1]; + + if (n.type !== "INTEGER" || e.type !== "INTEGER") { + throw new Error("invalid key data."); + } + + n = n.data.slice(n.header); + e = e.data.slice(e.header); + + if (n[0] === 0 && n[1] & 128) { n = n.slice(1); } + if (e[0] === 0 && e[1] & 128) { e = e.slice(1); } + + keyObject = { n: n, e: e }; + + } else if (p.format === "pkcs8") { + var publicKeyInfo = asn1.parse(p.keyData); + + if (publicKeyInfo == null) { + throw new Error("invalid key data."); + } + + var octetString = publicKeyInfo[2]; + var keySequence = asn1.parse(octetString.data.slice(octetString.header), true); + + if (keySequence == null) { + throw new Error("invalid key data."); + } + + var keyProps = ["n", "e", "d", "p", "q", "dp", "dq", "qi"]; + keyObject = {}; + + for (var i = 1; i < keySequence.length; i++) { + var int = keySequence[i]; + int = int.data.slice(int.header); + if (int[0] === 0 && int[1] & 128) { + int = int.slice(1); + } + keyObject[keyProps[i - 1]] = int; + } + } else { + throw new Error("unsupported key import format."); + } + + return { + type: "keyImport", + keyData: keyObject, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: p.usages, + type: keyObject.d || keyObject.dq ? "private" : "public" + } + }; + }; + + msrcryptoRsa.exportKey = function( p) { + var RSA_ENCRYPTION = "1.2.840.113549.1.1.1"; + + if (p.format === "jwk") { + var jsonKeyStringArray = msrcryptoJwk.keyToJwk(p.keyHandle, p.keyData); + return { type: "keyExport", keyHandle: jsonKeyStringArray }; + } + + if (p.format === "spki") { + var bytes = asn1.encode({ + SEQUENCE: [ + { + SEQUENCE: [{ "OBJECT IDENTIFIER": RSA_ENCRYPTION }, { NULL: 1 }] + }, + { + "BIT STRING": { + SEQUENCE: [{ INTEGER: p.keyData.n }, { INTEGER: p.keyData.e }] + } + } + ] + }); + + return { type: "keyExport", keyHandle: bytes }; + } + + if (p.format === "pkcs8") { + var bytes = asn1.encode({ + SEQUENCE: [ + { INTEGER: 0 }, + { + SEQUENCE: [{ "OBJECT IDENTIFIER": RSA_ENCRYPTION }, { NULL: 1 }] + }, + { + "OCTET STRING": { + SEQUENCE: [ + { INTEGER: 0 }, + { INTEGER: p.keyData.n }, + { INTEGER: p.keyData.e }, + { INTEGER: p.keyData.d }, + { INTEGER: p.keyData.p }, + { INTEGER: p.keyData.q }, + { INTEGER: p.keyData.dp }, + { INTEGER: p.keyData.dq }, + { INTEGER: p.keyData.qi } + ] + } + } + ] + }); + + return { type: "keyExport", keyHandle: bytes }; + } + + throw new Error(p.format + " not implemented"); + }; + + msrcryptoRsa.genRsaKeyFromRandom = function(bits, e) { + var exp = e ? cryptoMath.bytesToDigits(e) : [65537]; + + do { + var p = prime.generatePrime(bits / 2); + + var q = prime.generatePrime(bits / 2); + + if (cryptoMath.compareDigits(q, p) > 0) { + var t = p; + p = q; + q = t; + } + + var n = []; + cryptoMath.multiply(p, q, n); + + var p_1 = []; + cryptoMath.subtract(p, [1], p_1); + + var q_1 = []; + cryptoMath.subtract(q, [1], q_1); + + var p_1q_1 = []; + cryptoMath.multiply(p_1, q_1, p_1q_1); + + var gcd = []; + cryptoMath.gcd(exp, p_1q_1, gcd); + + var gcdEqual1 = cryptoMath.compareDigits(gcd, cryptoMath.One) === 0; + + } while (!gcdEqual1); + + var d = []; + cryptoMath.modInv(exp, p_1q_1, d); + + var dp = []; + cryptoMath.reduce(d, p_1, dp); + + var dq = []; + cryptoMath.reduce(d, q_1, dq); + + var qi = []; + cryptoMath.modInv(q, p, qi); + + var d2b = cryptoMath.digitsToBytes; + + return { + privateKey: { + n: d2b(n), + e: d2b(exp), + d: d2b(d), + p: d2b(p), + q: d2b(q), + dp: d2b(dp), + dq: d2b(dq), + qi: d2b(qi) + }, + publicKey: { n: d2b(n), e: d2b(exp) } + }; + }; + + msrcryptoRsa.generateKeyPair = function(p) { + if (typeof p.algorithm.modulusLength === "undefined") { + throw new Error("missing modulusLength"); + } + + var keyPair; + var b2d = cryptoMath.bytesToDigits; + + switch (p.algorithm.modulusLength) { + case 1024: + case 2048: + case 4096: + keyPair = msrcryptoRsa.genRsaKeyFromRandom(p.algorithm.modulusLength, p.algorithm.publicExponent); + break; + default: + throw new Error("invalid modulusLength"); + } + + var pk = keyPair.privateKey; + pk.ctxp = (new cryptoMath.MontgomeryMultiplier(b2d(pk.p))).ctx; + pk.ctxq = (new cryptoMath.MontgomeryMultiplier(b2d(pk.q))).ctx; + + var algName = p.algorithm.name; + var rsaKeyType = algName.slice(algName.indexOf("-") + 1).toUpperCase(); + + var publicUsage, privateUsage; + + if (algName === "RSASSA-PKCS1-V1_5" || algName === "RSA-PSS") { + publicUsage = ["verify"]; + privateUsage = ["sign"]; + } else { + publicUsage = ["encrypt", "wrapKey"]; + privateUsage = ["decrypt", "unwrapKey"]; + } + + if (p.usages) { + var requestedUsages = p.usages; + var filteredPublic = []; + var filteredPrivate = []; + var usageIndex; + + for (usageIndex = 0; usageIndex < publicUsage.length; usageIndex += 1) { + if (msrcryptoUtilities.indexOf(requestedUsages, publicUsage[usageIndex]) >= 0) { + filteredPublic.push(publicUsage[usageIndex]); + } + } + + for (usageIndex = 0; usageIndex < privateUsage.length; usageIndex += 1) { + if (msrcryptoUtilities.indexOf(requestedUsages, privateUsage[usageIndex]) >= 0) { + filteredPrivate.push(privateUsage[usageIndex]); + } + } + + publicUsage = filteredPublic; + privateUsage = filteredPrivate; + } + + return { + type: "keyGeneration", + keyPair: { + publicKey: { + keyData: keyPair.publicKey, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: publicUsage, + type: "public" + } + }, + privateKey: { + keyData: keyPair.privateKey, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: privateUsage, + type: "private" + } + } + } + }; + }; + + operations.register("sign", "RSASSA-PKCS1-V1_5", msrcryptoRsa.sign); + operations.register("sign", "RSA-PSS", msrcryptoRsa.sign); + + operations.register("verify", "RSASSA-PKCS1-V1_5", msrcryptoRsa.verify); + operations.register("verify", "RSA-PSS", msrcryptoRsa.verify); + + operations.register("encrypt", "RSAES-PKCS1-V1_5", msrcryptoRsa.workerEncrypt); + operations.register("decrypt", "RSAES-PKCS1-V1_5", msrcryptoRsa.workerDecrypt); + operations.register("encrypt", "RSA-OAEP", msrcryptoRsa.workerEncrypt); + operations.register("decrypt", "RSA-OAEP", msrcryptoRsa.workerDecrypt); + + operations.register("importKey", "RSA-OAEP", msrcryptoRsa.importKey); + operations.register("importKey", "RSAES-PKCS1-V1_5", msrcryptoRsa.importKey); + operations.register("importKey", "RSASSA-PKCS1-V1_5", msrcryptoRsa.importKey); + operations.register("importKey", "RSA-PSS", msrcryptoRsa.importKey); + + operations.register("exportKey", "RSA-OAEP", msrcryptoRsa.exportKey); + operations.register("exportKey", "RSAES-PKCS1-V1_5", msrcryptoRsa.exportKey); + operations.register("exportKey", "RSASSA-PKCS1-V1_5", msrcryptoRsa.exportKey); + operations.register("exportKey", "RSA-PSS", msrcryptoRsa.exportKey); + + operations.register("generateKey", "RSA-OAEP", msrcryptoRsa.generateKeyPair); + operations.register("generateKey", "RSAES-PKCS1-V1_5", msrcryptoRsa.generateKeyPair); + operations.register("generateKey", "RSASSA-PKCS1-V1_5", msrcryptoRsa.generateKeyPair); + operations.register("generateKey", "RSA-PSS", msrcryptoRsa.generateKeyPair); +} + +var msrcryptoConcatKdf = (function () { + + function deriveBits(p) { + + var hashName = p.algorithm.hash.name, + hashFunction = msrcryptoHashFunctions[hashName.toUpperCase()](), + alg = p.algorithm; + + var otherInfo = + utils.toArray(alg.algorithmId).concat( + utils.toArray(alg.partyUInfo), + utils.toArray(alg.partyVInfo), + utils.toArray(alg.publicInfo) || [], + utils.toArray(alg.privateInfo) || []); + + var reps = Math.ceil(p.length / hashFunction.hashLen), + counter = 1, + digest = p.keyData.concat(otherInfo), + output = []; + + for (var i = 0; i < reps; i++) { + var data = utils.int32ToBytes(counter++).concat(digest); + var h = hashFunction.computeHash(data); + output = output.concat(h); + } + + return output.slice(0, p.length / 8); + + } + + return { + deriveBits: deriveBits + }; + +}()); + +if (typeof operations !== "undefined") { + + msrcryptoConcatKdf.importKey = function (p) { + var keyData; + + if (p.format === "raw") { + keyData = msrcryptoUtilities.toArray(p.keyData); + } else { + throw new Error("unsupported import format"); + } + + if (p.extractable !== false) { + throw new Error("only extractable=false is supported."); + } + + return { + type: "keyImport", + keyData: keyData, + keyHandle: { + algorithm: { name: "CONCAT" }, + extractable: false, + usages: p.usages, + type: "secret" + } + }; + + }; + + operations.register("deriveBits", "CONCAT", msrcryptoConcatKdf.deriveBits); + operations.register("importKey", "CONCAT", msrcryptoConcatKdf.importKey); +} + +var msrcryptoPbkdf2 = (function() { + + function deriveBits(p) { + + var algorithm = p.algorithm, + keyBytes = p.keyData, + bits = p.length, + iterations = algorithm.iterations, + saltBytes = Array.apply(null, algorithm.salt), + byteLen = Math.ceil(bits / 8), + hLen, + blockCount, + output = []; + + switch (algorithm.hash.name.toUpperCase()) { + case "SHA-1": hLen = 20; break; + case "SHA-256": hLen = 32; break; + case "SHA-384": hLen = 48; break; + case "SHA-512": hLen = 64; break; + default: throw new Error("Unsupported hash algorithm"); + } + + + blockCount = Math.ceil(byteLen / hLen); + + var hmacKey = msrcryptoHmac.importKey({ + format: "raw", + keyData: keyBytes, + algorithm: { + name: "HMAC", + hash: algorithm.hash + } + }); + + var hmacContext = { + algorithm: algorithm, + keyHandle: hmacKey.keyHandle, + keyData: hmacKey.keyData, + workerid: 0, + buffer: null + }; + + function F( S, c, i) { + + var result = [], + u = S.concat([i >>> 24 & 0xFF, i >>> 16 & 0xFF, i >>> 8 & 0xFF, i & 0xFF]); + + for (var j = 0; j < c; j++) { + hmacContext.buffer = u; + u = msrcryptoHmac.signHmac(hmacContext); + for (var k = 0; k < hLen; k++) { + result[k] = ~~result[k] ^ u[k]; + } + } + + return result; + } + + for (var block = 1; block <= blockCount; block++) { + output = output.concat(F(saltBytes, iterations, block)); + } + + output.length = byteLen; + + return output; + } + + return { + + deriveBits: deriveBits + + }; + +}()); + +if (typeof operations !== "undefined") { + + msrcryptoPbkdf2.importKey = function(p) { + var keyData; + + if (p.format === "raw") { + keyData = msrcryptoUtilities.toArray(p.keyData); + } else { + throw new Error("unsupported import format"); + } + + if (p.extractable !== false) { + throw new Error("only extractable=false is supported."); + } + + return { + type: "keyImport", + keyData: keyData, + keyHandle: { + algorithm: { name: "PBKDF2" }, + extractable: false, + usages: p.usages, + type: "secret" + } + }; + + }; + + operations.register("deriveBits", "PBKDF2", msrcryptoPbkdf2.deriveBits); + operations.register("importKey", "PBKDF2", msrcryptoPbkdf2.importKey); +} + +var msrcryptoHkdf = (function() { + + function deriveBits(p) { + + var algorithm = p.algorithm, + keyBytes = p.keyData, + bits = p.length, + saltBytes = algorithm.salt, + byteLen = Math.ceil(bits / 8), + hLen, + output = [], + infoBytes = msrcryptoUtilities.toArray(algorithm.info), + t = [], + i, + hmacContext; + + switch (algorithm.hash.name.toUpperCase()) { + case "SHA-1": hLen = 20; break; + case "SHA-256": hLen = 32; break; + case "SHA-384": hLen = 48; break; + case "SHA-512": hLen = 64; break; + default: throw new Error("Unsupported hash algorithm."); + } + + if (algorithm.salt == null) { + throw new Error("HkdfParams: salt: Missing required property."); + } + + if (algorithm.info == null) { + throw new Error("HkdfParams: info: Missing required property."); + } + + if (bits % 8 !== 0) { + throw new Error("The length provided for HKDF is not a multiple of 8 bits."); + } + + if (byteLen > 255 * hLen) { + throw new Error("The length provided for HKDF is too large."); + } + + if (saltBytes.length === 0) { + saltBytes = msrcryptoUtilities.getVector(hLen); + } + + hmacContext = { + workerid: 0, + keyHandle: { algorithm: algorithm }, + keyData: saltBytes, + buffer: keyBytes + }; + + hmacContext.keyData = msrcryptoHmac.signHmac(hmacContext); + + for (i = 0; i < Math.ceil(byteLen / hLen); i++) { + hmacContext.buffer = t.concat(infoBytes).concat([1 + i]); + t = msrcryptoHmac.signHmac(hmacContext); + output = output.concat(t); + } + + return output.slice(0, byteLen); + } + + return { + + deriveBits: deriveBits + + }; + +}()); + +if (typeof operations !== "undefined") { + + msrcryptoHkdf.importKey = function(p) { + var keyData; + + if (p.format === "raw") { + keyData = msrcryptoUtilities.toArray(p.keyData); + } else { + throw new Error("unsupported import format"); + } + + if (p.extractable !== false) { + throw new Error("only extractable=false is supported."); + } + + return { + type: "keyImport", + keyData: keyData, + keyHandle: { + algorithm: { name: "HKDF" }, + extractable: false, + usages: p.usages, + type: "secret" + } + }; + + }; + + operations.register("deriveBits", "HKDF", msrcryptoHkdf.deriveBits); + operations.register("importKey", "HKDF", msrcryptoHkdf.importKey); +} + +var msrcryptoHkdfCtr = (function () { + + function deriveBits(p) { + + var algorithm = p.algorithm, + keyBytes = p.keyData, + bits = p.length, + labelBytes = algorithm.label, + contextBytes = algorithm.context, + byteLen = Math.ceil(bits / 8), + hLen, + output = [], + i, + hmacContext; + + switch (algorithm.hash.name.toUpperCase()) { + case "SHA-1": hLen = 20; break; + case "SHA-256": hLen = 32; break; + case "SHA-384": hLen = 48; break; + case "SHA-512": hLen = 64; break; + default: throw new Error("Unsupported hash algorithm."); + } + + if (algorithm.label == null) { + throw new Error("HkdfCtrParams: label: Missing required property."); + } + + if (algorithm.context == null) { + throw new Error("HkdfCtrParams: context: Missing required property."); + } + + if (bits % 8 !== 0) { + throw new Error("The length provided for HKDF-CTR is not a multiple of 8 bits."); + } + + if (byteLen > 255 * hLen) { + throw new Error("The length provided for HKDF-CTR is too large."); + } + + hmacContext = { + workerid: 0, + keyHandle: { algorithm: algorithm }, + keyData: keyBytes, + buffer: keyBytes + }; + + var fixed = labelBytes.concat([0],contextBytes,utils.int32ToBytes(bits)); + + for (i = 1; i <= Math.ceil(byteLen / hLen); i++) { + hmacContext.buffer = utils.int32ToBytes(i).concat(fixed); + output = output.concat(msrcryptoHmac.signHmac(hmacContext)); + } + + return output.slice(0, byteLen); + } + + return { + deriveBits: deriveBits + }; + +}()); + +if (typeof operations !== "undefined") { + + msrcryptoHkdfCtr.importKey = function (p) { + var keyData; + + if (p.format === "raw") { + keyData = msrcryptoUtilities.toArray(p.keyData); + } else { + throw new Error("unsupported import format"); + } + + if (p.extractable !== false) { + throw new Error("only extractable=false is supported."); + } + + return { + type: "keyImport", + keyData: keyData, + keyHandle: { + algorithm: { name: "HKDF-CTR" }, + extractable: false, + usages: p.usages, + type: "secret" + } + }; + + }; + + operations.register("deriveBits", "HKDF-CTR", msrcryptoHkdfCtr.deriveBits); + operations.register("importKey", "HKDF-CTR", msrcryptoHkdfCtr.importKey); +} + +var msrcryptoEcdh = function( curve ) { + + var btd = cryptoMath.bytesToDigits, + dtb = cryptoMath.digitsToBytes, + e = curve, + ecop = new cryptoECC.EllipticCurveOperatorFp( curve ); + + function generateKey( privateKeyBytes ) { + + var privateKey = [], + randomBytes = msrcryptoPseudoRandom.getBytes( + curve.order.length * cryptoMath.DIGIT_NUM_BYTES ); + + + + cryptoMath.reduce( + cryptoMath.bytesToDigits( randomBytes ), + e.order, + privateKey ); + + var publicKey = e.allocatePointStorage( ); + + ecop.scalarMultiply( privateKey, e.generator, publicKey ); + + return { + privateKey: { + x: dtb( publicKey.x ), + y: dtb( publicKey.y ), + d: dtb( privateKey ) + }, + publicKey: { + x: dtb( publicKey.x ), + y: dtb( publicKey.y ) + } + }; + } + + function deriveBits( privateKey, publicKey, length ) { + + var publicPoint = new cryptoECC.EllipticCurvePointFp( + e, false, btd( publicKey.x ), btd( publicKey.y ), null, false ); + + var sharedSecretPoint = e.allocatePointStorage(); + ecop.convertToJacobianForm( sharedSecretPoint ); + ecop.convertToMontgomeryForm( sharedSecretPoint ); + + ecop.scalarMultiply( btd( privateKey.d ), publicPoint, sharedSecretPoint ); + + ecop.convertToAffineForm( sharedSecretPoint ); + ecop.convertToStandardForm( sharedSecretPoint ); + + var secretBytes = cryptoMath.digitsToBytes( sharedSecretPoint.x, true, publicKey.x.length ); + + if ( length && secretBytes.length * 8 < length ) { + throw new Error( "DataError" ); + } + + secretBytes = length ? secretBytes.slice( 0, Math.ceil( length / 8 ) ) : secretBytes; + + var bits = length % 8; + var mask = bits === 0 ? 0xFF : 0xFF00 >>> bits; + secretBytes[secretBytes.length - 1] = secretBytes[secretBytes.length - 1] & mask; + + return secretBytes; + } + + function computePublicKey( privateKeyBytes ) { + + if ( !e.generator.isInMontgomeryForm ) { + ecop.convertToMontgomeryForm( e.generator ); + } + + var publicKey = e.allocatePointStorage(); + ecop.convertToJacobianForm( publicKey ); + ecop.convertToMontgomeryForm( publicKey ); + ecop.scalarMultiply( btd( privateKeyBytes ), e.generator, publicKey ); + + return { + x: dtb( publicKey.x ), + y: dtb( publicKey.y ) + }; + } + + return { + + generateKey: generateKey, + deriveBits: deriveBits, + computePublicKey: computePublicKey + }; + +}; + +var ecdhInstance = null; + +if ( typeof operations !== "undefined" ) { + + msrcryptoEcdh.deriveBits = function( p ) { + + var curve = cryptoECC.createCurve( p.algorithm.namedCurve.toUpperCase() ); + + var privateKey = p.keyData; + + var publicKey = p.additionalKeyData; + + ecdhInstance = msrcryptoEcdh( curve ); + + var secretBytes = ecdhInstance.deriveBits( privateKey, publicKey, p.length ); + + return secretBytes; + }; + + msrcryptoEcdh.deriveKey = function( p ) { + + throw new Error( "not supported" ); + + return secretBytes; + }; + + msrcryptoEcdh.generateKey = function( p ) { + + var curve = cryptoECC.createCurve( p.algorithm.namedCurve.toUpperCase() ); + + ecdhInstance = msrcryptoEcdh( curve ); + + var keyPairData = ecdhInstance.generateKey(); + + var partLen = { + "P-256": 32, "P-384": 48, "P-521": 66, + "NUMSP256D1": 32, "NUMSP256T1": 32, + "NUMSP384D1": 48, "NUMSP384T1": 48, + "NUMSP512D1": 64, "NUMSP512T1": 64 + }[p.algorithm.namedCurve]; + var pad = msrcryptoUtilities.padFront; + keyPairData.publicKey.x = pad(keyPairData.publicKey.x, 0, partLen); + keyPairData.publicKey.y = pad(keyPairData.publicKey.y, 0, partLen); + keyPairData.privateKey.x = pad(keyPairData.privateKey.x, 0, partLen); + keyPairData.privateKey.y = pad(keyPairData.privateKey.y, 0, partLen); + keyPairData.privateKey.d = pad(keyPairData.privateKey.d, 0, partLen); + + return { + type: "keyPairGeneration", + keyPair: { + publicKey: { + keyData: keyPairData.publicKey, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: [], + type: "public" + } + }, + privateKey: { + keyData: keyPairData.privateKey, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: p.usages, + type: "private" + } + } + } + }; + }; + + msrcryptoEcdh.importKey = function( p ) { + + try { + + if ( p.format === "raw" ) { + + + var keyData = p.keyData; + + if ( keyData[0] !== 4 ) { throw new Error( "DataError" ); } + + var elementSize = ~~( (keyData.length - 1 ) / 2 ); + + var curveName = p.algorithm.namedCurve.toUpperCase( ); + + var x = keyData.slice( 1, elementSize + 1 ), + y = keyData.slice( elementSize + 1 ); + + if ( cryptoECC.validatePoint( curveName, x, y ) === false ) { + throw new Error( "DataError" ); + } + + return { + type: "keyImport", + keyData: { x: x, y: y }, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable || false, + usages: p.usages, + type: "public" + } + }; + } + + if ( p.format === "jwk" ) { + + var keyObject = msrcryptoJwk.jwkToKey( p.keyData, p.algorithm, ["x", "y", "d", "crv"] ); + + if ( keyObject.d && ( !keyObject.x || !keyObject.y ) ) { + + var curve = cryptoECC.createCurve( p.algorithm.namedCurve.toUpperCase() ); + + ecdhInstance = msrcryptoEcdh( curve ); + + var publicKey = ecdhInstance.computePublicKey( keyObject.d ); + + keyObject.x = publicKey.x; + keyObject.y = publicKey.y; + } + + var partLen = { + "P-256": 32, "P-384": 48, "P-521": 66, + "NUMSP256D1": 32, "NUMSP256T1": 32, + "NUMSP384D1": 48, "NUMSP384T1": 48, + "NUMSP512D1": 64, "NUMSP512T1": 64 + }[p.algorithm.namedCurve]; + if ( keyObject.x ) { keyObject.x = msrcryptoUtilities.padFront(keyObject.x, 0, partLen); } + if ( keyObject.y ) { keyObject.y = msrcryptoUtilities.padFront(keyObject.y, 0, partLen); } + if ( keyObject.d ) { keyObject.d = msrcryptoUtilities.padFront(keyObject.d, 0, partLen); } + + if ( cryptoECC.validatePoint( p.algorithm.namedCurve.toUpperCase( ), keyObject.x, keyObject.y ) === false ) { + throw new Error( "DataError" ); + } + + return { + type: "keyImport", + keyData: keyObject, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable || keyObject.extractable, + usages: p.usages, + type: keyObject.d ? "private" : "public" + } + }; + } + + if ( p.format === "spki" ) { + + var lengths = { + "P-256" : 32, + "P-384" : 48, + "P-521" : 66 + } + + var partLen = lengths[p.algorithm.namedCurve]; + + var privateKeyInfo = asn1.parse(p.keyData); + + if (privateKeyInfo == null) { + throw new Error("invalid key data."); + } + + var bitString = privateKeyInfo[1]; + + var keySequence = bitString.data.slice(bitString.header + 1); + + if (keySequence == null || keySequence.shift() !== 4 || keySequence.length !== partLen * 2) { + throw new Error("invalid key data."); + } + + var x = keySequence.slice(0, partLen), + y = keySequence.slice(partLen) + + if (!msrcryptoUtilities.isBytes(x) || !msrcryptoUtilities.isBytes(y)) { + throw new Error("invalid key data."); + } + + var keyObject = {x:x, y:y}; + + if ( cryptoECC.validatePoint( p.algorithm.namedCurve.toUpperCase( ), keyObject.x, keyObject.y ) === false ) { + throw new Error( "DataError" ); + } + + return { + type: "keyImport", + keyData: keyObject, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: p.usages, + type: "public" + } + }; + + } + + if ( p.format === "pkcs8" ) { + + var lengths = { + "P-256" : 32, + "P-384" : 48, + "P-521" : 66 + } + + var partLen = lengths[p.algorithm.namedCurve]; + + var privateKeyInfo = asn1.parse(p.keyData); + + if (privateKeyInfo == null) { + throw new Error("invalid key data."); + } + + var octetString = privateKeyInfo[2]; + var keySequence = asn1.parse(octetString.data.slice(octetString.header)); + + if (keySequence == null) { + throw new Error("invalid key data."); + } + + var d = keySequence[1].data.slice(keySequence[1].header); + + var bitString = asn1.parse(keySequence[2][0].data); + + var keySequence = bitString.data.slice(bitString.header + 1); + + if (keySequence == null || keySequence.shift() !== 4 || keySequence.length !== partLen * 2) { + throw new Error("invalid key data."); + } + + var x = keySequence.slice(0, partLen), + y = keySequence.slice(partLen) + + if (!msrcryptoUtilities.isBytes(x) || !msrcryptoUtilities.isBytes(y)) { + throw new Error("invalid key data."); + } + + var keyObject = {x:x, y:y, d:d}; + + if ( cryptoECC.validatePoint( p.algorithm.namedCurve.toUpperCase( ), keyObject.x, keyObject.y ) === false ) { + throw new Error( "DataError" ); + } + + return { + type: "keyImport", + keyData: keyObject, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: p.usages, + type: "private" + } + }; + + } + + } catch(err) { + throw msrcryptoUtilities.error("DataError", ""); + } + + }; + + msrcryptoEcdh.exportKey = function( p ) { + var EC_PUBLICKEY = "1.2.840.10045.2.1"; + var curveOid = { + "P-256" : "1.2.840.10045.3.1.7 ", + "P-384" : "1.3.132.0.34", + "P-521" : "1.3.132.0.35" + } + + if ( p.format === "raw" && p.keyHandle.type === "public" ) { + + var keyData = [4].concat( p.keyData.x, p.keyData.y ); + + return { type: "keyExport", keyHandle: keyData }; + } + + if ( p.format === "jwk" ) { + var jsonKeyStringArray = msrcryptoJwk.keyToJwk( p.keyHandle, p.keyData ); + return { type: "keyExport", keyHandle: jsonKeyStringArray }; + } + + if (p.format === "spki") { + var bytes = asn1.encode({ + SEQUENCE: [ + { + SEQUENCE: [ + { "OBJECT IDENTIFIER": EC_PUBLICKEY }, + { "OBJECT IDENTIFIER": curveOid[p.algorithm.namedCurve] } + ] + }, + { + "BIT STRING": [4].concat(p.keyData.x, p.keyData.y) + } + ] + }); + + return { type: "keyExport", keyHandle: bytes }; + } + + if (p.format === "pkcs8") { + var bytes = asn1.encode({ + SEQUENCE: [ + { INTEGER: 0 }, + { + SEQUENCE: [ + { "OBJECT IDENTIFIER": EC_PUBLICKEY }, + { "OBJECT IDENTIFIER": curveOid[p.algorithm.namedCurve] } + ] + }, + { + "OCTET STRING": { + SEQUENCE: [ + { INTEGER: 1 }, + { "OCTET STRING": p.keyData.d }, + { + APPLICATION: [ + {"BIT STRING": [4].concat(p.keyData.x, p.keyData.y)} + ], + tag : 1 + } + ] + } + } + ] + }); + + return { type: "keyExport", keyHandle: bytes }; + } + + throw new Error( "unsupported export format." ); + }; + + operations.register( "importKey", "ECDH", msrcryptoEcdh.importKey ); + operations.register( "exportKey", "ECDH", msrcryptoEcdh.exportKey ); + operations.register( "generateKey", "ECDH", msrcryptoEcdh.generateKey ); + operations.register( "deriveBits", "ECDH", msrcryptoEcdh.deriveBits ); + operations.register( "deriveKey", "ECDH", msrcryptoEcdh.deriveKey ); +} + +var msrcryptoEcdsa = function(curve) { + + var btd = cryptoMath.bytesToDigits, + dtb = cryptoMath.digitsToBytes, + ecop = new cryptoECC.EllipticCurveOperatorFp(curve), + orderByteLength = dtb(curve.order).length, + tedCurve = curve.type === 1; + + function createKey(privateKeyBytes) { + return createKeyInternal(btd(privateKeyBytes)); + } + + function createKeyInternal(privateKeyDigits) { + + var publicKey = curve.allocatePointStorage(); + + ecop.scalarMultiply(privateKeyDigits, curve.generator, publicKey); + + return { + publicKey: publicKey, + privateKey: privateKeyDigits + }; + } + + function generateKey(randomBytes) { + + var privateKey = []; + + if (!randomBytes) { + randomBytes = msrcryptoPseudoRandom.getBytes( + curve.order.length * cryptoMath.DIGIT_NUM_BYTES); + } + + cryptoMath.reduce( + cryptoMath.bytesToDigits(randomBytes), + curve.order, + privateKey); + + return createKeyInternal(privateKey); + } + + function getDigest(messageBytes) { + + if (messageBytes.length > orderByteLength) { + messageBytes.length = orderByteLength; + } + + var digest = btd(messageBytes); + + if (tedCurve) { + var shift = 8 - curve.rbits % 8; + cryptoMath.shiftRight(digest, digest, shift); + } + + cryptoMath.reduce(digest, curve.order, digest); + + return digest; + } + + function sign(privateKey, messageBytes, ephemeralKey) { + + if (!ephemeralKey) { + ephemeralKey = generateKey(); + } + + var r = ephemeralKey.publicKey.x, + k = ephemeralKey.privateKey, + d = btd(privateKey.d), + digest = getDigest(messageBytes.slice()), + s = [], + tmp = [], + signature = null; + + cryptoMath.reduce(r, curve.order, r); + cryptoMath.modMul(r, d, curve.order, s); + cryptoMath.add(s, digest, s); + cryptoMath.reduce(s, curve.order, s); + cryptoMath.modInvCT(k, curve.order, tmp); + cryptoMath.modMul(s, tmp, curve.order, s); + + var rBytes = msrcryptoUtilities.padFront(dtb(r, true, orderByteLength), 0, orderByteLength); + var sBytes = msrcryptoUtilities.padFront(dtb(s, true, orderByteLength), 0, orderByteLength); + + signature = rBytes.concat(sBytes); + + return signature; + } + + function verify(publicKey, signatureBytes, messageBytes) { + + var split = Math.floor(signatureBytes.length / 2), + r = btd(signatureBytes.slice(0, split)), + s = btd(signatureBytes.slice(split)), + digest = getDigest(messageBytes.slice()), + u1 = [], + u2 = []; + + var publicPoint = new cryptoECC.EllipticCurvePointFp( + curve, false, btd(publicKey.x), btd(publicKey.y), null, false); + + cryptoMath.modInv(s, curve.order, s); + cryptoMath.modMul(digest, s, curve.order, u1); + cryptoMath.modMul(r, s, curve.order, u2); + + var r0 = curve.allocatePointStorage(); + var r1 = curve.allocatePointStorage(); + + if (tedCurve) { + cryptoMath.add(u1, u1, u1); + cryptoMath.add(u1, u1, u1); + cryptoMath.reduce(u1, curve.order, u1); + ecop.scalarMultiply(u1, curve.generator, r0, false); + ecop.scalarMultiply(u2, publicPoint, r1, false); + ecop.convertToExtendedProjective(r0); + ecop.convertToExtendedProjective(r1); + ecop.add(r1, r0, r0); + ecop.normalize(r0); + + } else { + ecop.scalarMultiply(u1, curve.generator, r0); + ecop.scalarMultiply(u2, publicPoint, r1); + ecop.convertToJacobianForm(r0); + ecop.convertToMontgomeryForm(r0); + ecop.convertToMontgomeryForm(r1); + ecop.mixedAdd(r0, r1, r0); + ecop.convertToAffineForm(r0); + ecop.convertToStandardForm(r0); + } + + if (r0.isInfinity) { + return false; + } + + cryptoMath.reduce(r0.x, curve.order, r0.x); + + return cryptoMath.compareDigits(r0.x, r) === 0; + } + + return { + createKey: createKey, + generateKey: generateKey, + sign: sign, + verify: verify + }; + +}; + +if (typeof operations !== "undefined") { + + msrcryptoEcdsa.sign = function(p) { + + msrcryptoUtilities.checkParam(p.algorithm.hash, "Object", "algorithm.hash"); + msrcryptoUtilities.checkParam(p.algorithm.hash.name, "String", "algorithm.hash.name"); + msrcryptoUtilities.checkParam(p.keyHandle.algorithm.namedCurve, "String", "p.keyHandle.algorithm.namedCurve"); + + var hashName = p.algorithm.hash.name, + curve = cryptoECC.createCurve(p.keyHandle.algorithm.namedCurve.toUpperCase()), + hashFunc = msrcryptoHashFunctions[hashName.toUpperCase()](), + digest = hashFunc.computeHash(p.buffer); + + var ecdsa = msrcryptoEcdsa(curve); + + return ecdsa.sign(p.keyData, digest); + }; + + msrcryptoEcdsa.verify = function(p) { + + var hashName = p.algorithm.hash.name, + curve = cryptoECC.createCurve(p.keyHandle.algorithm.namedCurve.toUpperCase()), + hashFunc = msrcryptoHashFunctions[hashName.toUpperCase()](), + digest = hashFunc.computeHash(p.buffer); + + var ecdsa = msrcryptoEcdsa(curve); + + return ecdsa.verify(p.keyData, p.signature, digest); + }; + + msrcryptoEcdsa.generateKey = function(p) { + + var curve = cryptoECC.createCurve(p.algorithm.namedCurve.toUpperCase()); + + var ecdsa = msrcryptoEcdsa(curve); + + var keyPairData = ecdsa.generateKey(); + + var dtb = cryptoMath.digitsToBytes; + + var partLen = { + "P-256": 32, "P-384": 48, "P-521": 66, + "NUMSP256D1": 32, "NUMSP256T1": 32, + "NUMSP384D1": 48, "NUMSP384T1": 48, + "NUMSP512D1": 64, "NUMSP512T1": 64 + }[p.algorithm.namedCurve]; + + function padToCurveLength( array ) { + return msrcryptoUtilities.padFront(array, 0, partLen); + } + var x = padToCurveLength(dtb(keyPairData.publicKey.x)); + var y = padToCurveLength(dtb(keyPairData.publicKey.y)); + var d = padToCurveLength(dtb(keyPairData.privateKey)); + + return { + type: "keyPairGeneration", + keyPair: { + publicKey: { + keyData: { + x: x, + y: y + }, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: ["verify"], + type: "public" + } + }, + privateKey: { + keyData: { + x: x, + y: y, + d: d + }, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: ["sign"], + type: "private" + } + } + } + }; + + }; + + msrcryptoEcdsa.importKey = function(p) { + + if (p.format === "raw") { + + + var keyData = p.keyData; + + if (keyData[0] !== 4) { throw msrcryptoUtilities.error("DataError", "invalid point encoding"); } + + var elementSize = ~~((keyData.length - 1) / 2); + + var curveName = p.algorithm.namedCurve.toUpperCase(); + + var x = keyData.slice(1, elementSize + 1), + y = keyData.slice(elementSize + 1); + + if (cryptoECC.validatePoint(curveName, x, y) === false) { + throw msrcryptoUtilities.error("DataError", "the imported point is not on the curve"); + } + + return { + type: "keyImport", + keyData: { x: x, y: y }, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: p.usages, + type: "public" + } + }; + } + + if ( p.format === "jwk" ) { + var keyObject = msrcryptoJwk.jwkToKey( p.keyData, p.algorithm, ["x", "y", "d", "crv"] ); + + if ( keyObject.d && ( !keyObject.x || !keyObject.y ) ) { + + var curve = msrcryptoEcdsa.curves[p.algorithm.namedCurve](); + + var ecdsa = msrcryptoEcdsa( curve ); + + var publicKey = ecdsa.computePublicKey( keyObject.d ); + + keyObject.x = publicKey.x; + keyObject.y = publicKey.y; + } + + var partLen = { + "P-256": 32, "P-384": 48, "P-521": 66, + "NUMSP256D1": 32, "NUMSP256T1": 32, + "NUMSP384D1": 48, "NUMSP384T1": 48, + "NUMSP512D1": 64, "NUMSP512T1": 64 + }[p.algorithm.namedCurve]; + if ( keyObject.x ) { keyObject.x = msrcryptoUtilities.padFront(keyObject.x, 0, partLen); } + if ( keyObject.y ) { keyObject.y = msrcryptoUtilities.padFront(keyObject.y, 0, partLen); } + if ( keyObject.d ) { keyObject.d = msrcryptoUtilities.padFront(keyObject.d, 0, partLen); } + + if (cryptoECC.validatePoint(p.algorithm.namedCurve.toUpperCase(), keyObject.x, keyObject.y) === false) { + throw msrcryptoUtilities.error("DataError", "the imported point is not on the curve"); + } + + return { + type: "keyImport", + keyData: keyObject, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable || keyObject.extractable, + usages: null || p.usages, + type: keyObject.d ? "private" : "public" + } + }; + } + + if ( p.format === "spki" ) { + + var lengths = { + "P-256" : 32, + "P-384" : 48, + "P-521" : 66 + } + + var partLen = lengths[p.algorithm.namedCurve]; + + var privateKeyInfo = asn1.parse(p.keyData); + + if (privateKeyInfo == null) { + throw new Error("invalid key data."); + } + + var bitString = privateKeyInfo[1]; + + var keySequence = bitString.data.slice(bitString.header + 1); + + if (keySequence == null || keySequence.shift() !== 4 || keySequence.length !== partLen * 2) { + throw new Error("invalid key data."); + } + + var x = keySequence.slice(0, partLen), + y = keySequence.slice(partLen) + + if (!msrcryptoUtilities.isBytes(x) || !msrcryptoUtilities.isBytes(y)) { + throw new Error("invalid key data."); + } + + var keyObject = {x:x, y:y}; + + if ( cryptoECC.validatePoint( p.algorithm.namedCurve.toUpperCase( ), keyObject.x, keyObject.y ) === false ) { + throw new Error( "DataError" ); + } + + return { + type: "keyImport", + keyData: keyObject, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: p.usages, + type: "public" + } + }; + + } + + if ( p.format === "pkcs8" ) { + + var lengths = { + "P-256" : 32, + "P-384" : 48, + "P-521" : 66 + } + + var partLen = lengths[p.algorithm.namedCurve]; + + var privateKeyInfo = asn1.parse(p.keyData); + + if (privateKeyInfo == null) { + throw new Error("invalid key data."); + } + + var octetString = privateKeyInfo[2]; + var keySequence = asn1.parse(octetString.data.slice(octetString.header)); + + if (keySequence == null) { + throw new Error("invalid key data."); + } + + var d = keySequence[1].data.slice(keySequence[1].header); + + var bitString = asn1.parse(keySequence[2][0].data); + + var keySequence = bitString.data.slice(bitString.header + 1); + + if (keySequence == null || keySequence.shift() !== 4 || keySequence.length !== partLen * 2) { + throw new Error("invalid key data."); + } + + var x = keySequence.slice(0, partLen), + y = keySequence.slice(partLen) + + if (!msrcryptoUtilities.isBytes(x) || !msrcryptoUtilities.isBytes(y)) { + throw new Error("invalid key data."); + } + + var keyObject = {x:x, y:y, d:d}; + + if ( cryptoECC.validatePoint( p.algorithm.namedCurve.toUpperCase( ), keyObject.x, keyObject.y ) === false ) { + throw new Error( "DataError" ); + } + + return { + type: "keyImport", + keyData: keyObject, + keyHandle: { + algorithm: p.algorithm, + extractable: p.extractable, + usages: p.usages, + type: "private" + } + }; + + } + + }; + + msrcryptoEcdsa.exportKey = function(p) { + var EC_PUBLICKEY = "1.2.840.10045.2.1"; + var curveOid = { + "P-256" : "1.2.840.10045.3.1.7 ", + "P-384" : "1.3.132.0.34", + "P-521" : "1.3.132.0.35" + } + + if (p.format === "raw" && p.keyHandle.type === "public") { + + var keyData = [4].concat(p.keyData.x, p.keyData.y); + + return { type: "keyExport", keyHandle: keyData }; + } + + if (p.format === "jwk") { + var jsonKeyStringArray = msrcryptoJwk.keyToJwk(p.keyHandle, p.keyData); + return { type: "keyExport", keyHandle: jsonKeyStringArray }; + } + + if (p.format === "spki") { + var bytes = asn1.encode({ + SEQUENCE: [ + { + SEQUENCE: [ + { "OBJECT IDENTIFIER": EC_PUBLICKEY }, + { "OBJECT IDENTIFIER": curveOid[p.algorithm.namedCurve] } + ] + }, + { + "BIT STRING": [4].concat(p.keyData.x, p.keyData.y) + } + ] + }); + + return { type: "keyExport", keyHandle: bytes }; + } + + if (p.format === "pkcs8") { + var bytes = asn1.encode({ + SEQUENCE: [ + { INTEGER: 0 }, + { + SEQUENCE: [ + { "OBJECT IDENTIFIER": EC_PUBLICKEY }, + { "OBJECT IDENTIFIER": curveOid[p.algorithm.namedCurve] } + ] + }, + { + "OCTET STRING": { + SEQUENCE: [ + { INTEGER: 1 }, + { "OCTET STRING": p.keyData.d }, + { + APPLICATION: [ + {"BIT STRING": [4].concat(p.keyData.x, p.keyData.y)} + ], + tag : 1 + } + ] + } + } + ] + }); + + return { type: "keyExport", keyHandle: bytes }; + } + + throw new Error("unsupported export format."); + + }; + + operations.register("sign", "ECDSA", msrcryptoEcdsa.sign); + operations.register("verify", "ECDSA", msrcryptoEcdsa.verify); + operations.register("generateKey", "ECDSA", msrcryptoEcdsa.generateKey); + operations.register("importKey", "ECDSA", msrcryptoEcdsa.importKey); + operations.register("exportKey", "ECDSA", msrcryptoEcdsa.exportKey); +} + +var msrcryptoSubtle; + + +var utils = msrcryptoUtilities; + +msrcryptoSubtle = (function() { +function syncWorker() { + var result; + + function postMessage(data) { + + try { + data.workerid = this.id; + result = msrcryptoWorker.jsCryptoRunner({ data: data }); + } catch (ex) { + this.onerror({ data: ex, type: "error" }); + return; + } + + this.onmessage({ data: result }); + } + + return { + postMessage: postMessage, + onmessage: null, + onerror: null, + terminate: function() { + } + }; +} + +var streamObject = function(op) { + + return { + process: function(buffer) { + return op.process(buffer); + }, + finish: function() { + return op.finish(); + }, + abort: function() { + return op.abort(); + } + }; +}; + +function baseOperation(processResults) { + + var result = null, + oncompleteCallback = null, + onerrorCallback = null, + retObj, + promise, + resolveFunc, + rejectFunc; + + promise = new Promise( + function(resolve, reject) { + resolveFunc = resolve; + rejectFunc = reject; + }); + function opDispatchEvent( e) { + + if (e.type === "error") { + if (rejectFunc) { + if (e.data) { + try { if (!e.data.stack) { e.data.stack = "Error"; } } catch (ex) { } + try { if (e.data.code == null) { e.data.code = 0; } } catch (ex) { } + } + rejectFunc.apply(promise, [e.data || e]); + } + return; + } + + if (e.data.type === "process") { + processResults(e.data.result, true); + return; + } + + if (e.data.type === "finish") { + processResults(e.data.result, true); + return; + } + + this.result = processResults(e.data); + resolveFunc.apply(promise, [this.result]); + + return; + } + + retObj = { + dispatchEvent: opDispatchEvent, + promise: promise, + result: null + }; + + return retObj; +} + +function keyOperation() { + + function toCryptoKey(keyHandle) { + return new CryptoKey(cryptoKeyInternalToken, keyHandle); + } + + function processResult(result) { + + var publicKey, + privateKey, + cryptoKey; + + switch (result.type) { + + case "keyGeneration": + case "keyImport": + case "keyDerive": + if (result.keyPair) { + publicKey = toCryptoKey(result.keyPair.publicKey.keyHandle); + privateKey = toCryptoKey(result.keyPair.privateKey.keyHandle); + keys.add(publicKey, result.keyPair.publicKey.keyData); + keys.add(privateKey, result.keyPair.privateKey.keyData); + return { + publicKey: publicKey, + privateKey: privateKey + }; + } else { + cryptoKey = toCryptoKey(result.keyHandle); + keys.add(cryptoKey, result.keyData); + return cryptoKey; + } + + case "keyExport": + return result.keyHandle; + + case "keyPairGeneration": + publicKey = toCryptoKey(result.keyPair.publicKey.keyHandle); + privateKey = toCryptoKey(result.keyPair.privateKey.keyHandle); + keys.add(publicKey, result.keyPair.publicKey.keyData); + keys.add(privateKey, result.keyPair.privateKey.keyData); + return { + publicKey: publicKey, + privateKey: privateKey + }; + + default: + throw new Error("Unknown key operation"); + } + } + + return baseOperation(processResult); +} + +function toArrayBufferIfSupported(dataArray) { + + if (typedArraySupport && dataArray.pop) { + + return (new Uint8Array(dataArray)).buffer; + } + + return dataArray; +} + +function cryptoOperation(cryptoContext) { + + function processResult(result, isProcessCall) { + + result = result && toArrayBufferIfSupported(result); + + if (isProcessCall) { + promiseQueue.resolve(result); + return; + } + + return result; + } + + var promiseQueue = [], + op = baseOperation(processResult); + + op.stream = cryptoContext.algorithm.stream; + + promiseQueue.add = function(label) { + + var resolveFunc, + rejectFunc, + promise = new Promise( + function(resolve, reject) { + resolveFunc = resolve; + rejectFunc = reject; + }); + + promise.label = label; + + promiseQueue.push({ + resolve: resolveFunc, + reject: rejectFunc, + promise: promise + }); + + return promise; + }; + + promiseQueue.resolve = function(result) { + var queueItem = promiseQueue.shift(); + queueItem.resolve.apply(queueItem.promise, [result]); + }; + + op.process = function(buffer) { + cryptoContext.operationSubType = "process"; + cryptoContext.buffer = utils.toArray(buffer); + workerManager.continueJob(this, + utils.clone(cryptoContext)); + + return promiseQueue.add("process"); + }; + + op.finish = function() { + cryptoContext.operationSubType = "finish"; + cryptoContext.buffer = []; + workerManager.continueJob(this, + utils.clone(cryptoContext)); + + return promiseQueue.add("finish"); + }; + + op.abort = function() { + workerManager.abortJob(this); + }; + op.algorithm = cryptoContext.algorithm || null; + op.key = cryptoContext.keyHandle || null; + + return op; +} + +var keys = []; + +keys.add = function(cryptoKey, keyData) { + keys.push({ cryptoKey: cryptoKey, keyData: keyData }); +}; + +keys.remove = function(cryptoKey) { + for (var i = 0; i < keys.length; i += 1) { + if (keys[i].cryptoKey === cryptoKey) { + keys = keys.splice(i, 1); + return; + } + } +}; + +keys.lookup = function(cryptoKey) { + for (var i = 0; i < keys.length; i += 1) { + if (keys[i].cryptoKey === cryptoKey) { + return keys[i].keyData; + } + } + return null; +}; + +var workerManager = (function() { + + var maxWorkers = 12; + + var maxFreeWorkers = 2; + + var workerPool = []; + + var jobQueue = []; + + var jobId = 0; + + var workerId = 0; + + var callbackQueue = []; + + var setFunction = typeof setImmediate === "undefined" ? setTimeout : setImmediate; + + function executeNextCallback() { + callbackQueue.shift()(); + } + + function queueCallback(callback) { + callbackQueue.push(callback); + setFunction(executeNextCallback, 0); + } + + var workerStatus = webWorkerSupport ? "available" : "unavailable"; + + function getFreeWorker() { + + purgeWorkerType(!asyncMode); + + for (var i = 0; i < workerPool.length; i++) { + if (!workerPool[i].busy) { + return workerPool[i]; + } + } + + return null; + } + + function purgeWorkerType(webWorker) { + for (var i = workerPool.length - 1; i >= 0; i -= 1) { + if (workerPool[i].isWebWorker === webWorker) { + workerPool[i].terminate(); + workerPool.splice(i, 1); + } + } + } + + function freeWorkerCount() { + var freeWorkers = 0; + for (var i = 0; i < workerPool.length; i++) { + if (!workerPool[i].busy) { + freeWorkers += 1; + } + } + return freeWorkers; + } + + function addWorkerToPool(worker) { + workerPool.push(worker); + } + + function removeWorkerFromPool(worker) { + for (var i = 0; i < workerPool.length; i++) { + if (workerPool[i] === worker) { + worker.terminate(); + workerPool.splice(i, 1); + return; + } + } + } + + function lookupWorkerByOperation(operation) { + for (var i = 0; i < workerPool.length; i++) { + if (workerPool[i].operation === operation) { + return workerPool[i]; + } + } + return null; + } + + function queueJob(operation, data) { + jobQueue.push({ operation: operation, data: data, id: jobId++ }); + } + + function jobCompleted(worker) { + + worker.busy = false; + + if (asyncMode) { + if (jobQueue.length > 0) { + + var job = jobQueue.shift(), + i; + + continueJob(job.operation, job.data); + + if (job.data.operationSubType === "process") { + for (i = 0; i < jobQueue.length; i++) { + if (job.operation === jobQueue[i].operation) { + continueJob(jobQueue[i].operation, jobQueue[i].data); + } + } + for (i = jobQueue.length - 1; i >= 0; i--) { + if (job.operation === jobQueue[i].operation) { + jobQueue.splice(i, 1); + } + } + } + } else if (freeWorkerCount() > maxFreeWorkers) { + removeWorkerFromPool(worker); + } + } + + } + + function createNewWorker(operation) { + + var worker; + + if (workerStatus === "pending") { + throw new Error("Creating new worker while workerstatus=pending"); + } + + if (workerStatus === "ready") { + try { + worker = new Worker(scriptUrl); + worker.postMessage({ prngSeed: msrcryptoPseudoRandom.getBytes(48) }); + worker.isWebWorker = true; + } catch (ex) { + asyncMode = false; + workerStatus = "failed"; + worker.terminate(); + worker = syncWorker(); + worker.isWebWorker = false; + } + + } else { + worker = syncWorker(); + worker.isWebWorker = false; + } + + worker.operation = operation; + + worker.id = workerId++; + + worker.busy = false; + + worker.onmessage = function( e) { + + if (e.data == null) { + return; + } + + if (e.data.initialized === true) { + return; + } + + var op = worker.operation; + + e.target || (e.target = { data: worker.data }); + + if (e.data.error) { + jobCompleted(worker); + op.dispatchEvent({ + type: "error", + data: utils.error(e.data.error.name, e.data.error.message) + }); + return; + } + + for (var i = 0; i < jobQueue.length; i++) { + if (jobQueue[i].operation === worker.operation) { + var job = jobQueue[i]; + jobQueue.splice(i, 1); + postMessageToWorker(worker, job.data); + return; + } + } + + if (!(e.data.hasOwnProperty("type") && e.data.type === "process")) { + jobCompleted(worker); + } + + op.dispatchEvent(e); + }; + + worker.onerror = function(e) { + + var op = worker.operation; + + jobCompleted(worker); + + op.dispatchEvent(e); + }; + + addWorkerToPool(worker); + + return worker; + } + + function useWebWorkers(enable) { + + if (workerStatus === "unavailable") { + utils.consoleLog("web workers not available in this browser."); + return; + } + + if (enable === true && workerStatus === "ready") { + return; + } + + if (enable === false && workerStatus === "available") { + return; + } + + if (enable === false && workerStatus === "ready") { + asyncMode = false; + workerStatus = "available"; + utils.consoleLog("web workers disabled."); + return; + } + + if (workerStatus === "pending") { + return; + } + + workerStatus = "pending"; + + var worker = new Worker(scriptUrl); + + function setWorkerStatus(e) { + var succeeded = !!(e.data && e.data.initialized === true); + worker.removeEventListener("message", setWorkerStatus, false); + worker.removeEventListener("error", setWorkerStatus, false); + worker.terminate(); + workerStatus = succeeded ? "ready" : "failed"; + asyncMode = succeeded; + utils.consoleLog("web worker initialization " + (succeeded ? "succeeded. Now using web workers." : + "failed. running synchronously." + (e.message || ""))); + if (jobQueue.length > 0) { + var job = jobQueue.shift(); + runJob(job.operation, job.data); + } + return; + } + + worker.addEventListener("message", setWorkerStatus, false); + worker.addEventListener("error", setWorkerStatus, false); + + worker.postMessage({ prngSeed: msrcryptoPseudoRandom.getBytes(48) }); + + return; + } + + function abortJob(cryptoOperationObject) { + var worker = lookupWorkerByOperation(cryptoOperationObject); + if (worker) { + removeWorkerFromPool(worker); + } + } + + function runJob(operation, data) { + + var worker = null; + + if (workerStatus === "pending") { + queueJob(operation, data); + return; + } + + worker = getFreeWorker(); + + if (asyncMode && worker === null && workerPool.length >= maxWorkers) { + queueJob(operation, data); + return; + } + + if (worker === null) { + worker = createNewWorker(operation); + } + + if (worker === null) { + queueJob(operation, data); + throw new Error("could not create new worker"); + } + + worker.operation = operation; + + worker.busy = true; + + data.workerid = worker.id; + + postMessageToWorker(worker, data); + } + + function continueJob(operation, data) { + + var worker = lookupWorkerByOperation(operation); + + if (worker) { + postMessageToWorker(worker, data); + return; + } + + runJob(operation, data); + } + function postMessageToWorker(worker, data) { + + data.workerid = worker.id; + + if (asyncMode) { + + worker.postMessage(data); + + } else { + + var func = (function(postData) { + return function() { + return worker.postMessage(postData); + }; + })(data); + + queueCallback(func); + } + + return; + } + + return { + runJob: runJob, + continueJob: continueJob, + abortJob: abortJob, + useWebWorkers: useWebWorkers + }; + +})(); + +function checkOperation(operationType, algorithmName) { + if (!operations.exists(operationType, algorithmName)) { + throw utils.error("NotSupportedError", "Unrecognized or unsupported algorithm."); + } +} + +var subtleParameters = [ + { name: "algorithm", type: "Object", required: true }, + { name: "keyHandle", type: "Object", required: true }, + { name: "buffer", type: "Array", required: false }, + { name: "signature", type: "Array", required: true }, + { name: "format", type: "String", required: true }, + { name: "keyData", type: "Object", required: true }, + { name: "extractable", type: "Boolean", required: false }, + { name: "usages", type: "Array", required: false }, + { name: "derivedKeyType", type: "Object", required: true }, + { name: "length", type: "Number", required: false }, + { name: "extractable", type: "Boolean", required: true }, + { name: "usages", type: "Array", required: true }, + { name: "keyData", type: "Array", required: true } +]; + +var subtleParametersSets = { + encrypt: [0, 1, 2], + decrypt: [0, 1, 2], + sign: [0, 1, 2], + verify: [0, 1, 3, 2], + digest: [0, 2], + generateKey: [0, 6, 7], + importKeyRaw: [4, 12, 0, 10, 11], + importKeyJwk: [4, 5, 0, 10, 11], + exportKey: [0, 4, 1, 6, 7], + deriveKey: [0, 1, 8, 6, 7], + deriveBits: [0, 1, 9] +}; + +function lookupKeyData(handle) { + var data = keys.lookup(handle); + + if (!data) { + throw utils.error("InvalidAccessError", "key not found"); + } + + return data; +} + +function buildParameterCollection(operationName, parameterSet) { + + var parameterCollection = { operationType: operationName }, + operationParameterSet, + expectedParam, + actualParam, + i; + + if (operationName === "importKey" && (parameterSet[0] === "raw" || parameterSet[0] === "spki" || parameterSet[0] === "pkcs8")) { + operationName = "importKeyRaw"; + } + + if (operationName === "importKey" && parameterSet[0] === "jwk") { + operationName = "importKeyJwk"; + } + + operationParameterSet = subtleParametersSets[operationName]; + + for (i = 0; i < operationParameterSet.length; i += 1) { + + expectedParam = subtleParameters[operationParameterSet[i]]; + actualParam = parameterSet[i]; + + if (actualParam == null) { + if (expectedParam.required) { + throw new TypeError("Missing required parameter: " + expectedParam.name); + } else { + continue; + } + } + + if (expectedParam.name === "algorithm" && utils.getObjectType(actualParam) === "String") { + actualParam = { name: actualParam }; + } + + if (actualParam.subarray) { + actualParam = utils.toArray(actualParam); + } + + if (utils.getObjectType(actualParam) === "ArrayBuffer") { + actualParam = utils.toArray(actualParam); + } + + if (msrcryptoUtilities.getObjectType(actualParam) !== expectedParam.type) { + throw new TypeError("Invalid type for parameter: " + expectedParam.name); + } + + if (expectedParam.name === "algorithm") { + + actualParam.name = actualParam.name.toUpperCase(); + + if (actualParam.iv) { + actualParam.iv = utils.toArray(actualParam.iv); + } + + if (actualParam.publicExponent) { + actualParam.publicExponent = utils.toArray(actualParam.publicExponent); + } + + if (actualParam.salt) { + actualParam.salt = utils.toArray(actualParam.salt); + } + + if (actualParam.additionalData) { + actualParam.additionalData = utils.toArray(actualParam.additionalData); + } + + if (actualParam.hash && !actualParam.hash.name && utils.getObjectType(actualParam.hash) === "String") { + actualParam.hash = { name: actualParam.hash }; + } + } + + if (parameterCollection.hasOwnProperty(expectedParam.name)) { + parameterCollection[expectedParam.name + "1"] = actualParam; + } else { + parameterCollection[expectedParam.name] = actualParam; + } + } + + return parameterCollection; +} + +function executeOperation(operationName, parameterSet, keyFunc) { + + try { + + var pc = buildParameterCollection(operationName, parameterSet); + + checkOperation(operationName, pc.algorithm.name); + + if (pc.keyHandle) { + pc.keyData = lookupKeyData(pc.keyHandle); + } + + if (pc.keyHandle1) { + pc.keyData1 = lookupKeyData(pc.keyHandle1); + } + + if (pc.algorithm && pc.algorithm.public) { + pc.additionalKeyData = lookupKeyData(pc.algorithm.public); + } + + var op = keyFunc ? keyOperation(pc) : cryptoOperation(pc); + + if (keyFunc || pc.buffer || operationName === "deriveBits") { + workerManager.runJob(op, pc); + } + + if (op.stream) { + return Promise.resolve(streamObject(op)); + } + + return op.promise; + + } catch (error) { + return Promise.reject(error); + } +} +var publicMethods = { + + encrypt: function(algorithm, cryptoKey, buffer) { + + return executeOperation("encrypt", arguments, 0); + }, + + decrypt: function(algorithm, cryptoKey, buffer) { + + return executeOperation("decrypt", arguments, 0); + }, + + sign: function(algorithm, cryptoKey, buffer) { + + return executeOperation("sign", arguments, 0); + }, + + verify: function(algorithm, cryptoKey, signature, buffer) { + + return executeOperation("verify", arguments, 0); + }, + + digest: function(algorithm, buffer) { + return executeOperation("digest", arguments, 0); + }, + + generateKey: function(algorithm, extractable, keyUsage) { + + return executeOperation("generateKey", arguments, 1); + }, + + deriveKey: function(algorithm, baseKey, derivedKeyType, extractable, keyUsage) { + + var deriveBits = this.deriveBits, + importKey = this.importKey; + + return new Promise(function(resolve, reject) { + + var keyLength; + + if (derivedKeyType.hash && !derivedKeyType.hash.name && utils.getObjectType(derivedKeyType.hash) === "String") { + derivedKeyType.hash = { name: derivedKeyType.hash }; + } + + switch (derivedKeyType.name.toUpperCase()) { + case "AES-CBC": + case "AES-GCM": + keyLength = derivedKeyType.length; + break; + case "HMAC": + keyLength = derivedKeyType.length || + { "SHA-1": 512, "SHA-224": 512, "SHA-256": 512, "SHA-384": 1024, "SHA-512": 1024 }[derivedKeyType.hash.name.toUpperCase()]; + break; + default: + reject(new Error("No Supported")); + return; + } + + deriveBits(algorithm, baseKey, keyLength) + .then(function(bits) { + return importKey("raw", bits, derivedKeyType, extractable, keyUsage); + }) + .then(function(key) { + resolve(key); + }) + ["catch"](function(err) { + reject(err); + }); + + }); + + }, + + deriveBits: function(algorithm, baseKey, length) { + + return executeOperation("deriveBits", arguments, 0); + }, + + importKey: function(format, keyData, algorithm, extractable, keyUsage) { + return executeOperation("importKey", arguments, 1); + }, + + exportKey: function(format, cryptoKey) { + + return executeOperation("exportKey", [cryptoKey.algorithm, format, cryptoKey], 1); + }, + + wrapKey: function(format, key, wrappingKey, wrappingKeyAlgorithm) { + + var encrypt = this.encrypt, + exportKey = this.exportKey; + + return new Promise(function(resolve, reject) { + + if (key.extractable === false || + utils.indexOf(wrappingKey.usages, "wrapKey") < 0 || + wrappingKey.algorithm.name.toUpperCase() !== wrappingKeyAlgorithm.name) { + reject(utils.error("InvalidAccessError", "key cannot be wrapped with the supplied wrapping key")); + return; + } + + exportKey(format, key) + + .then(function(keyData) { + + return encrypt(wrappingKeyAlgorithm, wrappingKey, format === "jwk" ? + utils.stringToBytes(JSON.stringify(keyData, null, 0)) : keyData); + }) + + .then(function(cipherArrayBuffer) { + resolve(cipherArrayBuffer); + }) + + ["catch"](function(err) { + reject(err); + }); + }); + }, + + unwrapKey: function(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) { + + var decrypt = this.decrypt, + importKey = this.importKey; + + return new Promise(function(resolve, reject) { + + if (utils.indexOf(unwrappingKey.usages, "unwrapKey") < 0 || + unwrappingKey.algorithm.name.toUpperCase() !== unwrapAlgorithm.name) { + reject(utils.error("InvalidAccessError", "key cannot be unwrapped with the supplied unwrapping key")); + return; + } + + decrypt(unwrapAlgorithm, unwrappingKey, wrappedKey) + + .then(function(keyPlain) { + return importKey(format, format === "jwk" ? JSON.parse(utils.bytesToString(keyPlain)) : keyPlain, + unwrappedKeyAlgorithm, extractable, keyUsages); + }) + + .then(function(key) { + resolve(key); + }) + + ["catch"](function(err) { + reject(err); + }); + }); + + } + +}; + +var internalMethods = { + useWebWorkers: workerManager.useWebWorkers +}; + +return { + publicMethods : publicMethods, + internalMethods: internalMethods}; + +}) (); + +var publicMethods = { + + subtle: msrcryptoSubtle ? msrcryptoSubtle.publicMethods : null, + + CryptoKey: CryptoKey, + + getRandomValues: function(array) { + + var i; + + var arrayType = msrcryptoUtilities.getObjectType(array); + if (arrayType === "Float32Array" || arrayType === "Float64Array") { + throw msrcryptoUtilities.error("TypeMismatchError", + "The provided ArrayBufferView is not an integer-typed array."); + } + + var byteLength = (array.byteLength != null) ? array.byteLength : (array.length || 0); + if (byteLength > 65536) { + throw msrcryptoUtilities.error("QuotaExceededError", + "The ArrayBufferView's byte length (" + byteLength + + ") exceeds the number of bytes of entropy available via this API (65536)."); + } + + var randomValues = msrcryptoPseudoRandom.getBytes(array.length); + for (i = 0; i < array.length; i += 1) { + array[i] = randomValues[i]; + } + return array; + }, + + initPrng: function(entropyData) { + + var entropyDataType = Object.prototype.toString.call(entropyData); + + if (entropyDataType !== "[object Array]" && entropyDataType !== "[object Uint8Array]") { + throw new Error("entropyData must be a Array or Uint8Array"); + } + + entropyPool && entropyPool.reseed(entropyData); + + msrcryptoPseudoRandom.reseed(entropyPool.read(48)); + fprngEntropyProvided = true; + }, + + toBase64: function(data, base64Url) { + + return msrcryptoUtilities.toBase64(data, base64Url); + }, + + fromBase64: function(base64String) { + return msrcryptoUtilities.fromBase64(base64String); + }, + + textToBytes: function(text) { + return msrcryptoUtilities.stringToBytes(text); + }, + + bytesToText: function(byteArray) { + return msrcryptoUtilities.bytesToString(byteArray); + }, + + asn1 : asn1, + + url : scriptUrl, + + version: msrCryptoVersion, + + useWebWorkers : function(useWebWorkers) { + return msrcryptoSubtle ? msrcryptoSubtle.internalMethods.useWebWorkers(useWebWorkers) : null; + } +}; + + + +var entropyPool; + +entropyPool = entropyPool || new MsrcryptoEntropy(global); + +entropyPool.init(); +var localEntropy = entropyPool.read(48); +msrcryptoPseudoRandom.init(localEntropy); + +return publicMethods; + +} + +return msrCrypto(); + +})); + +(function(factory) { + + var globalObject = (function() { + if (typeof globalThis !== "undefined") { return globalThis; } + if (typeof self !== "undefined") { return self; } + if (typeof window !== "undefined") { return window; } + if (typeof global !== "undefined") { return global; } + return this; + })(); + + var providedPromise = (typeof globalObject.Promise !== "undefined") + ? globalObject.Promise + : factory(); + + if (typeof module === "object" && module.exports) { + module.exports.Promise = module.exports.Promise || providedPromise; + } else if (globalObject.msrCrypto) { + globalObject.msrCrypto.Promise = globalObject.msrCrypto.Promise || providedPromise; + } + + if (typeof globalObject.Promise === "undefined") { + globalObject.Promise = providedPromise; + } + +}(function() { + + var Promise = function(executor, id) { + + if (!(this instanceof Promise)) { + throw new Error("use 'new' keyword with Promise constructor"); + } + + var state = 0, + settledValue = null, + handlers = []; + + function runHandler(handler) { + + var callback = (state === 1) ? handler.onCompleted : handler.onRejected; + + if (!callback) { + (state === 1 ? handler.resolveNext : handler.rejectNext)(settledValue); + return; + } + + var result; + try { + result = callback(settledValue); + } catch (handlerError) { + handler.rejectNext(handlerError); + return; + } + + handler.resolveNext(result); + } + + function settle(newState, value) { + + if (state !== 0) { + return; + } + + if (newState === 1 && value && (typeof value === "object" || typeof value === "function")) { + + var thenFunction; + try { + thenFunction = value.then; + } catch (accessError) { + settle(2, accessError); + return; + } + + if (typeof thenFunction === "function") { + var handled = false; + try { + thenFunction.call( + value, + function(result) { if (!handled) { handled = true; settle(1, result); } }, + function(reason) { if (!handled) { handled = true; settle(2, reason); } }); + } catch (thenableError) { + if (!handled) { handled = true; settle(2, thenableError); } + } + return; + } + } + + state = newState; + settledValue = value; + + for (var i = 0; i < handlers.length; i += 1) { + runHandler(handlers[i]); + } + handlers = []; + } + + function resolve(param) { + settle(1, param); + } + + function reject(param) { + settle(2, param); + } + + this.then = function(onCompleted, onRejected) { + + var resolveNext, rejectNext; + + var nextPromise = new Promise(function(resolve, reject) { + resolveNext = resolve; + rejectNext = reject; + }); + + var handler = { + onCompleted: (typeof onCompleted === "function") ? onCompleted : null, + onRejected: (typeof onRejected === "function") ? onRejected : null, + resolveNext: resolveNext, + rejectNext: rejectNext + }; + + if (state === 0) { + handlers.push(handler); + } else { + runHandler(handler); + } + + return nextPromise; + }; + + this["catch"] = function(onRejected) { + return this.then(null, onRejected); + }; + + try { + executor(resolve, reject); + } catch (executorError) { + reject(executorError); + } + + return; + }; + + + Promise.all = function(promiseArray) { + + var results = [], + resultCount = 0, + promiseAll; + + function then(index, resolve) { + + return function(result) { + + results[index] = result; + + resultCount += 1; + if (resultCount === promiseArray.length) { + resolve(results); + } + }; + } + + promiseAll = new Promise( + + function(resolve, reject) { + + var i; + + function r(reason) { reject(reason); } + + for (i = 0; i < promiseArray.length; i += 1) { + + if (promiseArray[i].then) { + promiseArray[i].then(then(i, resolve)); + promiseArray[i]["catch"](r); + continue; + } + Promise.resolve(promiseArray[i]).then(then(i, resolve)); + } + }); + + return promiseAll; + }; + + Promise.race = function(promiseArray) { + + var resolved = false, + promiseRace; + + function then(resolveFunction) { + + return function(result) { + + if (!resolved) { + resolved = true; + resolveFunction(result); + } + }; + } + + promiseRace = new Promise( + + function(resolve, reject) { + + for (var i = 0; i < promiseArray.length; i += 1) { + promiseArray[i].then(then(resolve), then(reject)); + } + }); + + return promiseRace; + }; + + Promise.reject = function(rejectReason) { + + return new Promise( + function(resolve, reject) { + reject(rejectReason); + }); + }; + + Promise.resolve = function(resolveResult) { + + return new Promise( + function(resolve, reject) { + resolve(resolveResult); + }); + }; + + + return Promise; + +})); diff --git a/dist/msrcrypto.min.js b/dist/msrcrypto.min.js new file mode 100644 index 0000000..964673b --- /dev/null +++ b/dist/msrcrypto.min.js @@ -0,0 +1,19 @@ +//******************************************************************************* +// +// Copyright 2020 Microsoft +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//******************************************************************************* + +"use strict";var msrCryptoVersion="1.7.0";(function(Nr,Mr){if(typeof define==="function"&&define.amd){define([],function(){return Nr.msrCrypto=Mr(Nr)})}else if(typeof exports==="object"){module.exports=Mr(Nr)}else{Nr.msrCrypto=Mr(Nr)}})(this,function(Nr){Nr=Nr||{};var Mr=function(){var Q={};Q.register=function(r,t,n){if(!Object.prototype.hasOwnProperty.call(Q,r)||typeof Q[r]!=="object"){Q[r]={}}var l=Q[r];if(!Object.prototype.hasOwnProperty.call(l,t)){l[t]=n}};Q.exists=function(r,t){if(!Object.prototype.hasOwnProperty.call(Q,r)||typeof Q[r]!=="object"){return false}var n=Q[r];return Object.prototype.hasOwnProperty.call(n,t)&&typeof n[t]==="function"};var Vr=(function(){if(typeof document!=="undefined"){try{throw new Error}catch(t){if(t.stack){var r=/\w+:\/\/(?:[^/\s]+\/)*[^/\s]*\.js/.exec(t.stack);return r&&r.length>0?r[0]:null}}}else if(typeof self!=="undefined"&&typeof self.location!=="undefined"){return self.location.href}return null})();var he=false;var xe=typeof Worker!=="undefined";var ee=typeof importScripts==="function"&&self instanceof WorkerGlobalScope;var Qr=false;var $r=typeof ArrayBuffer!=="undefined";var ve=(function(){try{Object.defineProperty({},"oncomplete",{});return true}catch(r){return false}})();var Tr=false;var qr=function(r,t,n,l,F){if(!ve){r[t]=n;return}var v={};l&&(v.get=l);F&&(v.set=F);Object.defineProperty(r,t,v)};var Pr={};var te={};function ge(r,t){if(r!==te){throw new Error("Illegal constructor")}for(var n in t){if(t.hasOwnProperty(n)){this[n]=t[n]}}}var J=(function(){var r="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";function t(A){if("console"in self&&"log"in console){console.log(A)}}function n(A,W){var s=F(A);if(s!=="Array"&&s!=="Uint8Array"&&s!=="ArrayBuffer"){throw new Error("invalid input")}var C="";var M=h(A);if(!W){W=false}var O,Y,z,Z,ir,yr,er;var fr;for(fr=0;fr>2;ir=(O&3)<<4|Y>>4;yr=(Y&15)<<2|z>>6;er=z&63;if(isNaN(Y)){yr=er=64}else if(isNaN(z)){er=64}C=C+r.charAt(Z)+r.charAt(ir)+r.charAt(yr)+r.charAt(er)}if(W){return C.replace(/\+/g,"-").replace(/\//g,"_").replace(/\=/g,"")}return C}function l(A){A=A.replace(/-/g,"+").replace(/_/g,"/");while(A.length%4!==0){A+="="}var W=[];var s,C,M;var O,Y,z,Z;var ir;A=A.replace(/[^A-Za-z0-9\+\/\=]/g,"");for(ir=0;ir>4;C=(Y&15)<<4|z>>2;M=(z&3)<<6|Z;W.push(s);if(z!==64){W.push(C)}if(Z!==64){W.push(M)}}return W}function F(A){return Object.prototype.toString.call(A).slice(8,-1)}function v(A,W){var s="";if(typeof W==="undefined"){W=false}for(var C=0;C=2){W.push(parseInt(A.substring(0,2),16));A=A.substring(2,A.length)}return W}function c(A){var W={};for(var s in A){if(A.hasOwnProperty(s)){W[s]=A[s]}}return W}function d(A,W,s){var C=l(A),M=[],O;if(isNaN(W)){return C}else{for(O=0;O>>24&255,A>>>16&255,A>>>8&255,A&255]}function y(A){var W=[];for(var s=0;s1){A=new Uint8Array(A.buffer)}if(A.length===1){return[A[0]]}if(A.length<65536){return Array.apply(null,A)}var W=new Array(A.length);for(var s=0;s>>0;var M=s|0;if(M<0){M=Math.max(C+M,0)}for(;M255){return false}}return true}function H(A,W,s){if(!A){throw new Error(s)}if(W&&F(A)!==W){throw new Error(s)}return true}function N(A){var W=[];for(var s=0,C=0;s>>6|192;W[C++]=M&63|128}else if(M<55296||M>57343){W[C++]=M>>>12|224;W[C++]=M>>>6&63|128;W[C++]=M&63|128}else{M=(M-55296)*1024+(A.charCodeAt(++s)-56320)+65536;W[C++]=M>>>18|240;W[C++]=M>>>12&63|128;W[C++]=M>>>6&63|128;W[C++]=M&63|128}}return W}function K(A){var W="",s;A=h(A);for(var C=0;C65535){var O=Math.floor((s-65536)/1024)+55296;var Y=(s-65536)%1024+56320;W+=String.fromCharCode(O,Y);continue}W+=String.fromCharCode(s)}return W}var D={IndexSizeError:1,HierarchyRequestError:3,WrongDocumentError:4,InvalidCharacterError:5,NoModificationAllowedError:7,NotFoundError:8,NotSupportedError:9,InUseAttributeError:10,InvalidStateError:11,SyntaxError:12,InvalidModificationError:13,NamespaceError:14,InvalidAccessError:15,TypeMismatchError:17,SecurityError:18,NetworkError:19,AbortError:20,URLMismatchError:21,QuotaExceededError:22,TimeoutError:23,InvalidNodeTypeError:24,DataCloneError:25};function U(A,W){W=W||"";try{return new DOMException(W,A)}catch(C){var s=new Error(W);s.name=A;if(D.hasOwnProperty(A)){s.code=D[A]}return s}}function b(A){if(!(A instanceof Array))return false;for(var W=0;W255||s<0)return false}return true}function _(A){return typeof A==="number"&&isFinite(A)&&Math.floor(A)===A};return{consoleLog:t,toBase64:n,fromBase64:l,checkParam:H,getObjectType:F,bytesToHexString:v,bytesToInt32:x,stringToBytes:N,bytesToString:K,unpackData:d,hexToBytesArray:E,int32ToBytes:g,int32ArrayToBytes:y,toArray:h,arraysEqual:m,indexOf:u,clone:c,xorVectors:a,padEnd:w,padFront:f,getVector:e,verifyByteArray:p,error:U,isBytes:b,isInteger:_}})();var Lr=(function(){var r={0:"CUSTOM",1:"BOOLEAN",2:"INTEGER",3:"BIT STRING",4:"OCTET STRING",5:"NULL",6:"OBJECT IDENTIFIER",16:"SEQUENCE",17:"SET",19:"PRINTABLE STRING",23:"UTCTime"};var t={0:"UNIVERSAL",1:"APPLICATION",2:"Context-Defined",3:"PRIVATE"};function n(c,d){d=!!d;var g=r[c[0]&31],y=c[1],a=0,e=!!(c[0]&32),h,w,f;if(y&128){for(a=0,y=0;a<(c[1]&127);a++){y=(y<<8)+c[2+a]}}f=2+a;if(g===void 0||y>c.length){return null}var m=e?[]:{};m.type=g;m.header=f;m.data=c.slice(0,y+f);if(e||d){if(m.type==="BIT STRING"&&c[f]===0){a++}h=c.slice(f,m.data.length);while(h.length>0){w=n(h);if(w===null){break}m.push(w);h=h.slice(w.data.length)}}return m}function l(c){var d=2,g=3,y=4,a=5,e=6,h=16,w=160,f=32;if(c.hasOwnProperty("INTEGER")){var m=c.INTEGER;if(J.isInteger(m))m=v(m);if(m[0]&128)m.unshift(0);var u=[d].concat(F(m),m);return u}if(c.hasOwnProperty("OCTET STRING")){var m=c["OCTET STRING"];if(!(m instanceof Array))m=l(m);var u=[y].concat(F(m),m);return u}if(c.hasOwnProperty("BIT STRING")){var m=c["BIT STRING"];if(!(m instanceof Array))m=l(m);m.unshift(0);var u=[g].concat(F(m),m);return u}if(c.hasOwnProperty("NULL")){return[a,0]}if(c.hasOwnProperty("OBJECT IDENTIFIER")){var m=x(c["OBJECT IDENTIFIER"]);var u=[e].concat(F(m),m);return u}if(c.hasOwnProperty("SEQUENCE")){var p=c.SEQUENCE;var m=[];for(var H=0;H0){d.unshift(c&255);c>>>=8}return d}function x(c){var d=c.split(".");var g=[parseInt(d[0]*40+parseInt(d[1]))];for(var y=2;y0){e.push(a&127|128);a=a>>>7}e[0]=e[0]&127;g=g.concat(e.reverse())}return g}function E(c,d){var g=new Array(d+1).join(" ")+c.type+" ("+c.length+") "+bytesToHexString(c.data).substring(0,16)+"\n";if(!c.children){return g}for(var y=0;y=T){X[0]=X[0]*T;Cr=Cr.concat("0")}for(hr=0;hr=0){var L=0;while(L<8){var rr=1<>>S&1)&S)}return T}function f(I){var T=0;var S=0;while(T=0&&S===0){var L=1<>>=1){if(j===T){hr[++X]=0;j=0}hr[X]+=(cr&1)<>>rr|I[L]<>>k.DIGIT_BITS-S}function H(I,T,S){var R=Math.floor(T/r),L=T%r;return I[R]>>>L|I[R+1]<>>r-S}function N(I,T,S,R,L){while(L-- >0){S[R+L]=I[T+L]}}function K(I){var T,S=0;for(T=0;T=0;j--){R=R+E[rr++]*(I[j]&255);if(E[rr]===l){rr=0;S[L++]=R;R=0}}if(R!==0){S[L]=R}while(S[--T]==null){S[T]=0}return S}function _(I,T,S){var R,L,rr;var j=[0];if(typeof T==="undefined"){T=true}for(R=0;RS&&j[0]===0){j.shift()}}return j}function A(I,T){if(typeof T==="undefined"){if(I<=1){T=1}else{var S=Math.log(I)/Math.LN2;T=Math.ceil(S/r)}}var R=[];while(I>0){R.push(I%l);I=Math.floor(I/l)}while(R.length=0;T--){if(I[T]!==void 0&&I[T]!==0){return T}}return I[0]===0?-1:0}function s(I,T){var S=0,R,L;for(L=0;L=r||S<0){throw new Error("Invalid bit count for shiftRight")}if(R===void 0){R=I.length}var L=R-1;var rr=r-S;for(var j=0;j>>S)&n}T[L]=I[L]>>>S}function O(I,T,S,R){if(S===void 0){S=1}else if(S>=r||S<0){throw new Error("bit count must be smaller than DIGIT_BITS and positive in shiftLeft")}if(R===void 0){R=I.length}var L=r-S;T[R]=I[R-1]>>>r-S||T[R];for(var rr=R-1;rr>0;rr--){T[rr]=(I[rr]<>>L)&n}T[0]=I[0]<>r}for(X=rr;X>r}S.length=L.length;if(j!==0){S[X]=j&n}return j}function z(I,T,S){var R=T.length;if(I.length>r}while(L>r}return rr}function Z(I,T,S){T=typeof T==="number"?[T]:T;var R,L,rr,j,X,cr,hr,vr=I.length,Cr=T.length,kr;for(R=0;R=0;lr--){Cr=hr*l+I[lr];S[lr]=Cr/kr&n;hr=Cr-S[lr]*kr&n}S.length=j;C(S);R[0]=hr;R.length=1;return}var fe=r-1-w(T[X-1]);var zr=L||[];zr.length=X;O(T,zr,fe,X);var ur=rr||[];ur.length=j;O(I,ur,fe,j);ur[j]=ur[j]||0;S.length=j-X+1;R.length=X;for(lr=j-X;lr>=0;lr--){cr=Math.floor((ur[lr+X]*l+ur[lr+X-1])/zr[X-1]);hr=ur[lr+X]*l+ur[lr+X-1]-cr*zr[X-1];while(true){if(cr>=l||cr*zr[X-2]>hr*l+ur[lr+X-2]){cr=cr-1;hr=hr+zr[X-1];if(hr>r}ur[lr+X]=ur[lr+X]+vr&n}}for(gr=0;gr>>fe|ur[gr+1]<0){R=T;L=I}fr(R,L,void 0,void 0,S);return C(S)}function nr(I,T,S,R){var L=new Array(T.length);var rr=new Array(T.length);var j=new Array(T.length);var X=fr(I,T,rr,L,j);S=S||[];if(s(j,g)!==0){S[0]=NaN;S.length=1}else{if((X&1)===1){z(T,L,S)}else{N(L,0,S,0,L.length);S.length=L.length}if(R){C(S,T.length,true)}else{C(S)}}return S}function V(I,T,S,R){var L=[];S=S||[];z(T,[2],L);tr(I,L,T,S);C(S);return S}function tr(I,T,S,R){R=R||[];if(s(T,d)===0){R[0]=1}else if(s(T,g)===0){N(I,0,R,0,I.length);R.length=I.length}else{var L=new wr(S);C(I,L.s,true);L.modExp(I,T,R);R.length=S.length}return R}function wr(I,T){function S(q){var G=1;var $=2;var ar=3;var or=ar&q;for(var Fr=2;Fr<=r;Fr+=1){if($0);k.subtract($,or,ar.temp2);Cr(Xe,$,ar.temp2);return}function rr(q){if(q.length>>31;for(Ir=0;Ir0);k.subtract(G,lr,sr);Cr(dr,G,sr);C(G);return}function gr(q){var G=q.length;var $=q[0];var ar={m:q,mPrime:S($),m0:$,temp1:y(2*G+1),temp2:y(2*G+1)};var or=y(q.length*2);or[or.length]=1;ar.mu=[];ir(or,q,ar.mu,[]);var Fr=y(2*G+1);var xr=y(G+1);var Br=y(2*G+1);var Ir=y(2*G+1);var dr=xr;dr[G]=1;ir(dr,q,Fr,xr,Br,Ir);ar.rModM=C(xr,G,true);var sr=y(2*G+1);var br=sr;br[G*2]=1;ir(br,q,Fr,sr,Br,Ir);ar.rSquaredModm=C(sr,G,true);ar.rCubedModm=y(G);L(sr,sr,ar.rCubedModm,ar);return ar}T=T||gr(I);var lr=T.m;var fe=T.mu;var zr=T.m0;var ur=lr.length;var pr=y(ur+1);var Kr=pr.slice(0,ur);Kr[0]=1;var Or=T.mPrime;var Gr=T.rModM;var pe=T.rSquaredModm;var Hr=T.rCubedModm;var o=y(2*ur+1);var B=y(2*ur+1);var P=new Array(4);P[0]=Gr;P[1]=new Array(ur);P[2]=new Array(ur);P[3]=new Array(ur);return{m:lr,m0:zr,mPrime:Or,mu:fe,rSquaredModm:pe,s:ur,rModM:Gr,rCubedModm:Hr,one:Kr,temp1:o,temp2:B,convertToMontgomeryForm:rr,convertToStandardForm:j,montgomeryMultiply:L,modExp:hr,reduce:kr,ctx:T}}function Ur(I){var T=b(I);var S=T.length;var R=A(0,S);var L=A(1,S);var rr=y(S);var j=y(S);var X=new wr(T);function cr(pr){var Kr=b(pr);if(k.compareDigits(Kr,this.m_modulus)>=0){throw new Error("The number provided is not an element of this group")}C(Kr,this.m_digitWidth,true);return ur(Kr,this)}function hr(pr){var Kr=A(pr,this.m_digitWidth);return ur(Kr,this)}function vr(pr){k.normalizeDigitArray(pr,this.m_digitWidth,true);return ur(pr,this)}function Cr(pr){return s(this.m_modulus,pr.m_modulus)===0}function kr(pr,Kr,Or){var Gr;var pe=this.m_digitWidth;var Hr=Or.m_digits;k.add(pr.m_digits,Kr.m_digits,Hr);var o=(s(Hr,this.m_modulus)>>>31)-1&n;var B=0;for(Gr=0;Gr>r}Hr.length=pe}function gr(pr,Kr,Or){var Gr,pe=this.m_digitWidth;var Hr=Or.m_digits;var o=k.subtract(pr.m_digits,Kr.m_digits,Or.m_digits);if(o===-1){o=0;for(Gr=0;Gr>r}}}function lr(pr,Kr){k.modInv(pr.m_digits,this.m_modulus,Kr.m_digits)}function fe(pr,Kr,Or){return k.modMul(pr.m_digits,Kr.m_digits,this.m_modulus,Or.m_digits,rr,j)}function zr(pr,Kr,Or){Or=Or||ur([],this);if(s(Kr,R)===0){Or.m_digits=A(1,this.m_digitWidth)}else if(s(Kr,L)===0){for(var Gr=0;Gr>>k.DIGIT_BITS}G=G<=0){throw new Error("The scalar k must be in the range 1 <= k < order.")}o=o.slice();if(B.curve.type===1){var G=typeof B.ta!=="undefined";if(!G){gr(B)}lr(o,B,P,q);if(!G){zr(B)}}else{var $=B.isInMontgomeryForm,ar=P.isInMontgomeryForm,or=P.isAffine;if(!$){j(B)}if(!ar){j(P)}S(o,B,P);if(or){cr(P)}if(!$){X(B)}if(!ar){X(P)}}return}function S(o,B,P){var q=B.clone();X(q);if(!vr(q)){throw new Error("Invalid Parameters.")}var G=o[0]&1,$=[];z(B.curve.order,o,$);for(sr=0;sr=0;sr--){for(var br=0;br>>31);for(var _r=0;_r=0;or--){for(Fr=0;Fr<$-1;Fr++){ur(xr,xr)}Sr=Math.floor((Math.abs(br[or])-1)/2);var _r=fe(Br,Sr);var Ee=-(br[or]>>>31);z(B.curve.p,_r.x,dr);for(var Xr=0;Xr<_r.x.length;Xr++){_r.x[Xr]=_r.x[Xr]&~Ee|dr[Xr]&Ee}z(B.curve.p,_r.td,dr);for(Xr=0;Xr<_r.td.length;Xr++){_r.td[Xr]=_r.td[Xr]&~Ee|dr[Xr]&Ee}Or(_r,xr,xr)}z(B.curve.p,xr.x,dr);for(or=0;or=F){g=a(g)}return}function m(){if(a(h(g)).length!==0){throw new Error("buffer.length !== 0")}var u=e();g=[];c=n.slice();y=0;return u}return{name:r,computeHash:w,process:f,finish:m,der:t,hashLen:x,maxMessageSize:4294967295}};var ae=(function(){function r(x,E,c,d,g){var y,a,e,h,w=64,f=4294967295;var m=c[0],u=c[1],p=c[2],H=c[3],N=c[4];for(a=0;a<16;a++){g[a]=t.bytesToInt32(x,E*w+a*4)}for(y=16;y<80;y++){h=g[y-3]^g[y-8]^g[y-14]^g[y-16];g[y]=h<<1|h>>>31}for(a=0;a<80;a++){e=m<<5|m>>>27;e+=a>=60?u^p^H:a>=40?u&p^u&H^p&H:a>=20?u^p^H:u&p^~u&H;e+=N+d[a]+g[a];N=H;H=p;p=u<<30|u>>>2;u=m;m=e}c[0]+=m&f;c[1]+=u&f;c[2]+=p&f;c[3]+=H&f;c[4]+=N&f;return c}var t=J,n=t.unpackData,l=n("Z0UjAe/Nq4mYutz+EDJUdsPS4fA=",4,1),F=n("WoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroY8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdY",4,1),v=n("MCEwCQYFKw4DAhoFAAQU");return{sha1:function(){return we("SHA-1",v,l,F,64,r,160)}}})();if(typeof Q!=="undefined"){ae.instances={};ae.getInstance=function(r){return ae.instances[r]||(ae.instances[r]=ae.sha1())};ae.deleteInstance=function(r){ae.instances[r]=null;delete ae.instances[r]};ae.hash=function(r){if(r.operationSubType==="process"){ae.sha1.process(r.buffer);return}if(r.operationSubType==="finish"){return ae.sha1.finish()}return ae.sha1().computeHash(r.buffer)};Q.register("digest","SHA-1",ae.hash)}Pr["SHA-1"]=ae.sha1;var Ar=(function(){var r=J;function t(c,d,g,y,a){var e,h,w,f,m,u=64,p=4294967295;var H=g[0],N=g[1],K=g[2],D=g[3],U=g[4],b=g[5],_=g[6],A=g[7];for(h=0;h<16;h++){a[h]=r.bytesToInt32(c,d*u+h*4)}for(e=16;e<64;e++){f=a[e-15];m=a[e-2];a[e]=((m>>>17|m<<15)^(m>>>19|m<<13)^m>>>10)+a[e-7]+((f>>>7|f<<25)^(f>>>18|f<<14)^f>>>3)+a[e-16];a[e]=a[e]&p}for(h=0;h<64;h++){w=A+((U>>>6|U<<26)^(U>>>11|U<<21)^(U>>>25|U<<7))+(U&b^~U&_)+y[h]+a[h];D+=w;w+=((H>>>2|H<<30)^(H>>>13|H<<19)^(H>>>22|H<<10))+(H&(N^K)^N&K);A=_;_=b;b=U;U=D;D=K;K=N;N=H;H=w}g[0]=g[0]+H>>>0;g[1]=g[1]+N>>>0;g[2]=g[2]+K>>>0;g[3]=g[3]+D>>>0;g[4]=g[4]+U>>>0;g[5]=g[5]+b>>>0;g[6]=g[6]+_>>>0;g[7]=g[7]+A>>>0;return g}var n,l,F,v,x,E=r.unpackData;l=E("wQWe2DZ81QcwcN0X9w5ZOf/ACzFoWBURZPmPp776T6Q",4,1);F=E("agnmZ7tnroU8bvNypU/1OlEOUn+bBWiMH4PZq1vgzRk",4,1);n=E("QoovmHE3RJG1wPvP6bXbpTlWwltZ8RHxkj+CpKscXtXYB6qYEoNbASQxhb5VDH3Dcr5ddIDesf6b3AanwZvxdOSbacHvvkeGD8GdxiQMocwt6SxvSnSEqlywqdx2+YjamD5RUqgxxm2wAyfIv1l/x8bgC/PVp5FHBspjURQpKWcntwqFLhshOE0sbfxTOA0TZQpzVHZqCruBwskuknIshaK/6KGoGmZLwkuLcMdsUaPRkugZ1pkGJPQONYUQaqBwGaTBFh43bAgnSHdMNLC8tTkcDLNO2KpKW5zKT2gub/N0j4LueKVjb4TIeBSMxwIIkL7/+qRQbOu++aP3xnF48g",4,1);v=E("MC0wDQYJYIZIAWUDBAIEBQAEHA");x=E("MDEwDQYJYIZIAWUDBAIBBQAEIA");return{sha224:function(){return we("SHA-224",v,l,n,64,t,224)},sha256:function(){return we("SHA-256",x,F,n,64,t,256)}}})();if(typeof Q!=="undefined"){Ar.instance224=Ar.instance224||Ar.sha224();Ar.instance256=Ar.instance256||Ar.sha256();Ar.instances={};Ar.getInstance224=function(r){return Ar.instances[r]||(Ar.instances[r]=Ar.sha224())};Ar.getInstance256=function(r){return Ar.instances[r]||(Ar.instances[r]=Ar.sha256())};Ar.deleteInstance=function(r){Ar.instances[r]=null;delete Ar.instances[r]};Ar.hash256=function(r){if(r.operationSubType==="process"){Ar.getInstance256(r.workerid).process(r.buffer);return null}if(r.operationSubType==="finish"){var t=Ar.getInstance256(r.workerid).finish();Ar.deleteInstance(r.workerid);return t}if(r.operationSubType==="abort"){Ar.deleteInstance(r.workerid);return}return Ar.instance256.computeHash(r.buffer)};Ar.hash224=function(r){if(r.operationSubType==="process"){Ar.getInstance224(r.workerid).process(r.buffer);return}if(r.operationSubType==="finish"){var t=Ar.getInstance224(r.workerid).finish()}if(r.operationSubType==="abort"){msrcryptoSha224.deleteInstance(r.workerid);return}return Ar.instance224.computeHash(r.buffer)};Q.register("digest","SHA-224",Ar.hash224);Q.register("digest","SHA-256",Ar.hash256)}Pr["SHA-224"]=Ar.sha224;Pr["SHA-256"]=Ar.sha256;var Rr=(function(){var r=J;function t(y,a,e,h,w){var f=a+h|0;var m=f>>>0>>0;w[0]=y+e+m|0;w[1]=f;return}function n(y,a,e,h,w){var f,m,u=128,p,H,N,K,D,U,b=[],_=[],A=[],W;var s=e[0],C=e[1],M=e[2],O=e[3],Y=e[4],z=e[5],Z=e[6],ir=e[7],yr=e[8],er=e[9],fr=e[10],Wr=e[11],nr=e[12],V=e[13],tr=e[14],wr=e[15];for(f=0;f<32;f++){W=a*u+f*4;w[f]=y.slice(W,W+4);w[f]=w[f][0]<<24|w[f][1]<<16|w[f][2]<<8|w[f][3]}for(f=32;f<160;f+=2){D=w[f-30];U=w[f-29];p=(D>>>1|U<<31)^(D>>>8|U<<24)^D>>>7;H=(U>>>1|D<<31)^(U>>>8|D<<24)^(U>>>7|D<<25);D=w[f-4];U=w[f-3];N=(D>>>19|U<<13)^(U>>>29|D<<3)^D>>>6;K=(U>>>19|D<<13)^(D>>>29|U<<3)^(U>>>6|D<<26);t(N,K,w[f-14],w[f-13],b);t(p,H,b[0],b[1],b);t(w[f-32],w[f-31],b[0],b[1],b);w[f]=b[0];w[f+1]=b[1]}for(m=0;m<160;m+=2){p=(yr>>>14|er<<18)^(yr>>>18|er<<14)^(er>>>9|yr<<23);H=(er>>>14|yr<<18)^(er>>>18|yr<<14)^(yr>>>9|er<<23);N=yr&fr^nr&~yr;K=er&Wr^V&~er;t(tr,wr,p,H,b);t(N,K,h[m],h[m+1],_);t(b[0],b[1],w[m],w[m+1],A);t(_[0],_[1],A[0],A[1],A);t(A[0],A[1],Z,ir,b);Z=b[0];ir=b[1];H=(C>>>28|s<<4)^(s>>>2|C<<30)^(s>>>7|C<<25);p=(s>>>28|C<<4)^(C>>>2|s<<30)^(C>>>7|s<<25);K=C&(O^z)^O&z;N=s&(M^Y)^M&Y;t(A[0],A[1],p,H,b);p=b[0];H=b[1];t(N,K,p,H,b);p=b[0];H=b[1];tr=nr;wr=V;nr=fr;V=Wr;fr=yr;Wr=er;yr=Z;er=ir;Z=Y;ir=z;Y=M;z=O;M=s;O=C;s=p;C=H}t(e[0],e[1],s,C,b);e[0]=b[0];e[1]=b[1];t(e[2],e[3],M,O,b);e[2]=b[0];e[3]=b[1];t(e[4],e[5],Y,z,b);e[4]=b[0];e[5]=b[1];t(e[6],e[7],Z,ir,b);e[6]=b[0];e[7]=b[1];t(e[8],e[9],yr,er,b);e[8]=b[0];e[9]=b[1];t(e[10],e[11],fr,Wr,b);e[10]=b[0];e[11]=b[1];t(e[12],e[13],nr,V,b);e[12]=b[0];e[13]=b[1];t(e[14],e[15],tr,wr,b);e[14]=b[0];e[15]=b[1];return e}var l,F,v,x,E,c,d,g=r.unpackData;l=g("y7udXcEFnthimikqNnzVB5FZAVowcN0XFS/s2PcOWTlnMyZn/8ALMY60SodoWBUR2wwuDWT5j6dHtUgdvvpPpA==",4,1);F=g("agnmZ/O8yQi7Z66FhMqnOzxu83L+lPgrpU/1Ol8dNvFRDlJ/reaC0ZsFaIwrPmwfH4PZq/tBvWtb4M0ZE34heQ",4,1);v=g("QoovmNcoriJxN0SRI+9lzbXA+8/sTTsv6bXbpYGJ27w5VsJb80i1OFnxEfG2BdAZkj+CpK8ZT5urHF7V2m2BGNgHqpijAwJCEoNbAUVwb74kMYW+TuSyjFUMfcPV/7Ticr5ddPJ7iW+A3rH+OxaWsZvcBqclxxI1wZvxdM9pJpTkm2nBnvFK0u++R4Y4TyXjD8GdxouM1bUkDKHMd6ycZS3pLG9ZKwJ1SnSEqm6m5INcsKncvUH71Hb5iNqDEVO1mD5RUu5m36uoMcZtLbQyELADJ8iY+yE/v1l/x77vDuTG4AvzPaiPwtWnkUeTCqclBspjUeADgm8UKSlnCg5ucCe3CoVG0i/8LhshOFwmySZNLG38WsQq7VM4DROdlbPfZQpzVIuvY952agq7PHeyqIHCyS5H7a7mknIshRSCNTuiv+ihTPEDZKgaZku8QjABwkuLcND4l5HHbFGjBlS+MNGS6BnW71IY1pkGJFVlqRD0DjWFV3EgKhBqoHAyu9G4GaTBFrjS0MgeN2wIUUGrUydId0zfjuuZNLC8teGbSKg5HAyzxclaY07YqkrjQYrLW5zKT3dj43NoLm/z1rK4o3SPgu5d77L8eKVjb0MXL2CEyHgUofCrcozHAggaZDnskL7/+iNjHiikUGzr3oK96b75o/eyxnkVxnF48uNyUyvKJz7O6iZhnNGGuMchwMIH6tp91s3g6x71fU9/7m7ReAbwZ6pyF2+6CmN9xaLImKYRP5gEvvkNrhtxCzUTHEcbKNt39SMEfYQyyqt7QMckkzyevgoVyb68Qx1nxJwQDUxMxdS+yz5Ctll/KZz8ZX4qX8tvqzrW+uxsRBmMSkdYFw==",4,1);x=g("MEEwDQYJYIZIAWUDBAICBQAEMA");E=g("MFEwDQYJYIZIAWUDBAIDBQAEQA");c=g("MC0wDQYJYIZIAWUDBAIFBQAEHA");d=g("MDEwDQYJYIZIAWUDBAIGBQAEIA");return{sha384:function(){return we("SHA-384",x,l,v,128,n,384)},sha512:function(){return we("SHA-512",E,F,v,128,n,512)},sha512_224:function(){return we("SHA-512.224",c,F,v,128,n,224)},sha512_256:function(){return we("SHA-512.256",d,F,v,128,n,256)}}})();if(typeof Q!=="undefined"){Rr.instances={};Rr.getInstance384=function(r){return Rr.instances[r]||(Rr.instances[r]=Rr.sha384())};Rr.getInstance512=function(r){return Rr.instances[r]||(Rr.instances[r]=Rr.sha512())};Rr.deleteInstance=function(r){Rr.instances[r]=null;delete Rr.instances[r]};Rr.hash384=function(r){if(r.operationSubType==="process"){Rr.sha384.process(r.buffer);return}if(r.operationSubType==="finish"){return Rr.sha384.finish()}return Rr.sha384().computeHash(r.buffer)};Rr.hash512=function(r){if(r.operationSubType==="process"){Rr.sha512.process(r.buffer);return}if(r.operationSubType==="finish"){return Rr.sha512.finish()}return Rr.sha512().computeHash(r.buffer)};Q.register("digest","SHA-384",Rr.hash384);Q.register("digest","SHA-512",Rr.hash512)}Pr["SHA-384"]=Rr.sha384;Pr["SHA-512"]=Rr.sha512;var Jr=function(r,t){var n={"384":128,"512":128}[t.name.replace(/SHA-/,"")]||64;var l;var F;var v=y();var x;var E;var c;function d(f,m){var u=new Array(f);for(var p=0;pn){return g(t.computeHash(r),n)}return g(r,n)}function a(f){if(!c){c=E.concat(f);t.process(c)}else{t.process(f)}return}function e(){var f=t.finish();var m=x.concat(f);return t.computeHash(m)}function h(){r=null;t=null;v=null}l=new Array(n);F=new Array(n);for(var w=0;w0){l[l.length-1]&=255<6&&O%e===4){U(C)}var Z=N(_(M,O-e),C);A(M,Z,O,0);O+=1}return M};f=W(g);return{encrypt:function(s){var C=s,M;K(C,f,0);for(M=1;M<=w-1;M+=1){U(C);m(C);p(C);K(C,f,4*M*h)}U(C);m(C);K(C,f,4*w*h);return C},decrypt:function(s){var C=s,M;K(C,f,4*w*h);for(M=w-1;M>=1;M-=1){u(C);b(C);K(C,f,4*M*h);H(C)}u(C);b(C);K(C,f,0);return C},clear:function(){},keyLength:a,blockSize:y}}}})();var Te=Te||{};Te.pkcsv7=function(r){function t(l){var F=l.length-1>=0?l.length-1:0;var v=l[F];var x=v.length;var E=x===r;if(E){var c=[];var d;for(d=0;d0;O--){M[O]=(M[O-1]&1)<<7|M[O]>>>1}M[0]=M[0]>>>1;return M}function u(M,O){var Y=Math.floor(O/8);return M[Y]>>7-O%8&1}function p(M){var O=256;for(var Y=1;Y<=4;Y++){O=(O>>>8)+M[M.length-Y];M[M.length-Y]=O&255}return M}function H(M,O){var Y=Math.ceil(O.length/16),z,Z=[];if(a!==M){a=M.slice()}for(var ir=0;ir>>24&255,M>>>16&255,M>>>8&255,M&255]}function K(M){var O=16*Math.ceil(F.length/16)-F.length;return M.concat(t.getVector(O))}function D(){e=0;n=[];y=[];d=t.getVector(16);g=[];a=l=F=null}function U(M,O,Y){F=O||[];v=isNaN(Y)?128:Y;if(v%8!==0){throw J.error("DataError","tagLength must be a multiple of 8")}l=M;if(l.length===12){x=l.concat([0,0,0,1])}else{var z=16*Math.ceil(l.length/16)-l.length;x=h(c,l.concat(t.getVector(z+8)).concat(N(l.length*8)));d=t.getVector(16)}E=p(x.slice());h(c,K(F))}function b(M){e=M.length;var O=H(E,M);h(c,O);var Y=w();var z=H(x,Y).slice(0,v/8);D();return O.slice().concat(z)}function _(M,O){e=M.length;var Y=H(E,M);h(c,M);var z=w();var Z=H(x,z).slice(0,v/8);D();if(t.arraysEqual(Z,O)){return Y}else{return null}}function A(M){n=n.concat(M);var O=n.slice(0,Math.floor(n.length/16)*16);e+=O.length;n=n.slice(O.length);var Y=H(a||E,O);y=y.concat(Y);h(c,Y)}function W(M){n=n.concat(M);var O=n.slice(0,Math.floor((n.length-v/8)/16)*16);e+=O.length;n=n.slice(O.length);var Y=H(a||E,O);y=y.concat(Y);h(c,O)}function s(){var M=H(a,n);y=y.concat(M);e+=n.length;var O=w();var Y=H(x,O).slice(0,v/8);var z=y.slice().concat(Y);D();return z}function C(){var M=Math.floor(v/8);var O=n.slice(-M);n=n.slice(0,n.length-M);var Y=H(a,n);y=y.concat(Y);e+=n.length;var z=w();var Z=H(x,z).slice(0,v/8);var ir=y.slice();D();if(t.arraysEqual(Z,O)){return ir}else{return null}}return{init:U,encrypt:b,decrypt:_,processEncrypt:A,processDecrypt:W,finishEncrypt:s,finishDecrypt:C}};if(typeof Q!=="undefined"){var Yr={};le.encrypt=function(r){var t,n=r.workerid;if(!Yr[n]){Yr[n]=le(de.aes(r.keyData));Yr[n].init(r.algorithm.iv,r.algorithm.additionalData,r.algorithm.tagLength)}if(r.operationSubType==="process"){Yr[n].processEncrypt(r.buffer);return}if(r.operationSubType==="finish"){t=Yr[n].finishEncrypt();Yr[n]=null;return t}t=Yr[n].encrypt(r.buffer);Yr[n]=null;return t};le.decrypt=function(r){var t,n=r.workerid;if(!Yr[n]){Yr[n]=le(de.aes(r.keyData));Yr[n].init(r.algorithm.iv,r.algorithm.additionalData,r.algorithm.tagLength)}if(r.operationSubType==="process"){Yr[n].processDecrypt(r.buffer);return}if(r.operationSubType==="finish"){t=Yr[n].finishDecrypt();Yr[n]=null;if(t===null){throw J.error("OperationError","")}return t}var l=r.algorithm.tagLength?Math.floor(r.algorithm.tagLength/8):16;var F=r.buffer.slice(0,r.buffer.length-l);var v=r.buffer.slice(-l);t=Yr[n].decrypt(F,v);Yr[n]=null;if(t===null){throw J.error("OperationError","")}return t};le.generateKey=function(r){if(r.algorithm.length!==128&&r.algorithm.length!==192&&r.algorithm.length!==256){throw new Error("invalid key length (should be 128, 192, or 256 bits)")}return{type:"keyGeneration",keyData:jr.getBytes(Math.floor(r.algorithm.length/8)),keyHandle:{algorithm:r.algorithm,extractable:r.extractable,usages:r.usages,type:"secret"}}};le.importKey=function(r){var t,n=r.keyData.length*8;if(r.format==="jwk"){t=ne.jwkToKey(r.keyData,r.algorithm,["k"])}else if(r.format==="raw"){if(n!==128&&n!==192&&n!==256){throw new Error("invalid key length (should be 128, 192, or 256 bits)")}t={k:J.toArray(r.keyData)}}else{throw new Error("unsupported import format")}return{type:"keyImport",keyData:t.k,keyHandle:{algorithm:r.algorithm,extractable:r.extractable||t.extractable,usages:r.usages,type:"secret"}}};le.exportKey=function(r){if(r.format==="jwk"){return{type:"keyExport",keyHandle:ne.keyToJwk(r.keyHandle,r.keyData)}}if(r.format==="raw"){return{type:"keyExport",keyHandle:r.keyData}}throw new Error("unsupported export format")};Q.register("importKey","AES-GCM",le.importKey);Q.register("exportKey","AES-GCM",le.exportKey);Q.register("generateKey","AES-GCM",le.generateKey);Q.register("encrypt","AES-GCM",le.encrypt);Q.register("decrypt","AES-GCM",le.decrypt)}var ue=function(r){function t(l){var F=[[0]];for(var v=0;v0;a--,g>>>=8){x[a]^=g&255}}}var e=x;for(var v=1;v<=E;v++){e=e.concat(c[v])}return e}function n(l){var F=[];for(var v=0;v=0;g--){for(var v=x;v>=1;v--){var y=x*g+v;for(var a=7;y>0;a--,y>>>=8){d[a]^=y&255}var e=r.decrypt(d.concat(E[v]));d=e.slice(0,8);E[v]=e.slice(8)}}if(d.join(",")!=="166,166,166,166,166,166,166,166"){throw J.error("OperationError","")}for(var v=1;v<=x;v++){c=c.concat(E[v])}return c}return{encrypt:t,decrypt:n}};if(typeof Q!=="undefined"){var me={};ue.workerEncrypt=function(r){var t,n=r.workerid;if(r.buffer.length%8!==0){throw J.error("DataError","The AES-KW input data length is invalid: not a multiple of 8 bytes")}if(!me[n]){me[n]=ue(de.aes(r.keyData))}t=me[n].encrypt(r.buffer);me[n]=null;return t};ue.workerDecrypt=function(r){var t,n=r.workerid;if(r.buffer.length%8!==0){throw J.error("DataError","The AES-KW input data length is invalid: not a multiple of 8 bytes")}if(!me[n]){me[n]=ue(de.aes(r.keyData))}t=me[n].decrypt(r.buffer);me[n]=null;return t};ue.generateKey=function(r){if(r.algorithm.length!==128&&r.algorithm.length!==192&&r.algorithm.length!==256){throw J.error("OperationError","AES key length must be 128, 192, or 256 bits")}return{type:"keyGeneration",keyData:jr.getBytes(Math.floor(r.algorithm.length/8)),keyHandle:{algorithm:r.algorithm,extractable:r.extractable,usages:r.usages,type:"secret"}}};ue.importKey=function(r){var t;var n=r.keyData.length*8;if(r.format==="jwk"){t=ne.jwkToKey(r.keyData,r.algorithm,["k"])}else if(r.format==="raw"){if(n!==128&&n!==192&&n!==256){throw J.error("OperationError","AES key length must be 128, 192, or 256 bits")}t={k:J.toArray(r.keyData)}}else{throw new TypeError("Invalid keyFormat argument")}r.algorithm.length=t.k.length*8;return{keyData:t.k,keyHandle:{algorithm:r.algorithm,extractable:r.extractable||t.extractable,usages:r.usages,type:"secret"},type:"keyImport"}};ue.exportKey=function(r){if(r.format==="jwk"){return{type:"keyExport",keyHandle:ne.keyToJwk(r.keyHandle,r.keyData)}}if(r.format==="raw"){return{type:"keyExport",keyHandle:r.keyData}}throw new TypeError("Invalid keyFormat argument")};Q.register("importKey","AES-KW",ue.importKey);Q.register("exportKey","AES-KW",ue.exportKey);Q.register("generateKey","AES-KW",ue.generateKey);Q.register("encrypt","AES-KW",ue.workerEncrypt);Q.register("decrypt","AES-KW",ue.workerDecrypt)}function Be(){if(!(this instanceof Be)){throw new Error("create MsrcryptoPrng object with new keyword")}var r=false;var t;var n;var l;var F;var v=1;var x=Math.pow(2,48);c();function E(a){var e;for(e=a.length-1;e>=0;e-=1){a[e]+=1;if(a[e]>=256){a[e]=0}if(a[e]){break}}}function c(){t=J.getVector(32);n=J.getVector(16);l=32;F=48;v=1}function d(a,e){e=e||[0];if(e.length>F){throw new Error("Incorrect entropy or additionalEntropy length")}e=e.concat(J.getVector(F-e.length));a=a.concat(J.getVector((F-a.length%F)%F));for(var h=0;h=65536){throw new Error("too much random requested")}if(v>x){throw new Error("Reseeding is required")}if(e&&e.length>0){while(e.length=l){a.stopCollectors()}}var y=r&&r.addEventListener||typeof document!=="undefined"&&document.attachEvent;var a=(function(){return{startCollectors:function(){if(!this.collectorsRegistered){if(r.addEventListener){r.addEventListener("mousemove",this.MouseEventCallBack,true);r.addEventListener("load",this.LoadTimeCallBack,true)}else if(document.attachEvent){document.attachEvent("onmousemove",this.MouseEventCallBack);document.attachEvent("onload",this.LoadTimeCallBack)}else{throw new Error("Can't attach events for entropy collection")}this.collectorsRegistered=1}},stopCollectors:function(){if(this.collectorsRegistered){if(r.removeEventListener){r.removeEventListener("mousemove",this.MouseEventCallBack,1);r.removeEventListener("load",this.LoadTimeCallBack,1)}else if(r.detachEvent){r.detachEvent("onmousemove",this.MouseEventCallBack);r.detachEvent("onload",this.LoadTimeCallBack)}this.collectorsRegistered=0}},MouseEventCallBack:function(e){var h=new Date().valueOf();var w=e.x||e.clientX||e.offsetX||0;var f=e.y||e.clientY||e.offsetY||0;var m=[h&255,h>>8&255,h>>16&255,h>>24&255,w&255,w>>8&255,f&255,f>>8&255];g(m)},LoadTimeCallBack:function(){var e=new Date().valueOf();var h=[e&255,e>>8&255,e>>16&255,e>>24&255];g(h)}}})();return{init:function(){d();if(!E&&!F&&y){try{a.startCollectors()}catch(e){}}},reseed:function(e){v.reseed(e)},read:function(e){if(!x){throw new Error("Entropy pool is not initialized.")}var h=v.getBytes(e);d();return h}}}var Ne=(function(){var r=[];var t=[];var n=4096*4;function l(y){var a=new Array(y+1),e=[],h,w,f=Math.sqrt(y)|0;for(h=3;h<=f;h+=2){for(w=h*h;w<=y;w+=h*2){a[w]=0}}for(h=3;h<=y;h+=2){if(a[h]!==0){e.push(h)}}return e}function F(y){var a,e=t.length;for(a=0;a=0){w=h*p+y[e--];h=w-(w/f|0)*f}t[a]=h}return}function x(y){var a=0,e=0,h=0,w;if(k.isZero(y)){return 0}for(a=0;y[a]===0;a++){}for(e=0,w=2;y[a]%w===0;w*=2,e++){}return a*k.DIGIT_BITS+e}function E(y){var a=0,e=0,h=0;if(k.isZero(y)){return 0}for(a=y.length-1;y[a]===0;a--){}for(e=k.DIGIT_BITS-1,h=1<0;h=h>>>1,e--){if((y[a]&h)!==0){break}}return a*k.DIGIT_BITS+e}function c(y,a){var e=y;var h=[];k.subtract(e,[1],h);var w=x(h);var f=[];k.shiftRight(h,f,w);var m=E(e);var u;var p=k.MontgomeryMultiplier(e);for(var H=1;H<=a;H++){var N=false;do{u=g(m)}while(k.compareDigits(u,h)>=0);var K=[];p.modExp(u,f,K,true);if(k.compareDigits(K,[1])===0||k.compareDigits(K,h)===0){continue}for(var D=1;D>>24&255,x>>>16&255,x>>>8&255,x&255];v=n.computeHash(r.concat(F));l=l.concat(v)}return l.slice(0,t)},checkMessageVsMaxHash:function(r,t){if(r.length>(t.maxMessageSize||4294967295)){throw new Error("message too long")}return}};var ie=ie||{};ie.oaep=function(r,t){var n=J,l=jr,F=r.n.length;if(t===null){throw new Error("must supply hashFunction")}function v(E,c){var d,g,y,a,e,h;var w,f,m,u;var p;if(E.length>F-2*(t.hashLen/8)-2){throw new Error("Message too long.")}if(c==null){c=[]}d=t.computeHash(c);g=F-E.length-2*d.length-2;y=n.getVector(g);e=d.concat(y,[1],E);h=l.getBytes(d.length);w=Ae.mgf1(h,F-d.length-1,t);f=n.xorVectors(e,w);m=Ae.mgf1(f,d.length,t);u=n.xorVectors(h,m);p=[0].concat(u).concat(f);E=p.slice();return E}function x(E,c){var d,g,y,a;var e,h,w;var f,m=0;var u=E[0]===0;if(!c){c=[]}d=t.computeHash(c);g=E.slice(1,d.length+1);y=E.slice(d.length+1);a=Ae.mgf1(y,d.length,t);e=n.xorVectors(g,a);h=Ae.mgf1(e,F-d.length-1,t);w=n.xorVectors(y,h);f=w.slice(0,d.length);u=u&&n.arraysEqual(d,f);w=w.slice(d.length);while(!w[m++]){}return{valid:u,data:w.slice(m)}}return{pad:function(E,c){return v(E,c)},unpad:function(E,c){return x(E,c)}}};var ie=ie||{};ie.pkcs1Encrypt=function(r){var t=jr,n=r.n.length;function l(x){var E;if(x.length>n-11){throw new Error("message too long")}E=t.getNonZeroBytes(n-x.length-3);return[0,2].concat(E,[0],x)}function F(x){var E=x[0]===0&&x[1]===2;for(var c=2;c<10;c++){E=E&&!!x[c]}return E}function v(x){var E,c=F(x),d=0;for(E=1;E>>8-(8*y-g);for(var u=0;u0){var v=l;l=F;F=v}var x=[];k.multiply(l,F,x);var E=[];k.subtract(l,[1],E);var c=[];k.subtract(F,[1],c);var d=[];k.multiply(E,c,d);var g=[];k.gcd(n,d,g);var y=k.compareDigits(g,k.One)===0}while(!y);var a=[];k.modInv(n,d,a);var e=[];k.reduce(a,E,e);var h=[];k.reduce(a,c,h);var w=[];k.modInv(F,l,w);var f=k.digitsToBytes;return{privateKey:{n:f(x),e:f(n),d:f(a),p:f(l),q:f(F),dp:f(e),dq:f(h),qi:f(w)},publicKey:{n:f(x),e:f(n)}}};mr.generateKeyPair=function(r){if(typeof r.algorithm.modulusLength==="undefined"){throw new Error("missing modulusLength")}var t;var n=k.bytesToDigits;switch(r.algorithm.modulusLength){case 1024:case 2048:case 4096:t=mr.genRsaKeyFromRandom(r.algorithm.modulusLength,r.algorithm.publicExponent);break;default:throw new Error("invalid modulusLength")}var l=t.privateKey;l.ctxp=new k.MontgomeryMultiplier(n(l.p)).ctx;l.ctxq=new k.MontgomeryMultiplier(n(l.q)).ctx;var F=r.algorithm.name;var v=F.slice(F.indexOf("-")+1).toUpperCase();var x,E;if(F==="RSASSA-PKCS1-V1_5"||F==="RSA-PSS"){x=["verify"];E=["sign"]}else{x=["encrypt","wrapKey"];E=["decrypt","unwrapKey"]}if(r.usages){var c=r.usages;var d=[];var g=[];var y;for(y=0;y=0){d.push(x[y])}}for(y=0;y=0){g.push(E[y])}}x=d;E=g}return{type:"keyGeneration",keyPair:{publicKey:{keyData:t.publicKey,keyHandle:{algorithm:r.algorithm,extractable:r.extractable,usages:x,type:"public"}},privateKey:{keyData:t.privateKey,keyHandle:{algorithm:r.algorithm,extractable:r.extractable,usages:E,type:"private"}}}}};Q.register("sign","RSASSA-PKCS1-V1_5",mr.sign);Q.register("sign","RSA-PSS",mr.sign);Q.register("verify","RSASSA-PKCS1-V1_5",mr.verify);Q.register("verify","RSA-PSS",mr.verify);Q.register("encrypt","RSAES-PKCS1-V1_5",mr.workerEncrypt);Q.register("decrypt","RSAES-PKCS1-V1_5",mr.workerDecrypt);Q.register("encrypt","RSA-OAEP",mr.workerEncrypt);Q.register("decrypt","RSA-OAEP",mr.workerDecrypt);Q.register("importKey","RSA-OAEP",mr.importKey);Q.register("importKey","RSAES-PKCS1-V1_5",mr.importKey);Q.register("importKey","RSASSA-PKCS1-V1_5",mr.importKey);Q.register("importKey","RSA-PSS",mr.importKey);Q.register("exportKey","RSA-OAEP",mr.exportKey);Q.register("exportKey","RSAES-PKCS1-V1_5",mr.exportKey);Q.register("exportKey","RSASSA-PKCS1-V1_5",mr.exportKey);Q.register("exportKey","RSA-PSS",mr.exportKey);Q.register("generateKey","RSA-OAEP",mr.generateKeyPair);Q.register("generateKey","RSAES-PKCS1-V1_5",mr.generateKeyPair);Q.register("generateKey","RSASSA-PKCS1-V1_5",mr.generateKeyPair);Q.register("generateKey","RSA-PSS",mr.generateKeyPair)}var Se=(function(){function r(t){var n=t.algorithm.hash.name,l=Pr[n.toUpperCase()](),F=t.algorithm;var v=Er.toArray(F.algorithmId).concat(Er.toArray(F.partyUInfo),Er.toArray(F.partyVInfo),Er.toArray(F.publicInfo)||[],Er.toArray(F.privateInfo)||[]);var x=Math.ceil(t.length/l.hashLen),E=1,c=t.keyData.concat(v),d=[];for(var g=0;g>>24&255,m>>>16&255,m>>>8&255,m&255]);for(var H=0;H255*E){throw new Error("The length provided for HKDF is too large.")}if(v.length===0){v=J.getVector(E)}a={workerid:0,keyHandle:{algorithm:n},keyData:v,buffer:l};a.keyData=Jr.signHmac(a);for(y=0;y255*c){throw new Error("The length provided for HKDF-CTR is too large.")}y={workerid:0,keyHandle:{algorithm:n},keyData:l,buffer:l};var a=v.concat([0],x,Er.int32ToBytes(F));for(g=1;g<=Math.ceil(E/c);g++){y.buffer=Er.int32ToBytes(g).concat(a);d=d.concat(Jr.signHmac(y))}return d.slice(0,E)}return{deriveBits:r}})();if(typeof Q!=="undefined"){Ke.importKey=function(r){var t;if(r.format==="raw"){t=J.toArray(r.keyData)}else{throw new Error("unsupported import format")}if(r.extractable!==false){throw new Error("only extractable=false is supported.")}return{type:"keyImport",keyData:t,keyHandle:{algorithm:{name:"HKDF-CTR"},extractable:false,usages:r.usages,type:"secret"}}};Q.register("deriveBits","HKDF-CTR",Ke.deriveBits);Q.register("importKey","HKDF-CTR",Ke.importKey)}var Fe=function(r){var t=k.bytesToDigits,n=k.digitsToBytes,l=r,F=new Dr.EllipticCurveOperatorFp(r);function v(c){var d=[],g=jr.getBytes(r.order.length*k.DIGIT_NUM_BYTES);k.reduce(k.bytesToDigits(g),l.order,d);var y=l.allocatePointStorage();F.scalarMultiply(d,l.generator,y);return{privateKey:{x:n(y.x),y:n(y.y),d:n(d)},publicKey:{x:n(y.x),y:n(y.y)}}}function x(c,d,g){var y=new Dr.EllipticCurvePointFp(l,false,t(d.x),t(d.y),null,false);var a=l.allocatePointStorage();F.convertToJacobianForm(a);F.convertToMontgomeryForm(a);F.scalarMultiply(t(c.d),y,a);F.convertToAffineForm(a);F.convertToStandardForm(a);var e=k.digitsToBytes(a.x,true,d.x.length);if(g&&e.length*8>>h;e[e.length-1]=e[e.length-1]&w;return e}function E(c){if(!l.generator.isInMontgomeryForm){F.convertToMontgomeryForm(l.generator)}var d=l.allocatePointStorage();F.convertToJacobianForm(d);F.convertToMontgomeryForm(d);F.scalarMultiply(t(c),l.generator,d);return{x:n(d.x),y:n(d.y)}}return{generateKey:v,deriveBits:x,computePublicKey:E}};var be=null;if(typeof Q!=="undefined"){Fe.deriveBits=function(r){var t=Dr.createCurve(r.algorithm.namedCurve.toUpperCase());var n=r.keyData;var l=r.additionalKeyData;be=Fe(t);var F=be.deriveBits(n,l,r.length);return F};Fe.deriveKey=function(r){throw new Error("not supported");return secretBytes};Fe.generateKey=function(r){var t=Dr.createCurve(r.algorithm.namedCurve.toUpperCase());be=Fe(t);var n=be.generateKey();var l={"P-256":32,"P-384":48,"P-521":66,"NUMSP256D1":32,"NUMSP256T1":32,"NUMSP384D1":48,"NUMSP384T1":48,"NUMSP512D1":64,"NUMSP512T1":64}[r.algorithm.namedCurve];var F=J.padFront;n.publicKey.x=F(n.publicKey.x,0,l);n.publicKey.y=F(n.publicKey.y,0,l);n.privateKey.x=F(n.privateKey.x,0,l);n.privateKey.y=F(n.privateKey.y,0,l);n.privateKey.d=F(n.privateKey.d,0,l);return{type:"keyPairGeneration",keyPair:{publicKey:{keyData:n.publicKey,keyHandle:{algorithm:r.algorithm,extractable:r.extractable,usages:[],type:"public"}},privateKey:{keyData:n.privateKey,keyHandle:{algorithm:r.algorithm,extractable:r.extractable,usages:r.usages,type:"private"}}}}};Fe.importKey=function(r){try{if(r.format==="raw"){var t=r.keyData;if(t[0]!==4){throw new Error("DataError")}var n=~~((t.length-1)/2);var l=r.algorithm.namedCurve.toUpperCase();var F=t.slice(1,n+1),v=t.slice(n+1);if(Dr.validatePoint(l,F,v)===false){throw new Error("DataError")}return{type:"keyImport",keyData:{x:F,y:v},keyHandle:{algorithm:r.algorithm,extractable:r.extractable||false,usages:r.usages,type:"public"}}}if(r.format==="jwk"){var x=ne.jwkToKey(r.keyData,r.algorithm,["x","y","d","crv"]);if(x.d&&(!x.x||!x.y)){var E=Dr.createCurve(r.algorithm.namedCurve.toUpperCase());be=Fe(E);var c=be.computePublicKey(x.d);x.x=c.x;x.y=c.y}var d={"P-256":32,"P-384":48,"P-521":66,"NUMSP256D1":32,"NUMSP256T1":32,"NUMSP384D1":48,"NUMSP384T1":48,"NUMSP512D1":64,"NUMSP512T1":64}[r.algorithm.namedCurve];if(x.x){x.x=J.padFront(x.x,0,d)}if(x.y){x.y=J.padFront(x.y,0,d)}if(x.d){x.d=J.padFront(x.d,0,d)}if(Dr.validatePoint(r.algorithm.namedCurve.toUpperCase(),x.x,x.y)===false){throw new Error("DataError")}return{type:"keyImport",keyData:x,keyHandle:{algorithm:r.algorithm,extractable:r.extractable||x.extractable,usages:r.usages,type:x.d?"private":"public"}}}if(r.format==="spki"){var g={"P-256":32,"P-384":48,"P-521":66};var d=g[r.algorithm.namedCurve];var y=Lr.parse(r.keyData);if(y==null){throw new Error("invalid key data.")}var a=y[1];var e=a.data.slice(a.header+1);if(e==null||e.shift()!==4||e.length!==d*2){throw new Error("invalid key data.")}var F=e.slice(0,d),v=e.slice(d);if(!J.isBytes(F)||!J.isBytes(v)){throw new Error("invalid key data.")}var x={x:F,y:v};if(Dr.validatePoint(r.algorithm.namedCurve.toUpperCase(),x.x,x.y)===false){throw new Error("DataError")}return{type:"keyImport",keyData:x,keyHandle:{algorithm:r.algorithm,extractable:r.extractable,usages:r.usages,type:"public"}}}if(r.format==="pkcs8"){var g={"P-256":32,"P-384":48,"P-521":66};var d=g[r.algorithm.namedCurve];var y=Lr.parse(r.keyData);if(y==null){throw new Error("invalid key data.")}var h=y[2];var e=Lr.parse(h.data.slice(h.header));if(e==null){throw new Error("invalid key data.")}var w=e[1].data.slice(e[1].header);var a=Lr.parse(e[2][0].data);var e=a.data.slice(a.header+1);if(e==null||e.shift()!==4||e.length!==d*2){throw new Error("invalid key data.")}var F=e.slice(0,d),v=e.slice(d);if(!J.isBytes(F)||!J.isBytes(v)){throw new Error("invalid key data.")}var x={x:F,y:v,d:w};if(Dr.validatePoint(r.algorithm.namedCurve.toUpperCase(),x.x,x.y)===false){throw new Error("DataError")}return{type:"keyImport",keyData:x,keyHandle:{algorithm:r.algorithm,extractable:r.extractable,usages:r.usages,type:"private"}}}}catch(f){throw J.error("DataError","")}};Fe.exportKey=function(r){var t="1.2.840.10045.2.1";var n={"P-256":"1.2.840.10045.3.1.7 ","P-384":"1.3.132.0.34","P-521":"1.3.132.0.35"};if(r.format==="raw"&&r.keyHandle.type==="public"){var l=[4].concat(r.keyData.x,r.keyData.y);return{type:"keyExport",keyHandle:l}}if(r.format==="jwk"){var F=ne.keyToJwk(r.keyHandle,r.keyData);return{type:"keyExport",keyHandle:F}}if(r.format==="spki"){var v=Lr.encode({SEQUENCE:[{SEQUENCE:[{"OBJECT IDENTIFIER":t},{"OBJECT IDENTIFIER":n[r.algorithm.namedCurve]}]},{"BIT STRING":[4].concat(r.keyData.x,r.keyData.y)}]});return{type:"keyExport",keyHandle:v}}if(r.format==="pkcs8"){var v=Lr.encode({SEQUENCE:[{INTEGER:0},{SEQUENCE:[{"OBJECT IDENTIFIER":t},{"OBJECT IDENTIFIER":n[r.algorithm.namedCurve]}]},{"OCTET STRING":{SEQUENCE:[{INTEGER:1},{"OCTET STRING":r.keyData.d},{APPLICATION:[{"BIT STRING":[4].concat(r.keyData.x,r.keyData.y)}],tag:1}]}}]});return{type:"keyExport",keyHandle:v}}throw new Error("unsupported export format.")};Q.register("importKey","ECDH",Fe.importKey);Q.register("exportKey","ECDH",Fe.exportKey);Q.register("generateKey","ECDH",Fe.generateKey);Q.register("deriveBits","ECDH",Fe.deriveBits);Q.register("deriveKey","ECDH",Fe.deriveKey)}var re=function(r){var t=k.bytesToDigits,n=k.digitsToBytes,l=new Dr.EllipticCurveOperatorFp(r),F=n(r.order).length,v=r.type===1;function x(a){return E(t(a))}function E(a){var e=r.allocatePointStorage();l.scalarMultiply(a,r.generator,e);return{publicKey:e,privateKey:a}}function c(a){var e=[];if(!a){a=jr.getBytes(r.order.length*k.DIGIT_NUM_BYTES)}k.reduce(k.bytesToDigits(a),r.order,e);return E(e)}function d(a){if(a.length>F){a.length=F}var e=t(a);if(v){var h=8-r.rbits%8;k.shiftRight(e,e,h)}k.reduce(e,r.order,e);return e}function g(a,e,h){if(!h){h=c()}var w=h.publicKey.x,f=h.privateKey,m=t(a.d),u=d(e.slice()),p=[],H=[],N=null;k.reduce(w,r.order,w);k.modMul(w,m,r.order,p);k.add(p,u,p);k.reduce(p,r.order,p);k.modInvCT(f,r.order,H);k.modMul(p,H,r.order,p);var K=J.padFront(n(w,true,F),0,F);var D=J.padFront(n(p,true,F),0,F);N=K.concat(D);return N}function y(a,e,h){var w=Math.floor(e.length/2),f=t(e.slice(0,w)),m=t(e.slice(w)),u=d(h.slice()),p=[],H=[];var N=new Dr.EllipticCurvePointFp(r,false,t(a.x),t(a.y),null,false);k.modInv(m,r.order,m);k.modMul(u,m,r.order,p);k.modMul(f,m,r.order,H);var K=r.allocatePointStorage();var D=r.allocatePointStorage();if(v){k.add(p,p,p);k.add(p,p,p);k.reduce(p,r.order,p);l.scalarMultiply(p,r.generator,K,false);l.scalarMultiply(H,N,D,false);l.convertToExtendedProjective(K);l.convertToExtendedProjective(D);l.add(D,K,K);l.normalize(K)}else{l.scalarMultiply(p,r.generator,K);l.scalarMultiply(H,N,D);l.convertToJacobianForm(K);l.convertToMontgomeryForm(K);l.convertToMontgomeryForm(D);l.mixedAdd(K,D,K);l.convertToAffineForm(K);l.convertToStandardForm(K)}if(K.isInfinity){return false}k.reduce(K.x,r.order,K.x);return k.compareDigits(K.x,f)===0}return{createKey:x,generateKey:c,sign:g,verify:y}};if(typeof Q!=="undefined"){re.sign=function(r){J.checkParam(r.algorithm.hash,"Object","algorithm.hash");J.checkParam(r.algorithm.hash.name,"String","algorithm.hash.name");J.checkParam(r.keyHandle.algorithm.namedCurve,"String","p.keyHandle.algorithm.namedCurve");var t=r.algorithm.hash.name,n=Dr.createCurve(r.keyHandle.algorithm.namedCurve.toUpperCase()),l=Pr[t.toUpperCase()](),F=l.computeHash(r.buffer);var v=re(n);return v.sign(r.keyData,F)};re.verify=function(r){var t=r.algorithm.hash.name,n=Dr.createCurve(r.keyHandle.algorithm.namedCurve.toUpperCase()),l=Pr[t.toUpperCase()](),F=l.computeHash(r.buffer);var v=re(n);return v.verify(r.keyData,r.signature,F)};re.generateKey=function(r){var t=Dr.createCurve(r.algorithm.namedCurve.toUpperCase());var n=re(t);var l=n.generateKey();var F=k.digitsToBytes;var v={"P-256":32,"P-384":48,"P-521":66,"NUMSP256D1":32,"NUMSP256T1":32,"NUMSP384D1":48,"NUMSP384T1":48,"NUMSP512D1":64,"NUMSP512T1":64}[r.algorithm.namedCurve];function x(g){return J.padFront(g,0,v)}var E=x(F(l.publicKey.x));var c=x(F(l.publicKey.y));var d=x(F(l.privateKey));return{type:"keyPairGeneration",keyPair:{publicKey:{keyData:{x:E,y:c},keyHandle:{algorithm:r.algorithm,extractable:r.extractable,usages:["verify"],type:"public"}},privateKey:{keyData:{x:E,y:c,d:d},keyHandle:{algorithm:r.algorithm,extractable:r.extractable,usages:["sign"],type:"private"}}}}};re.importKey=function(r){if(r.format==="raw"){var t=r.keyData;if(t[0]!==4){throw J.error("DataError","invalid point encoding")}var n=~~((t.length-1)/2);var l=r.algorithm.namedCurve.toUpperCase();var F=t.slice(1,n+1),v=t.slice(n+1);if(Dr.validatePoint(l,F,v)===false){throw J.error("DataError","the imported point is not on the curve")}return{type:"keyImport",keyData:{x:F,y:v},keyHandle:{algorithm:r.algorithm,extractable:r.extractable,usages:r.usages,type:"public"}}}if(r.format==="jwk"){var x=ne.jwkToKey(r.keyData,r.algorithm,["x","y","d","crv"]);if(x.d&&(!x.x||!x.y)){var E=re.curves[r.algorithm.namedCurve]();var c=re(E);var d=c.computePublicKey(x.d);x.x=d.x;x.y=d.y}var g={"P-256":32,"P-384":48,"P-521":66,"NUMSP256D1":32,"NUMSP256T1":32,"NUMSP384D1":48,"NUMSP384T1":48,"NUMSP512D1":64,"NUMSP512T1":64}[r.algorithm.namedCurve];if(x.x){x.x=J.padFront(x.x,0,g)}if(x.y){x.y=J.padFront(x.y,0,g)}if(x.d){x.d=J.padFront(x.d,0,g)}if(Dr.validatePoint(r.algorithm.namedCurve.toUpperCase(),x.x,x.y)===false){throw J.error("DataError","the imported point is not on the curve")}return{type:"keyImport",keyData:x,keyHandle:{algorithm:r.algorithm,extractable:r.extractable||x.extractable,usages:r.usages,type:x.d?"private":"public"}}}if(r.format==="spki"){var y={"P-256":32,"P-384":48,"P-521":66};var g=y[r.algorithm.namedCurve];var a=Lr.parse(r.keyData);if(a==null){throw new Error("invalid key data.")}var e=a[1];var h=e.data.slice(e.header+1);if(h==null||h.shift()!==4||h.length!==g*2){throw new Error("invalid key data.")}var F=h.slice(0,g),v=h.slice(g);if(!J.isBytes(F)||!J.isBytes(v)){throw new Error("invalid key data.")}var x={x:F,y:v};if(Dr.validatePoint(r.algorithm.namedCurve.toUpperCase(),x.x,x.y)===false){throw new Error("DataError")}return{type:"keyImport",keyData:x,keyHandle:{algorithm:r.algorithm,extractable:r.extractable,usages:r.usages,type:"public"}}}if(r.format==="pkcs8"){var y={"P-256":32,"P-384":48,"P-521":66};var g=y[r.algorithm.namedCurve];var a=Lr.parse(r.keyData);if(a==null){throw new Error("invalid key data.")}var w=a[2];var h=Lr.parse(w.data.slice(w.header));if(h==null){throw new Error("invalid key data.")}var f=h[1].data.slice(h[1].header);var e=Lr.parse(h[2][0].data);var h=e.data.slice(e.header+1);if(h==null||h.shift()!==4||h.length!==g*2){throw new Error("invalid key data.")}var F=h.slice(0,g),v=h.slice(g);if(!J.isBytes(F)||!J.isBytes(v)){throw new Error("invalid key data.")}var x={x:F,y:v,d:f};if(Dr.validatePoint(r.algorithm.namedCurve.toUpperCase(),x.x,x.y)===false){throw new Error("DataError")}return{type:"keyImport",keyData:x,keyHandle:{algorithm:r.algorithm,extractable:r.extractable,usages:r.usages,type:"private"}}}};re.exportKey=function(r){var t="1.2.840.10045.2.1";var n={"P-256":"1.2.840.10045.3.1.7 ","P-384":"1.3.132.0.34","P-521":"1.3.132.0.35"};if(r.format==="raw"&&r.keyHandle.type==="public"){var l=[4].concat(r.keyData.x,r.keyData.y);return{type:"keyExport",keyHandle:l}}if(r.format==="jwk"){var F=ne.keyToJwk(r.keyHandle,r.keyData);return{type:"keyExport",keyHandle:F}}if(r.format==="spki"){var v=Lr.encode({SEQUENCE:[{SEQUENCE:[{"OBJECT IDENTIFIER":t},{"OBJECT IDENTIFIER":n[r.algorithm.namedCurve]}]},{"BIT STRING":[4].concat(r.keyData.x,r.keyData.y)}]});return{type:"keyExport",keyHandle:v}}if(r.format==="pkcs8"){var v=Lr.encode({SEQUENCE:[{INTEGER:0},{SEQUENCE:[{"OBJECT IDENTIFIER":t},{"OBJECT IDENTIFIER":n[r.algorithm.namedCurve]}]},{"OCTET STRING":{SEQUENCE:[{INTEGER:1},{"OCTET STRING":r.keyData.d},{APPLICATION:[{"BIT STRING":[4].concat(r.keyData.x,r.keyData.y)}],tag:1}]}}]});return{type:"keyExport",keyHandle:v}}throw new Error("unsupported export format.")};Q.register("sign","ECDSA",re.sign);Q.register("verify","ECDSA",re.verify);Q.register("generateKey","ECDSA",re.generateKey);Q.register("importKey","ECDSA",re.importKey);Q.register("exportKey","ECDSA",re.exportKey)}var Ce;var Er=J;Ce=(function(){function r(){var f;function m(u){try{u.workerid=this.id;f=De.jsCryptoRunner({data:u})}catch(p){this.onerror({data:p,type:"error"});return}this.onmessage({data:f})}return{postMessage:m,onmessage:null,onerror:null,terminate:function(){}}}var t=function(f){return{process:function(m){return f.process(m)},finish:function(){return f.finish()},abort:function(){return f.abort()}}};function n(f){var m=null,u=null,p=null,H,N,K,D;N=new Promise(function(b,_){K=b;D=_});function U(b){if(b.type==="error"){if(D){if(b.data){try{if(!b.data.stack){b.data.stack="Error"}}catch(_){}try{if(b.data.code==null){b.data.code=0}}catch(_){}}D.apply(N,[b.data||b])}return}if(b.data.type==="process"){f(b.data.result,true);return}if(b.data.type==="finish"){f(b.data.result,true);return}this.result=f(b.data);K.apply(N,[this.result]);return}H={dispatchEvent:U,promise:N,result:null};return H}function l(){function f(u){return new ge(te,u)}function m(u){var p,H,N;switch(u.type){case"keyGeneration":case"keyImport":case"keyDerive":if(u.keyPair){p=f(u.keyPair.publicKey.keyHandle);H=f(u.keyPair.privateKey.keyHandle);x.add(p,u.keyPair.publicKey.keyData);x.add(H,u.keyPair.privateKey.keyData);return{publicKey:p,privateKey:H}}else{N=f(u.keyHandle);x.add(N,u.keyData);return N}case"keyExport":return u.keyHandle;case"keyPairGeneration":p=f(u.keyPair.publicKey.keyHandle);H=f(u.keyPair.privateKey.keyHandle);x.add(p,u.keyPair.publicKey.keyData);x.add(H,u.keyPair.privateKey.keyData);return{publicKey:p,privateKey:H};default:throw new Error("Unknown key operation")}}return n(m)}function F(f){if($r&&f.pop){return new Uint8Array(f).buffer}return f}function v(f){function m(H,N){H=H&&F(H);if(N){u.resolve(H);return}return H}var u=[],p=n(m);p.stream=f.algorithm.stream;u.add=function(H){var N,K,D=new Promise(function(U,b){N=U;K=b});D.label=H;u.push({resolve:N,reject:K,promise:D});return D};u.resolve=function(H){var N=u.shift();N.resolve.apply(N.promise,[H])};p.process=function(H){f.operationSubType="process";f.buffer=Er.toArray(H);E.continueJob(this,Er.clone(f));return u.add("process")};p.finish=function(){f.operationSubType="finish";f.buffer=[];E.continueJob(this,Er.clone(f));return u.add("finish")};p.abort=function(){E.abortJob(this)};p.algorithm=f.algorithm||null;p.key=f.keyHandle||null;return p}var x=[];x.add=function(f,m){x.push({cryptoKey:f,keyData:m})};x.remove=function(f){for(var m=0;m=0;V-=1){if(u[V].isWebWorker===nr){u[V].terminate();u.splice(V,1)}}}function s(){var nr=0;for(var V=0;V0){var V=p.shift(),tr;fr(V.operation,V.data);if(V.data.operationSubType==="process"){for(tr=0;tr=0;tr--){if(V.operation===p[tr].operation){p.splice(tr,1)}}}}else if(s()>m){M(nr)}}}function Z(nr){var V;if(_==="pending"){throw new Error("Creating new worker while workerstatus=pending")}if(_==="ready"){try{V=new Worker(Vr);V.postMessage({prngSeed:jr.getBytes(48)});V.isWebWorker=true}catch(tr){Tr=false;_="failed";V.terminate();V=r();V.isWebWorker=false}}else{V=r();V.isWebWorker=false}V.operation=nr;V.id=N++;V.busy=false;V.onmessage=function(tr){if(tr.data==null){return}if(tr.data.initialized===true){return}var wr=V.operation;tr.target||(tr.target={data:V.data});if(tr.data.error){z(V);wr.dispatchEvent({type:"error",data:Er.error(tr.data.error.name,tr.data.error.message)});return}for(var Ur=0;Ur0){var I=p.shift();er(I.operation,I.data)}return}V.addEventListener("message",tr,false);V.addEventListener("error",tr,false);V.postMessage({prngSeed:jr.getBytes(48)});return}function yr(nr){var V=O(nr);if(V){M(V)}}function er(nr,V){var tr=null;if(_==="pending"){Y(nr,V);return}tr=A();if(Tr&&tr===null&&u.length>=f){Y(nr,V);return}if(tr===null){tr=Z(nr)}if(tr===null){Y(nr,V);throw new Error("could not create new worker")}tr.operation=nr;tr.busy=true;V.workerid=tr.id;Wr(tr,V)}function fr(nr,V){var tr=O(nr);if(tr){Wr(tr,V);return}er(nr,V)}function Wr(nr,V){V.workerid=nr.id;if(Tr){nr.postMessage(V)}else{var tr=(function(wr){return function(){return nr.postMessage(wr)}})(V);b(tr)}return}return{runJob:er,continueJob:fr,abortJob:yr,useWebWorkers:ir}})();function c(f,m){if(!Q.exists(f,m)){throw Er.error("NotSupportedError","Unrecognized or unsupported algorithm.")}}var d=[{name:"algorithm",type:"Object",required:true},{name:"keyHandle",type:"Object",required:true},{name:"buffer",type:"Array",required:false},{name:"signature",type:"Array",required:true},{name:"format",type:"String",required:true},{name:"keyData",type:"Object",required:true},{name:"extractable",type:"Boolean",required:false},{name:"usages",type:"Array",required:false},{name:"derivedKeyType",type:"Object",required:true},{name:"length",type:"Number",required:false},{name:"extractable",type:"Boolean",required:true},{name:"usages",type:"Array",required:true},{name:"keyData",type:"Array",required:true}];var g={encrypt:[0,1,2],decrypt:[0,1,2],sign:[0,1,2],verify:[0,1,3,2],digest:[0,2],generateKey:[0,6,7],importKeyRaw:[4,12,0,10,11],importKeyJwk:[4,5,0,10,11],exportKey:[0,4,1,6,7],deriveKey:[0,1,8,6,7],deriveBits:[0,1,9]};function y(f){var m=x.lookup(f);if(!m){throw Er.error("InvalidAccessError","key not found")}return m}function a(f,m){var u={operationType:f},p,H,N,K;if(f==="importKey"&&(m[0]==="raw"||m[0]==="spki"||m[0]==="pkcs8")){f="importKeyRaw"}if(f==="importKey"&&m[0]==="jwk"){f="importKeyJwk"}p=g[f];for(K=0;K65536){throw J.error("QuotaExceededError","The ArrayBufferView's byte length ("+l+") exceeds the number of bytes of entropy available via this API (65536).")}var F=jr.getBytes(r.length);for(t=0;t.\node_modules\.bin\gulp diff --git a/lib/msrcrypto.js b/lib/msrcrypto.js deleted file mode 100644 index e80860d..0000000 --- a/lib/msrcrypto.js +++ /dev/null @@ -1,10427 +0,0 @@ -//******************************************************************************* -// -// Copyright 2020 Microsoft -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -//******************************************************************************* -"use strict"; - -var msrCryptoVersion = "1.6.6"; - -(function(root, factory) { - - if (typeof define === "function" && define.amd) { - define([], function() { - return (root.msrCrypto = factory(root)); - }); - } else if (typeof exports === "object") { - module.exports = factory(root); - } else { - root.msrCrypto = factory(root); - } - -}(this, function(global) { - - global = global || {}; - - var msrCrypto = function() { - - var operations = {}; - - operations.register = function(operationType, algorithmName, functionToCall) { - - if (!operations[operationType]) { - operations[operationType] = {}; - } - - var op = operations[operationType]; - - if (!op[algorithmName]) { - op[algorithmName] = functionToCall; - } - - }; - - operations.exists = function(operationType, algorithmName) { - if (!operations[operationType]) { - return false; - } - - return operations[operationType][algorithmName] ? true : false; - }; - - var scriptUrl = (function() { - - if (typeof document !== "undefined") { - try { - throw new Error(); - } catch (e) { - if (e.stack) { - var match = /\w+:\/\/(.+?\/)*.+\.js/.exec(e.stack); - return (match && match.length > 0) ? match[0] : null; - } - } - } else if (typeof self !== "undefined" && typeof self.location !== "undefined") { - return self.location.href; - } - - return null; - - })(); - - var fprngEntropyProvided = false; - - var webWorkerSupport = (typeof Worker !== "undefined"); - - var runningInWorkerInstance = typeof importScripts === "function" && self instanceof WorkerGlobalScope; - - var workerInitialized = false; - - var typedArraySupport = (typeof ArrayBuffer !== "undefined"); - - var setterSupport = (function() { - try { - Object.defineProperty({}, "oncomplete", {}); - return true; - } catch (ex) { - return false; - } - }()); - - var asyncMode = false; - - var createProperty = function(parentObject, propertyName, initialValue, getterFunction, setterFunction) { - if (!setterSupport) { - parentObject[propertyName] = initialValue; - return; - } - - var setGet = {}; - - getterFunction && (setGet.get = getterFunction); - setterFunction && (setGet.set = setterFunction); - - Object.defineProperty( - parentObject, - propertyName, setGet); - }; - - var msrcryptoHashFunctions = {}; - - var msrcryptoUtilities = (function() { - - var encodingChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; - - function consoleLog(text) { - if ("console" in self && "log" in console) { - console.log(text); - } - } - - function toBase64(data, base64Url) { - var dataType = getObjectType(data); - - if (dataType !== "Array" && dataType !== "Uint8Array" && dataType !== "ArrayBuffer") { - throw new Error("invalid input"); - } - - var output = ""; - var input = toArray(data); - - if (!base64Url) { - base64Url = false; - } - - var char1, char2, char3, enc1, enc2, enc3, enc4; - var i; - - for (i = 0; i < input.length; i += 3) { - - char1 = input[i]; - char2 = input[i + 1]; - char3 = input[i + 2]; - - enc1 = char1 >> 2; - enc2 = ((char1 & 0x3) << 4) | (char2 >> 4); - enc3 = ((char2 & 0xF) << 2) | (char3 >> 6); - enc4 = char3 & 0x3F; - - if (isNaN(char2)) { - enc3 = enc4 = 64; - - } else if (isNaN(char3)) { - enc4 = 64; - } - - output = output + - encodingChars.charAt(enc1) + - encodingChars.charAt(enc2) + - encodingChars.charAt(enc3) + - encodingChars.charAt(enc4); - - } - - if (base64Url) { - return output.replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, ""); - } - - return output; - } - - function base64ToBytes(encodedString) { - encodedString = encodedString.replace(/-/g, "+").replace(/_/g, "/"); - - while (encodedString.length % 4 !== 0) { - encodedString += "="; - } - - var output = []; - var char1, char2, char3; - var enc1, enc2, enc3, enc4; - var i; - - encodedString = encodedString.replace(/[^A-Za-z0-9\+\/\=]/g, ""); - - for (i = 0; i < encodedString.length; i += 4) { - - enc1 = encodingChars.indexOf(encodedString.charAt(i)); - enc2 = encodingChars.indexOf(encodedString.charAt(i + 1)); - enc3 = encodingChars.indexOf(encodedString.charAt(i + 2)); - enc4 = encodingChars.indexOf(encodedString.charAt(i + 3)); - - char1 = (enc1 << 2) | (enc2 >> 4); - char2 = ((enc2 & 15) << 4) | (enc3 >> 2); - char3 = ((enc3 & 3) << 6) | enc4; - - output.push(char1); - - if (enc3 !== 64) { - output.push(char2); - } - - if (enc4 !== 64) { - output.push(char3); - } - - } - - return output; - - } - - function getObjectType(object) { - return Object.prototype.toString.call(object).slice(8, -1); - } - - function bytesToHexString(bytes, separate) { - var result = ""; - if (typeof separate === "undefined") { - separate = false; - } - - for (var i = 0; i < bytes.length; i++) { - - if (separate && (i % 4 === 0) && i !== 0) { - result += "-"; - } - - var hexval = bytes[i].toString(16).toUpperCase(); - if (hexval.length === 1) { - result += "0"; - } - - result += hexval; - } - - return result; - } - - function bytesToInt32(bytes, index) { - index = (index || 0); - - return (bytes[index] << 24) | - (bytes[index + 1] << 16) | - (bytes[index + 2] << 8) | - bytes[index + 3]; - } - - function hexToBytesArray(hexString) { - hexString = hexString.replace(/\-/g, ""); - - var result = []; - while (hexString.length >= 2) { - result.push(parseInt(hexString.substring(0, 2), 16)); - hexString = hexString.substring(2, hexString.length); - } - - return result; - } - - function clone(object) { - var newObject = {}; - for (var propertyName in object) { - if (object.hasOwnProperty(propertyName)) { - newObject[propertyName] = object[propertyName]; - } - } - return newObject; - } - - function unpackData(base64String, arraySize, toUint32s) { - var bytes = base64ToBytes(base64String), - data = [], - i; - - if (isNaN(arraySize)) { - return bytes; - } else { - for (i = 0; i < bytes.length; i += arraySize) { - data.push(bytes.slice(i, i + arraySize)); - } - } - - if (toUint32s) { - for (i = 0; i < data.length; i++) { - data[i] = (data[i][0] << 24) + (data[i][1] << 16) + (data[i][2] << 8) + data[i][3]; - } - } - - return data; - } - - function int32ToBytes(int32) { - return [(int32 >>> 24) & 255, (int32 >>> 16) & 255, (int32 >>> 8) & 255, int32 & 255]; - } - - function int32ArrayToBytes(int32Array) { - var result = []; - for (var i = 0; i < int32Array.length; i++) { - result = result.concat(int32ToBytes(int32Array[i])); - } - return result; - } - - function xorVectors(a, b, res) { - var length = Math.min(a.length, b.length), - res = res || new Array(length); - for (var i = 0; i < length; i += 1) { - res[i] = a[i] ^ b[i]; - } - return res; - } - - function getVector(length, fillValue) { - if (isNaN(fillValue)) { - fillValue = 0; - } - - var res = new Array(length); - for (var i = 0; i < length; i += 1) { - res[i] = fillValue; - } - return res; - } - - function toArray(typedArray) { - if (!typedArray) { - return []; - } - - if (typedArray.pop) { - return typedArray; - } - - if (getObjectType(typedArray) === "ArrayBuffer") { - typedArray = new Uint8Array(typedArray); - } else if (typedArray.BYTES_PER_ELEMENT > 1) { - typedArray = new Uint8Array(typedArray.buffer); - } - - if (typedArray.length === 1) { - return [typedArray[0]]; - } - - if (typedArray.length < 65536) { - return Array.apply(null, typedArray); - } - - var returnArray = new Array(typedArray.length); - for (var i = 0; i < typedArray.length; i++) { - returnArray[i] = typedArray[i]; - } - - return returnArray; - - } - - function padEnd(array, value, finalLength) { - while (array.length < finalLength) { - array.push(value); - } - - return array; - } - - function padFront(array, value, finalLength) { - while (array.length < finalLength) { - array.unshift(value); - } - - return array; - } - - function arraysEqual(array1, array2) { - var result = true; - - if (array1.length !== array2.length) { - result = false; - } - - for (var i = 0; i < array1.length; i++) { - if (array1[i] !== array2[i]) { - result = false; - } - } - - return result; - } - - function verifyByteArray(array) { - if (getObjectType(array) !== "Array") { - return false; - } - - var element; - - for (var i = 0; i < array.length; i++) { - - element = array[i]; - - if (isNaN(element) || element < 0 || element > 255) { - return false; - } - } - - return true; - } - - function checkParam(param, type, errorMessage) { - - if (!param) { - throw new Error(errorMessage); - } - - if (type && (getObjectType(param) !== type)) { - throw new Error(errorMessage); - } - - return true; - } - - function stringToBytes(text) { - var encodedBytes = []; - - for (var i = 0, j = 0; i < text.length; i++) { - - var charCode = text.charCodeAt(i); - - if (charCode < 128) { - encodedBytes[j++] = charCode; - - } else if (charCode < 2048) { - encodedBytes[j++] = (charCode >>> 6) | 192; - encodedBytes[j++] = (charCode & 63) | 128; - - } else if (charCode < 0xD800 || charCode > 0xDFFF) { - encodedBytes[j++] = (charCode >>> 12) | 224; - encodedBytes[j++] = ((charCode >>> 6) & 63) | 128; - encodedBytes[j++] = (charCode & 63) | 128; - - } else { - charCode = ((charCode - 0xD800) * 0x400) + (text.charCodeAt(++i) - 0xDC00) + 0x10000; - encodedBytes[j++] = (charCode >>> 18) | 240; - encodedBytes[j++] = ((charCode >>> 12) & 63) | 128; - encodedBytes[j++] = (charCode >>> 6) & 63 | 128; - encodedBytes[j++] = (charCode & 63) | 128; - } - } - - return encodedBytes; - } - - function bytesToString(textBytes) { - var result = "", - charCode; - - textBytes = toArray(textBytes); - - for (var i = 0; i < textBytes.length;) { - - var encodedChar = textBytes[i++]; - - if (encodedChar < 128) { - charCode = encodedChar; - - } else if (encodedChar < 224) { - charCode = (encodedChar << 6) + textBytes[i++] - 0x3080; - - } else if (encodedChar < 240) { - charCode = - (encodedChar << 12) + (textBytes[i++] << 6) + textBytes[i++] - 0xE2080; - - } else { - charCode = - (encodedChar << 18) + (textBytes[i++] << 12) + (textBytes[i++] << 6) + textBytes[i++] - 0x3C82080; - } - - if (charCode > 0xFFFF) { - var surrogateHigh = Math.floor((charCode - 0x10000) / 0x400) + 0xD800; - var surrogateLow = ((charCode - 0x10000) % 0x400) + 0xDC00; - result += String.fromCharCode(surrogateHigh, surrogateLow); - continue; - } - - result += String.fromCharCode(charCode); - } - - return result; - } - - function error(name, message) { - var err = Error(message); - err.name = name; - throw err; - } - - function isBytes(array) { - if (!(array instanceof Array)) return false; - for (var i = 0; i < array.length; i++) { - var d = array[i]; - if (!isInteger(d) || d > 255 || d < 0) return false; - } - return true; - } - - function isInteger(value) { - return typeof value === "number" && isFinite(value) && Math.floor(value) === value; - }; - - return { - consoleLog: consoleLog, - toBase64: toBase64, - fromBase64: base64ToBytes, - checkParam: checkParam, - getObjectType: getObjectType, - bytesToHexString: bytesToHexString, - bytesToInt32: bytesToInt32, - stringToBytes: stringToBytes, - bytesToString: bytesToString, - unpackData: unpackData, - hexToBytesArray: hexToBytesArray, - int32ToBytes: int32ToBytes, - int32ArrayToBytes: int32ArrayToBytes, - toArray: toArray, - arraysEqual: arraysEqual, - clone: clone, - xorVectors: xorVectors, - padEnd: padEnd, - padFront: padFront, - getVector: getVector, - verifyByteArray: verifyByteArray, - error: error, - isBytes: isBytes, - isInteger: isInteger - }; - - })(); - - var asn1 = (function() { - var asn1Types = { - 0x00: "CUSTOM", - 0x01: "BOOLEAN", - 0x02: "INTEGER", - 0x03: "BIT STRING", - 0x04: "OCTET STRING", - 0x05: "NULL", - 0x06: "OBJECT IDENTIFIER", - 0x10: "SEQUENCE", - 0x11: "SET", - 0x13: "PRINTABLE STRING", - 0x17: "UTCTime" - }; - - var asn1Classes = { - 0x00: "UNIVERSAL", - 0x01: "APPLICATION", - 0x02: "Context-Defined", - 0x03: "PRIVATE" - }; - - function parse(bytes, force) { - force = !!force; - - var type = asn1Types[bytes[0] & 0x1f], - dataLen = bytes[1], - i = 0, - constructed = !!(bytes[0] & 0x20), - remainder, - child, - header; - - if (dataLen & 0x80) { - for (i = 0, dataLen = 0; i < (bytes[1] & 127); i++) { - dataLen = (dataLen << 8) + bytes[2 + i]; - } - } - - header = 2 + i; - - if (type === undefined || dataLen > bytes.length) { - return null; - } - - var obj = constructed ? [] : {}; - - obj.type = type; - obj.header = header; - obj.data = bytes.slice(0, dataLen + header); - if (constructed || force) { - if (obj.type === "BIT STRING" && bytes[header] === 0) { - i++; - } - remainder = bytes.slice(header, obj.data.length); - while (remainder.length > 0) { - child = parse(remainder); - if (child === null) { - break; - } - obj.push(child); - remainder = remainder.slice(child.data.length); - } - } - return obj; - } - - function encode(node) { - var INTEGER = 0x02, - BIT_STRING = 0x03, - OCTET_STRING = 0x04, - NULL = 0x05, - OBJECT_IDENTIFIER = 0x06, - SEQUENCE = 0x10, - - APPLICATION = 0xA0, - CONSTRUCTED = 0x20; - - if (node.hasOwnProperty("INTEGER")) { - var val = node.INTEGER; - if (msrcryptoUtilities.isInteger(val)) val = intToBytes(val); - if (val[0] & 128) val.unshift(0); - var result = [INTEGER].concat(encodeLength(val), val); - return result; - } - - if (node.hasOwnProperty("OCTET STRING")) { - var val = node["OCTET STRING"]; - if (!(val instanceof Array)) val = encode(val); - var result = [OCTET_STRING].concat(encodeLength(val), val); - return result; - } - - if (node.hasOwnProperty("BIT STRING")) { - var val = node["BIT STRING"]; - if (!(val instanceof Array)) val = encode(val); - val.unshift(0); - var result = [BIT_STRING].concat(encodeLength(val), val); - return result; - } - - if (node.hasOwnProperty("NULL")) { - return [NULL, 0]; - } - - if (node.hasOwnProperty("OBJECT IDENTIFIER")) { - var val = encodeOid(node["OBJECT IDENTIFIER"]); - var result = [OBJECT_IDENTIFIER].concat(encodeLength(val), val); - return result; - } - - if (node.hasOwnProperty("SEQUENCE")) { - var nodes = node.SEQUENCE; - var val = []; - for (var i = 0; i < nodes.length; i++) { - val = val.concat(encode(nodes[i])); - } - var result = [SEQUENCE | CONSTRUCTED].concat(encodeLength(val), val); - return result; - } - - if (node.hasOwnProperty("APPLICATION")) { - var nodes = node.APPLICATION; - var structured = isNaN(parseInt(nodes[0])) ? CONSTRUCTED : 0; - var tag = node.tag; - var val = structured ? [] : node.APPLICATION; - - if (structured) { - for (var i = 0; i < nodes.length; i++) { - val = val.concat(encode(nodes[i])); - } - } - - var result = [APPLICATION | structured | tag].concat(encodeLength(val), val); - - return result; - } - - throw new Error("unsupported asn.1 type"); - } - - function encodeLength(bytes) { - var len = bytes.length; - if (len <= 127) return [len]; - var result = intToBytes(len); - result.unshift(result.length | 128); - return result; - } - - function intToBytes(int) { - var result = []; - if (int === 0) return [0]; - while (int > 0) { - result.unshift(int & 255); - int >>>= 8; - } - return result; - } - - function encodeOid(text) { - var parts = text.split("."); - var result = [parseInt(parts[0] * 40 + parseInt(parts[1]))]; - - for (var i = 2; i < parts.length; i++) { - var val = parseInt(parts[i]); - - var bytes = []; - while (val > 0) { - bytes.push((val & 127) | 128); - val = val >>> 7; - } - bytes[0] = bytes[0] & 127; - - result = result.concat(bytes.reverse()); - } - return result; - } - - - function toString(objTree, indent) { - var output = - new Array(indent + 1).join(" ") + - objTree.type + - " (" + - objTree.length + - ") " + - bytesToHexString(objTree.data).substring(0, 16) + - "\n"; - - if (!objTree.children) { - return output; - } - - for (var i = 0; i < objTree.children.length; i++) { - output += toString(objTree.children[i], indent + 4) + ""; - } - - return output; - } - - - return { - parse: parse, - encode: encode, - toString: function(objTree) { - return toString(objTree, 0); - } - }; - })(); - - var msrcryptoWorker = (function() { - - function returnResult(result) { - - if (workerInitialized && runningInWorkerInstance) { - self.postMessage(result); - } - return result; - } - - var workerId, - operationType, - operationSubType; - - return { - - jsCryptoRunner: function(e) { - - workerId = e.data.workerid; - operationType = e.data.operationType; - operationSubType = e.data.operationSubType; - - var operation = e.data.operationType, - result, - func = operations[operation][e.data.algorithm.name], - p = e.data; - - if (!operations.exists(operation, e.data.algorithm.name)) { - throw new Error("unregistered algorithm."); - } - - if (p.operationSubType) { - result = returnResult({ - type: p.operationSubType, - result: func(p) - }); - } else { - result = returnResult(func(p)); - } - - return result; - }, - - returnResult: returnResult - }; - - })(); - - if (runningInWorkerInstance) { - - self.onmessage = function(e) { - - if (!workerInitialized && e.data.prngSeed) { - var entropy = e.data.prngSeed; - msrcryptoPseudoRandom.init(entropy); - workerInitialized = true; - return msrcryptoWorker.returnResult({ - initialized: true - }); - } - - if (workerInitialized === true) { - msrcryptoWorker.jsCryptoRunner(e); - } - - }; - } - - var msrcryptoJwk = (function() { - - var utils = msrcryptoUtilities; - - function stringToArray(stringData) { - - var result = []; - - for (var i = 0; i < stringData.length; i++) { - result[i] = stringData.charCodeAt(i); - } - - if (result[result.length - 1] === 0) { - result.pop(); - } - - return result; - } - - function getKeyType(keyHandle) { - - var algType = keyHandle.algorithm.name.slice(0, 3).toUpperCase(); - - if (algType === "RSA") { - return "RSA"; - } - - if (algType === "ECD") { - return "EC"; - } - - return "oct"; - } - - function hashSize(algorithm) { - return algorithm.hash.name.substring(algorithm.hash.name.indexOf("-") + 1); - } - - var algorithmMap = { - - "HMAC": function(algorithm) { - return "HS" + hashSize(algorithm); - }, - - "AES-CBC": function(algorithm) { - return "A" + algorithm.length.toString() + "CBC"; - }, - - "AES-GCM": function(algorithm) { - return "A" + algorithm.length.toString() + "GCM"; - }, - - "AES-KW": function(algorithm) { - return "A" + algorithm.length.toString() + "KW"; - }, - - "RSAES-PKCS1-V1_5": function(algorithm) { - return "RSA1_5"; - }, - - "RSASSA-PKCS1-V1_5": function(algorithm) { - return "RS" + hashSize(algorithm); - }, - - "RSA-OAEP": function(algorithm) { - if (algorithm.hash.name.toUpperCase() === "SHA-1") { - return "RSA-OAEP"; - } - return "RSA-OAEP-" + hashSize(algorithm); - }, - - "RSA-PSS": function(algorithm) { - return "PS" + hashSize(algorithm); - }, - - "ECDSA": function(algorithm) { - return "EC-" + algorithm.namedCurve.substring(algorithm.namedCurve.indexOf("-") + 1); - } - }; - - function keyToJwk(keyHandle, keyData) { - - var key = {}; - - key.kty = getKeyType(keyHandle); - key.ext = keyHandle.extractable; - if (algorithmMap[keyHandle.algorithm.name.toUpperCase()]) { - key.alg = algorithmMap[keyHandle.algorithm.name.toUpperCase()](keyHandle.algorithm); - } - key.key_ops = keyHandle.usages; - if (keyData.pop) { - key.k = utils.toBase64(keyData, true); - } else { - for (var property in keyData) { - if (keyData[property].pop && property !== "key_ops") { - key[property] = utils.toBase64(keyData[property], true); - } - } - } - - if (keyHandle.algorithm.namedCurve) { - key.crv = keyHandle.algorithm.namedCurve; - } - - return key; - } - - function findUsage(usage, usages) { - for (var i = 0; i < usages.length; i++) { - if (usage.toUpperCase() === usages[i].toUpperCase()) { - return true; - } - } - return false; - } - - function keyToJwkOld(keyHandle, keyData) { - - var key = {}; - - key.kty = getKeyType(keyHandle); - key.extractable = keyHandle.extractable; - - if (keyData.pop) { - key.k = utils.toBase64(keyData, true); - } else { - for (var property in keyData) { - if (keyData[property].pop) { - key[property] = utils.toBase64(keyData[property], true); - } - } - } - - if (keyHandle.algorithm.namedCurve) { - key.crv = keyHandle.algorithm.namedCurve; - } - - var stringData = JSON.stringify(key, null, "\t"); - - return stringToArray(stringData); - } - - function jwkToKey(keyData, algorithm, propsToArray) { - var jsonKeyObject = JSON.parse(JSON.stringify(keyData)); - - for (var i = 0; i < propsToArray.length; i += 1) { - var propValue = jsonKeyObject[propsToArray[i]]; - if (propValue) { - jsonKeyObject[propsToArray[i]] = - utils.fromBase64(propValue); - } - } - - return jsonKeyObject; - } - - return { - keyToJwkOld: keyToJwkOld, - keyToJwk: keyToJwk, - jwkToKey: jwkToKey - }; - })(); - - function msrcryptoMath() { - var DIGIT_BITS = 24; - var DIGIT_NUM_BYTES = Math.floor(DIGIT_BITS / 8); - var DIGIT_MASK = (1 << DIGIT_BITS) - 1; - var DIGIT_BASE = (1 << DIGIT_BITS); - var DIGIT_MAX = DIGIT_MASK; - var DIG_INV = 1 / DIGIT_BASE; - var DIGIT_MAX_ADDS = 31; - - var DIGIT_SCALER = [1, 256]; - for (var ds = 2; ds <= DIGIT_NUM_BYTES; ds++) { - DIGIT_SCALER[ds] = DIGIT_SCALER[ds - 1] * 256; - } - - var Zero = [0]; - var One = [1]; - - function createArray(parameter) { - var i, array = null; - if (!arguments.length || typeof arguments[0] === "number") { - array = new Array(parameter); - for (i = 0; i < parameter; i += 1) { - array[i] = 0; - } - } else if (typeof arguments[0] === "object") { - array = new Array(parameter.length); - for (i = 0; i < parameter.length; i += 1) { - array[i] = parameter[i]; - } - } - return array; - } - - function stringToDigits(numberStr, radix) { - numberStr = numberStr.replace(/^\s+|\s+$/g, ""); - var num = [0]; - var buffer = [0]; - radix = radix || 10; - for (var i = 0; i < numberStr.length; i += 1) { - var char = parseInt(numberStr[i], radix); - if (isNaN(char)) { - throw new Error("Failed to convert string to integer in radix " + radix.toString()); - } - - multiply(num, radix, buffer); - - add(buffer, [char], num); - normalizeDigitArray(num); - } - - return num; - } - - function digitsToString(digits, radix) { - radix = radix || 10; - if (DIGIT_BASE <= radix) { - throw new Error("DIGIT_BASE is smaller than RADIX; cannot convert."); - } - - var wordLength = digits.length; - var quotient = []; - var remainder = []; - var temp1 = []; - var temp2 = []; - var divisor = []; - var a = []; - var i; - - var sb = ""; - var pad = "0"; - divisor[0] = radix; - while (Math.floor(DIGIT_BASE / divisor[0]) >= radix) { - divisor[0] = divisor[0] * radix; - pad = pad.concat("0"); - } - - for (i = 0; i < wordLength; i += 1) { - a[i] = digits[i]; - } - - do { - var allZeros = true; - for (i = 0; i < a.length; i += 1) { - if (a[i] !== 0) { - allZeros = false; - break; - } - } - - if (allZeros) { - break; - } - - divRem(a, divisor, quotient, remainder, temp1, temp2); - normalizeDigitArray(quotient, a.length, true); - - var newDigits = remainder[0].toString(radix); - sb = pad.substring(0, pad.length - newDigits.length) + newDigits + sb; - - var swap = a; - a = quotient; - quotient = swap; - } while (true); - - while (sb.length !== 0 && sb[0] === "0") { - sb = sb.substring(1, sb.length); - } - - if (sb.length === 0) { - sb = "0"; - } - - return sb; - } - - function computeBitArray(bytes) { - var out = createArray(bytes.length * 8); - var bitLength = 0; - var i = bytes.length - 1; - while (i >= 0) { - var j = 0; - while (j < 8) { - var mask = (1 << j); - var bit = ((bytes[i] & mask) === mask) ? 1 : 0; - var thisBitIndex = (8 * ((bytes.length - i) - 1)) + j; - - if (bit === 1) { - bitLength = thisBitIndex + 1; - } - - out[thisBitIndex] = bit; - j += 1; - } - - i--; - } - - return out.slice(0, bitLength); - } - - function bitScanForward(digit) { - var index = 0; - - for (var i = 0; i < DIGIT_BITS; i++) { - index = Math.max(index, -(digit >>> i & 1) & i); - } - - return index; - } - - function highestSetBit(bytes) { - var i = 0; - var bitLength = 0; - - while (i < bytes.length) { - if (bitLength === 0) { - var j = 7; - while (j >= 0 && bitLength === 0) { - var mask = (1 << j); - if ((bytes[i] & mask) === mask) { - bitLength = j + 1; - } - - j--; - } - } else { - bitLength += 8; - } - - i += 1; - } - - return bitLength; - } - - function fixedWindowRecode(digits, windowSize, t) { - digits = digits.slice(); - - var recodedDigits = [], - windowSizeBits = Math.pow(2, windowSize), - windowSizeMinus1Bits = Math.pow(2, windowSize - 1); - - for (var i = 0; i < t; i++) { - - recodedDigits[i] = (digits[0] % windowSizeBits) - windowSizeMinus1Bits; - - digits[0] = digits[0] - recodedDigits[i]; - - cryptoMath.shiftRight(digits, digits, windowSize - 1); - } - - recodedDigits[i] = digits[0]; - - return recodedDigits; - } - - function fixedWindowRecode2(digits, windowSize) { - - var digLen = digits.length, - bits = new Array(digLen * DIGIT_BITS), - i = 0, - j = 0, - k = 0, - r = 0, - dig, - result = new Array(Math.ceil(digLen * DIGIT_BITS / windowSize)); - - for (k = 0, result[0] = 0; i < digLen; i++) { - for (j = 0, dig = digits[i]; j < DIGIT_BITS; j++, dig >>>= 1) { - if (k === windowSize) { - result[++r] = 0; - k = 0; - } - result[r] += (dig & 1) << k++; - } - } - - return result; - } - - function fetchBits(digits, startBit, count) { - var startDigit = Math.floor(startBit / cryptoMath.DIGIT_BITS); - var endDigit = startDigit + 1; - - var shiftRight = (startBit % cryptoMath.DIGIT_BITS); - var shiftLeft = cryptoMath.DIGIT_BITS - shiftRight; - - var bits = (digits[startDigit] >>> shiftRight) | (digits[endDigit] << shiftLeft); - - return bits & (cryptoMath.DIGIT_MASK >>> (cryptoMath.DIGIT_BITS - count)); - - } - - function fetchBits2(digits, startBit, count) { - var startDigit = Math.floor(startBit / DIGIT_BITS), - shiftRight = (startBit % DIGIT_BITS); - - return (digits[startDigit] >>> shiftRight) | - (digits[startDigit + 1] << (DIGIT_BITS - shiftRight)) & - (DIGIT_MASK >>> (DIGIT_BITS - count)); - } - - function copyArray(source, sourceIndex, destination, destIndex, length) { - while (length-- > 0) { - destination[destIndex + length] = source[sourceIndex + length]; - } - } - - function isZero(array) { - var i, - result = 0; - - for (i = 0; i < array.length; i += 1) { - result = result | array[i]; - } - return !result; - } - - function isEven(array) { - return (array[0] & 0x1) === 0x0; - } - - function sequenceEqual(left, right) { - var equal = left.length === right.length; - - for (var i = 0; i < Math.min(left.length, right.length); i += 1) { - if (left[i] !== right[i]) { - equal = false; - } - } - - return equal; - } - - function bytesToDigits(bytes) { - var arrayLength = Math.floor((bytes.length + DIGIT_NUM_BYTES - 1) / DIGIT_NUM_BYTES); - var array = new Array(arrayLength); - array[0] = 0; - var digit = 0, - index = 0, - scIndex = 0; - for (var i = bytes.length - 1; i >= 0; i--) { - digit = digit + (DIGIT_SCALER[scIndex++] * (bytes[i] & 0x0ff)); - if (DIGIT_SCALER[scIndex] === DIGIT_BASE) { - scIndex = 0; - array[index++] = digit; - digit = 0; - } - } - - if (digit !== 0) { - array[index] = digit; - } - - while (array[--arrayLength] == null) { - array[arrayLength] = 0; - } - - return array; - } - - function digitsToBytes(digits, trim, minTrimLength) { - var i, j, byte1; - var bytes = [0]; - - if (typeof trim === "undefined") { - trim = true; - } - - for (i = 0; i < digits.length; i += 1) { - byte1 = digits[i]; - for (j = 0; j < DIGIT_NUM_BYTES; j += 1) { - bytes[i * DIGIT_NUM_BYTES + j] = byte1 & 0x0FF; - byte1 = Math.floor(byte1 / 256); - } - } - - bytes.reverse(); - - if (minTrimLength === undefined) { - minTrimLength = 1; - } - if (trim) { - while (bytes.length > minTrimLength && bytes[0] === 0) { - bytes.shift(); - } - } - - return bytes; - } - - function intToDigits(value, numDigits) { - if (typeof numDigits === "undefined") { - if (value <= 1) { - numDigits = 1; - } else { - var numBits = Math.log(value) / Math.LN2; - numDigits = Math.ceil(numBits / DIGIT_BITS); - } - } - - var digitRepresentation = []; - while (value > 0) { - digitRepresentation.push(value % DIGIT_BASE); - value = Math.floor(value / DIGIT_BASE); - } - - while (digitRepresentation.length < numDigits) { - digitRepresentation.push(0); - } - - return digitRepresentation; - } - - function mswIndex(digits) { - for (var i = digits.length - 1; i >= 0; i--) { - if (digits[i] !== undefined && digits[i] !== 0) { - return i; - } - } - - return (digits[0] === 0) ? -1 : 0; - } - - function compareDigits(left, right) { - - var result = 0, - val, i; - - for (i = 0; i < Math.max(left.length, right.length); i++) { - val = ~~left[i] - ~~right[i]; - result = val + (result & -!val); - } - - return result; - } - - function normalizeDigitArray(digits, length, pad) { - var i = mswIndex(digits); - - digits.length = length || i + 1; - - if (pad) { - while (++i < digits.length) { - digits[i] = 0; - } - } - - if (digits.length <= 0) { - digits[0] = 0; - digits.length = 1; - } - - return digits; - } - - function shiftRight(source, destination, bits, length) { - if (bits === undefined) { - bits = 1; - } else if (bits >= DIGIT_BITS || bits < 0) { - throw new Error("Invalid bit count for shiftRight"); - } - if (length === undefined) { - length = source.length; - } - - var n = length - 1; - var leftShiftBitCount = DIGIT_BITS - bits; - for (var i = 0; i < n; i++) { - destination[i] = ((source[i + 1] << leftShiftBitCount) | (source[i] >>> bits)) & DIGIT_MASK; - } - - destination[n] = source[n] >>> bits; - } - - function shiftLeft(source, destination, bits, length) { - if (bits === undefined) { - bits = 1; - } else if (bits >= DIGIT_BITS || bits < 0) { - throw new Error("bit count must be smaller than DIGIT_BITS and positive in shiftLeft"); - } - if (length === undefined) { - length = source.length; - } - - var rightShiftBitCount = DIGIT_BITS - bits; - destination[length] = (source[length - 1] >>> (DIGIT_BITS - bits)) || destination[length]; - for (var i = length - 1; i > 0; i--) { - destination[i] = ((source[i] << bits) | ((source[i - 1] >>> rightShiftBitCount))) & DIGIT_MASK; - } - - destination[0] = (source[0] << bits) & DIGIT_MASK; - } - - function add(addend1, addend2, sum) { - var shortArray = addend1; - var longArray = addend2; - if (addend2.length < addend1.length) { - shortArray = addend2; - longArray = addend1; - } - - var s = shortArray.length; - var carry = 0; - var i; - - for (i = 0; i < s; i += 1) { - carry += shortArray[i] + longArray[i]; - sum[i] = carry & DIGIT_MASK; - carry = (carry >> DIGIT_BITS); - } - - for (i = s; i < longArray.length; i += 1) { - carry += longArray[i]; - sum[i] = carry & DIGIT_MASK; - carry = (carry >> DIGIT_BITS); - } - - sum.length = longArray.length; - - if (carry !== 0) { - sum[i] = carry & DIGIT_MASK; - } - - return carry; - } - - function subtract(minuend, subtrahend, difference) { - var s = subtrahend.length; - if (minuend.length < subtrahend.length) { - s = mswIndex(subtrahend) + 1; - if (minuend.length < s) { - throw new Error("Subtrahend is longer than minuend, not supported."); - } - } - var i, carry = 0; - for (i = 0; i < s; i += 1) { - carry += minuend[i] - subtrahend[i]; - difference[i] = carry & DIGIT_MASK; - carry = carry >> DIGIT_BITS; - } - - while (i < minuend.length) { - carry += minuend[i]; - difference[i++] = carry & DIGIT_MASK; - carry = carry >> DIGIT_BITS; - } - - return carry; - } - - function multiply(a, b, p) { - - b = (typeof b === "number") ? [b] : b; - - var i, j, k, l, c, t1, t2, alen = a.length, - blen = b.length, - bi; - - for (i = 0; i < alen + blen; i += 1) { - p[i] = 0; - } - - i = 0; - l = 0; - - var maxRounds = 31; - var ks = 0; - - while (i < blen) { - - l = Math.min(l + maxRounds, blen); - - for (; i < l; i++) { - bi = b[i]; - for (j = 0; j < alen; j++) { - p[i + j] += a[j] * bi; - } - } - - c = 0; - for (k = ks; k < i + alen; k++) { - t1 = p[k] + c; - t2 = t1 & DIGIT_MASK; - p[k] = t2; - c = (t1 - t2) * DIG_INV; - } - p[k] = c; - - ks += maxRounds; - } - - p.length = alen + blen; - - return p; - } - - function divRem(dividend, divisor, quotient, remainder, temp1, temp2) { - var m = mswIndex(dividend) + 1; - var n = mswIndex(divisor) + 1; - var qhat, rhat, carry, p, t, i, j; - - if (m < n) { - copyArray(dividend, 0, remainder, 0, dividend.length); - remainder.length = dividend.length; - normalizeDigitArray(remainder); - quotient[0] = 0; - quotient.length = 1; - return; - } else if (n === 0 || (n === 1 && divisor[n - 1] === 0)) { - throw new Error("Division by zero."); - } else if (n === 1) { - t = divisor[0]; - rhat = 0; - for (j = m - 1; j >= 0; j--) { - p = (rhat * DIGIT_BASE) + dividend[j]; - quotient[j] = (p / t) & DIGIT_MASK; - rhat = (p - quotient[j] * t) & DIGIT_MASK; - } - quotient.length = m; - normalizeDigitArray(quotient); - remainder[0] = rhat; - remainder.length = 1; - return; - } - - var s = DIGIT_BITS - 1 - bitScanForward(divisor[n - 1]); - var vn = temp1 || []; - vn.length = n; - shiftLeft(divisor, vn, s, n); - - var un = temp2 || []; - un.length = m; - shiftLeft(dividend, un, s, m); - un[m] = un[m] || 0; - - quotient.length = m - n + 1; - remainder.length = n; - for (j = m - n; j >= 0; j--) { - qhat = Math.floor((un[j + n] * DIGIT_BASE + un[j + n - 1]) / vn[n - 1]); - rhat = (un[j + n] * DIGIT_BASE + un[j + n - 1]) - qhat * vn[n - 1]; - - while (true) { - if (qhat >= DIGIT_BASE || (qhat * vn[n - 2]) > ((rhat * DIGIT_BASE) + un[j + n - 2])) { - qhat = qhat - 1; - rhat = rhat + vn[n - 1]; - if (rhat < DIGIT_BASE) { - continue; - } - } - - break; - } - - carry = 0; - for (i = 0; i < n; i++) { - p = qhat * vn[i]; - t = un[i + j] - carry - (p & DIGIT_MASK); - un[i + j] = t & DIGIT_MASK; - carry = Math.floor(p / DIGIT_BASE) - Math.floor(t / DIGIT_BASE); - } - - t = un[j + n] - carry; - un[j + n] = t & DIGIT_MASK; - - quotient[j] = qhat & DIGIT_MASK; - - if (t < 0) { - quotient[j] = quotient[j] - 1; - - carry = 0; - for (i = 0; i < n; i++) { - t = un[i + j] + vn[i] + carry; - un[i + j] = t & DIGIT_MASK; - carry = t >> DIGIT_BITS; - } - un[j + n] = (un[j + n] + carry) & DIGIT_MASK; - } - } - - for (i = 0; i < n; i++) { - remainder[i] = ((un[i] >>> s) | (un[i + 1] << (DIGIT_BITS - s))) & DIGIT_MASK; - } - - normalizeDigitArray(quotient); - normalizeDigitArray(remainder); - } - - function reduce(number, modulus, remainder, temp1, temp2) { - var quotient = []; - divRem(number, modulus, quotient, remainder, temp1, temp2); - - return remainder; - } - - function modMul(multiplicand, multiplier, modulus, product, temp1, temp2) { - var quotient = []; - multiply(multiplicand, multiplier, quotient); - divRem(quotient, modulus, quotient, product, temp1, temp2); - - return product; - } - - function eea(a, b, upp, vpp, rpp) { - var rp; - if (isZero(a)) { - copyArray(b, 0, rpp, 0, b.length); - rpp.length = b.length; - return 0; - } else if (isZero(b)) { - copyArray(a, 0, rpp, 0, a.length); - rpp.length = a.length; - return 0; - } else if (compareDigits(a, b) < 0) { - rp = a.slice(0); - copyArray(b, 0, rpp, 0, b.length); - rpp.length = b.length; - } else { - rp = b.slice(0); - copyArray(a, 0, rpp, 0, a.length); - rpp.length = a.length; - } - - normalizeDigitArray(rpp); - normalizeDigitArray(rp); - var q = new Array(rpp.length); - var r = new Array(rpp.length); - - var v = new Array(rpp.length); - var vppPresent = vpp !== undefined; - var vp; - if (vppPresent) { - vp = new Array(rpp.length); - vp[0] = 1; - vp.length = 1; - vpp[0] = 0; - vpp.length = 1; - } - - var up; - var u = new Array(rpp.length); - var uppPresent = upp !== undefined; - if (uppPresent) { - up = new Array(rpp.length); - up[0] = 0; - up.length = 1; - upp[0] = 1; - upp.length = 1; - } - - var k = -1; - - var upp_out = upp; - var vpp_out = vpp; - var rpp_out = rpp; - var save; - - while (!isZero(rp)) { - divRem(rpp, rp, q, r, u, v); - - if (uppPresent) { - multiply(q, up, u); - add(u, upp, u); - normalizeDigitArray(u); - save = upp; - upp = up; - up = u; - u = save; - } - - if (vppPresent) { - multiply(q, vp, v); - add(v, vpp, v); - normalizeDigitArray(v); - save = vpp; - vpp = vp; - vp = v; - v = save; - } - - save = rpp; - rpp = rp; - rp = r; - r = save; - - k++; - } - - if (uppPresent) { - copyArray(upp, 0, upp_out, 0, upp.length); - upp_out.length = upp.length; - } - if (vppPresent) { - copyArray(vpp, 0, vpp_out, 0, vpp.length); - vpp_out.length = vpp.length; - } - copyArray(rpp, 0, rpp_out, 0, rpp.length); - rpp_out.length = rpp.length; - - return k; - } - - function gcd(a, b, output) { - var aa = a; - var bb = b; - if (compareDigits(a, b) > 0) { - aa = b; - bb = a; - } - - eea(aa, bb, undefined, undefined, output); - return normalizeDigitArray(output); - } - - function modInv(a, n, aInv, pad) { - var upp = new Array(n.length); - var vpp = new Array(n.length); - var rpp = new Array(n.length); - var k = eea(a, n, vpp, upp, rpp); - - aInv = aInv || []; - if (compareDigits(rpp, One) !== 0) { - aInv[0] = NaN; - aInv.length = 1; - } else { - if ((k & 1) === 1) { - subtract(n, upp, aInv); - } else { - copyArray(upp, 0, aInv, 0, upp.length); - aInv.length = upp.length; - } - if (pad) { - normalizeDigitArray(aInv, n.length, true); - } else { - normalizeDigitArray(aInv); - } - } - - return aInv; - } - - function modInvCT(a, n, aInv, pad) { - var nMinus2 = []; - aInv = aInv || []; - subtract(n, [2], nMinus2); - modExp(a, nMinus2, n, aInv); - normalizeDigitArray(aInv); - return aInv; - } - - function modExp(base, exponent, modulus, result) { - result = result || []; - - if (compareDigits(exponent, Zero) === 0) { - result[0] = 1; - } else if (compareDigits(exponent, One) === 0) { - copyArray(base, 0, result, 0, base.length); - result.length = base.length; - } else { - var montmul = new MontgomeryMultiplier(modulus); - normalizeDigitArray(base, montmul.s, true); - montmul.modExp( - base, - exponent, - result); - result.length = modulus.length; - } - - return result; - } - - function MontgomeryMultiplier(modulus, context) { - function computeM0Prime(m0) { - var m0Pr = 1; - var a = 2; - var b = 3; - var c = b & m0; - - for (var i = 2; i <= DIGIT_BITS; i += 1) { - if (a < c) { - m0Pr += a; - } - - a = a << 1; - b = (b << 1) | 1; - c = m0 * m0Pr & b; - } - - var result = (~m0Pr & DIGIT_MASK) + 1; - return result; - } - - function montgomeryReduction(t, m, result) { - - var m0 = m[0]; - var mPrime = computeM0Prime(m0); - var n = m.length; - var A = t.slice(0); - var ui = []; - var uimbi = []; - var uim = []; - var bi = [1]; - - for (var i = 0; i < n; i++) { - - ui = (A[i] * mPrime) % DIGIT_BASE; - - multiply(m, [ui], uim); - multiply(uim, bi, uimbi); - - add(A, uimbi, A); - - bi.unshift(0); - } - - A = A.slice(n); - for (i = 0; i < A.length; i++) { - result[i] = A[i]; - } - - } - - function montgomeryMultiply(multiplicand, multiplier, result, ctx) { - ctx = ctx || this; - - var m = ctx.m, - s = m.length, - mPrime = ctx.mPrime, - m0 = ctx.m0, - rightI, r0, q, i = 0, - j, jm1, t1, t2, carry, rounds = 0; - - var temp = createArray(s + 2); - - while (i < s) { - - rounds = Math.min(s, rounds + 16); - - for (; i < rounds;) { - - rightI = ~~multiplier[i]; - - r0 = temp[0] + multiplicand[0] * rightI; - - q = ((r0 & DIGIT_MASK) * mPrime) & DIGIT_MASK; - - temp[1] += ((m0 * q + r0) * DIG_INV) | 0; - - for (j = 1, jm1 = 0; j < s; jm1 = j, j += 1) { - temp[jm1] = temp[j] + m[j] * q + multiplicand[j] * rightI; - } - temp[jm1] = temp[j]; - temp[j] = 0; - - i++; - } - - carry = 0; - for (j = 0; j < s; j++) { - t1 = temp[j] + carry; - t2 = t1 & DIGIT_MASK; - temp[j] = t2; - carry = (t1 - t2) * DIG_INV; - } - temp[j] = carry; - } - - for (i = 0; i < s; i += 1) { - result[i] = temp[i]; - } - result.length = s; - - var needSubtract = +(cryptoMath.compareDigits(temp, m) > 0); - cryptoMath.subtract(result, m, ctx.temp2); - - ctSetArray(needSubtract, result, ctx.temp2); - - return; - } - - function convertToMontgomeryForm(digits) { - if (digits.length < this.s) { - digits.length = this.s; - for (var i = 0; i < this.s; i++) { - digits[i] = isNaN(digits[i]) ? 0 : digits[i]; - } - } - - var result = createArray(digits.length); - - this.montgomeryMultiply(digits, this.rSquaredModm, result); - for (i = 0; i < this.s; i += 1) { - digits[i] = result[i]; - } - } - - function convertToStandardForm(digits) { - this.montgomeryMultiply(digits, this.one, this.temp1); - for (var i = 0; i < this.s; i += 1) { - digits[i] = this.temp1[i]; - } - } - - function optimalWindowSize(length) { - - var i = 2, - t1, t0, bits = length * DIGIT_BITS; - - t0 = 4 + Math.ceil(bits / 2) * 3 + 1; - do { - i++; - t1 = t0; - t0 = Math.pow(2, i) + Math.ceil(bits / i) * (i + 1) + 1; - } while (t0 < t1); - - return i - 1; - } - - function modExp(base, exponent, result, skipSideChannel) { - skipSideChannel = !!skipSideChannel; - - var windowBits = optimalWindowSize(exponent.length); - - var i, j, - expBits = fixedWindowRecode2(exponent, windowBits).reverse(), - partialResult = this.rModM.slice(0), - baseTableLen = Math.pow(2, windowBits), - bt = baseTable; - - bt.length = baseTableLen; - bt[0] = this.rModM; - for (i = 1; i < baseTableLen; i++) { - bt[i] = []; - multiply(bt[i - 1], base, bt[i]); - this.reduce(bt[i]); - } - - var tableVal = []; - var exp; - - for (i = 0; i < expBits.length; i++) { - for (j = 0; j < windowBits; j++) { - this.montgomeryMultiply(partialResult, partialResult, partialResult); - } - - exp = expBits[i]; - - skipSideChannel ? - (tableVal = bt[exp]) : - getTableEntry(bt, exp, tableVal); - - this.montgomeryMultiply(partialResult, tableVal, partialResult); - } - - this.montgomeryMultiply(partialResult, this.one, result); - - return result; - } - - function getTableEntry(bt, exp, tableVal) { - - var z, t, mask, tableEntry, k; - for (z = 0; z < bt[0].length; z++) { - tableVal[z] = 0; - } - for (t = 0; t < bt.length; t++) { - tableEntry = bt[t]; - mask = -(exp === t); - for (k = 0; k < tableEntry.length; k++) { - tableVal[k] = tableVal[k] | (tableEntry[k] & mask); - } - } - } - - function ctSetArray(condition, a, b) { - var bMask = -condition; - var aMask = ~bMask; - - for (var i = 0; i < a.length; i++) { - a[i] = (a[i] & aMask) | (b[i] & bMask); - } - } - - function reduce(x, result) { - var k = this.m.length, - q1, q2, q3, - r1, r2, - i, - needSubtract, - temp = []; - - result = result || x; - - q1 = x.slice(k - 1); - q2 = []; - multiply(q1, this.mu, q2); - q3 = q2.slice(k + 1); - - r1 = x.slice(0, k + 1); - r2 = []; - multiply(q3, m, r2); - r2 = r2.slice(0, k + 1); - - r1[k + 1] = compareDigits(r1, r2) >>> 31; - - for (i = 0; i < result.length; i++) { - result[i] = 0; - } - subtract(r1, r2, result); - - needSubtract = +(compareDigits(result, m) > 0); - cryptoMath.subtract(result, m, temp); - ctSetArray(needSubtract, result, temp); - - normalizeDigitArray(result); - - return; - } - - function computeContext(modulus) { - - var s = modulus.length; - - var m0 = modulus[0]; - - var ctx = { - m: modulus, - mPrime: computeM0Prime(m0), - m0: m0, - temp1: createArray(2 * s + 1), - temp2: createArray(2 * s + 1) - }; - - var R = createArray(modulus.length * 2); - R[R.length] = 1; - ctx.mu = []; - divRem(R, modulus, ctx.mu, []); - - var quotient = createArray(2 * s + 1); - var rRemainder = createArray(s + 1); - var temp1 = createArray(2 * s + 1); - var temp2 = createArray(2 * s + 1); - var rDigits = rRemainder; - rDigits[s] = 1; - divRem(rDigits, modulus, quotient, rRemainder, temp1, temp2); - ctx.rModM = normalizeDigitArray(rRemainder, s, true); - - var rSquaredModm = createArray(2 * s + 1); - var rSquaredDigits = rSquaredModm; - rSquaredDigits[s * 2] = 1; - divRem(rSquaredDigits, modulus, quotient, rSquaredModm, temp1, temp2); - ctx.rSquaredModm = normalizeDigitArray(rSquaredModm, s, true); - - ctx.rCubedModm = createArray(s); - montgomeryMultiply(rSquaredModm, rSquaredModm, ctx.rCubedModm, ctx); - - return ctx; - } - - context = context || computeContext(modulus); - - var m = context.m; - - var mu = context.mu; - - var m0 = context.m0; - - var s = m.length; - - var zeros = createArray(s + 1); - - var one = zeros.slice(0, s); - one[0] = 1; - - var mPrime = context.mPrime; - - var rModM = context.rModM; - - var rSquaredModm = context.rSquaredModm; - - var rCubedModm = context.rCubedModm; - - var temp1 = createArray(2 * s + 1); - var temp2 = createArray(2 * s + 1); - - var baseTable = new Array(4); - baseTable[0] = rModM; - baseTable[1] = new Array(s); - baseTable[2] = new Array(s); - baseTable[3] = new Array(s); - - return { - m: m, - - m0: m0, - - mPrime: mPrime, - mu: mu, - - rSquaredModm: rSquaredModm, - s: s, - rModM: rModM, - rCubedModm: rCubedModm, - one: one, - temp1: temp1, - temp2: temp2, - - convertToMontgomeryForm: convertToMontgomeryForm, - convertToStandardForm: convertToStandardForm, - montgomeryMultiply: montgomeryMultiply, - modExp: modExp, - reduce: reduce, - - ctx: context - }; - } - - function IntegerGroup(modulusBytes) { - var m_modulus = bytesToDigits(modulusBytes); - - var m_digitWidth = m_modulus.length; - - var m_zero = intToDigits(0, m_digitWidth); - var m_one = intToDigits(1, m_digitWidth); - - var temp0 = createArray(m_digitWidth); - var temp1 = createArray(m_digitWidth); - - var montmul = new MontgomeryMultiplier(m_modulus); - - function createElementFromBytes(bytes) { - var digits = bytesToDigits(bytes); - - if (cryptoMath.compareDigits(digits, this.m_modulus) >= 0) { - throw new Error("The number provided is not an element of this group"); - } - - normalizeDigitArray(digits, this.m_digitWidth, true); - return integerGroupElement(digits, this); - } - - function createElementFromInteger(integer) { - var digits = intToDigits(integer, this.m_digitWidth); - return integerGroupElement(digits, this); - } - - function createElementFromDigits(digits) { - cryptoMath.normalizeDigitArray(digits, this.m_digitWidth, true); - return integerGroupElement(digits, this); - } - - function equals(otherGroup) { - return compareDigits(this.m_modulus, otherGroup.m_modulus) === 0; - } - - function add(addend1, addend2, sum) { - var i; - var s = this.m_digitWidth; - var result = sum.m_digits; - cryptoMath.add(addend1.m_digits, addend2.m_digits, result); - var mask = (compareDigits(result, this.m_modulus) >>> 31) - 1 & DIGIT_MASK; - - var carry = 0; - for (i = 0; i < s; i += 1) { - carry = result[i] - (this.m_modulus[i] & mask) + carry; - result[i] = carry & DIGIT_MASK; - carry = (carry >> DIGIT_BITS); - } - - result.length = s; - } - - function subtract(leftElement, rightElement, outputElement) { - var i, s = this.m_digitWidth; - var result = outputElement.m_digits; - var carry = cryptoMath.subtract(leftElement.m_digits, rightElement.m_digits, outputElement.m_digits); - - if (carry === -1) { - carry = 0; - for (i = 0; i < s; i += 1) { - carry += result[i] + this.m_modulus[i]; - result[i] = carry & DIGIT_MASK; - carry = carry >> DIGIT_BITS; - } - } - } - - function inverse(element, outputElement) { - cryptoMath.modInv(element.m_digits, this.m_modulus, outputElement.m_digits); - } - - function multiply(multiplicand, multiplier, product) { - return cryptoMath.modMul(multiplicand.m_digits, multiplier.m_digits, this.m_modulus, - product.m_digits, temp0, temp1); - } - - function modexp(valueElement, exponent, outputElement) { - outputElement = outputElement || integerGroupElement([], this); - - if (compareDigits(exponent, m_zero) === 0) { - outputElement.m_digits = intToDigits(1, this.m_digitWidth); - } else if (compareDigits(exponent, m_one) === 0) { - for (var i = 0; i < valueElement.m_digits.length; i++) { - outputElement.m_digits[i] = valueElement.m_digits[i]; - } - outputElement.m_digits.length = valueElement.m_digits.length; - } else { - this.montmul.modExp( - valueElement.m_digits, - exponent, - outputElement.m_digits); - outputElement.m_digits.length = this.montmul.s; - } - - return outputElement; - } - - function integerGroupElement(digits, group) { - return { - m_digits: digits, - m_group: group, - - equals: function(element) { - return (compareDigits(this.m_digits, element.m_digits) === 0) && - this.m_group.equals(this.m_group, element.m_group); - } - }; - } - - return { - m_modulus: m_modulus, - m_digitWidth: m_digitWidth, - montmul: montmul, - - createElementFromInteger: createElementFromInteger, - createElementFromBytes: createElementFromBytes, - createElementFromDigits: createElementFromDigits, - equals: equals, - add: add, - subtract: subtract, - multiply: multiply, - inverse: inverse, - modexp: modexp - }; - } - - return { - DIGIT_BITS: DIGIT_BITS, - DIGIT_NUM_BYTES: DIGIT_NUM_BYTES, - DIGIT_MASK: DIGIT_MASK, - DIGIT_BASE: DIGIT_BASE, - DIGIT_MAX: DIGIT_MAX, - Zero: Zero, - One: One, - - normalizeDigitArray: normalizeDigitArray, - bytesToDigits: bytesToDigits, - stringToDigits: stringToDigits, - digitsToString: digitsToString, - intToDigits: intToDigits, - digitsToBytes: digitsToBytes, - isZero: isZero, - isEven: isEven, - - shiftRight: shiftRight, - shiftLeft: shiftLeft, - compareDigits: compareDigits, - bitLength: highestSetBit, - - fixedWindowRecode: fixedWindowRecode, - IntegerGroup: IntegerGroup, - - add: add, - subtract: subtract, - multiply: multiply, - divRem: divRem, - reduce: reduce, - modInv: modInv, - modInvCT: modInvCT, - modExp: modExp, - modMul: modMul, - MontgomeryMultiplier: MontgomeryMultiplier, - gcd: gcd, - sequenceEqual: sequenceEqual, - swapEndianness: function(bytes) { - return bytes.reverse(); - }, - computeBitArray: computeBitArray - }; - } - - var cryptoMath = cryptoMath || msrcryptoMath(); - - function MsrcryptoECC() { - var btd = cryptoMath.bytesToDigits; - - function createArray(parameter) { - var i, array = null; - if (!arguments.length || typeof arguments[0] === "number") { - array = []; - for (i = 0; i < parameter; i += 1) { - array[i] = 0; - } - } else if (typeof arguments[0] === "object") { - array = []; - for (i = 0; i < parameter.length; i += 1) { - array[i] = parameter[i]; - } - } - return array; - } - - var EllipticCurveFp = function(p1, a1, b1, order, gx, gy) { - var fieldStorageBitLength = p1.length; - - var generator = EllipticCurvePointFp(this, false, gx, gy, null, false); - - return { - p: p1, - a: a1, - b: b1, - order: order, - generator: generator, - allocatePointStorage: function() { - return EllipticCurvePointFp( - this, - false, - cryptoMath.intToDigits(0, fieldStorageBitLength), - cryptoMath.intToDigits(0, fieldStorageBitLength) - ); - }, - createPointAtInfinity: function() { - return EllipticCurvePointFp( - this, - true, - cryptoMath.intToDigits(0, fieldStorageBitLength), - cryptoMath.intToDigits(0, fieldStorageBitLength) - ); - } - }; - }; - - var createWeierstrassCurve = function(curveData) { - - var newCurve = new EllipticCurveFp( - btd(curveData.p), - btd(curveData.a), - btd(curveData.b), - btd(curveData.order), - btd(curveData.gx), - btd(curveData.gy) - ); - - newCurve.type = curveData.type; - newCurve.name = curveData.name; - newCurve.generator.curve = newCurve; - - return newCurve; - }; - - var createTedCurve = function(curveData) { - - var newCurve = new EllipticCurveFp( - btd(curveData.p), - btd(curveData.a), - btd(curveData.d), - btd(curveData.order), - btd(curveData.gx), - btd(curveData.gy) - ); - - newCurve.type = curveData.type; - - if (newCurve.type === 1) { - newCurve.d = newCurve.b.slice(); - delete newCurve.b; - } - - newCurve.rbits = curveData.info[2]; - newCurve.name = curveData.name; - newCurve.generator.curve = newCurve; - - return newCurve; - }; - - var EllipticCurvePointFp = function(curve, isInfinity, x, y, z, isInMontgomeryForm) { - var returnObj; - - if (typeof z === "undefined") { - z = null; - } - - if (typeof isInMontgomeryForm === "undefined") { - isInMontgomeryForm = false; - } - - function equals(ellipticCurvePointFp) { - if (!ellipticCurvePointFp) { - return false; - } - - if (returnObj.isInfinity && ellipticCurvePointFp.isInfinity) { - return true; - } - - if (returnObj.z === null && ellipticCurvePointFp.z !== null) { - return false; - } - - if (returnObj.z !== null && ellipticCurvePointFp.z === null) { - return false; - } - - if (returnObj.z === null) { - return cryptoMath.compareDigits(returnObj.x, ellipticCurvePointFp.x) === 0 && - cryptoMath.compareDigits(returnObj.y, ellipticCurvePointFp.y) === 0 && - returnObj.isInMontgomeryForm === ellipticCurvePointFp.isInMontgomeryForm; - } - - return cryptoMath.compareDigits(returnObj.x, ellipticCurvePointFp.x) === 0 && - cryptoMath.compareDigits(returnObj.y, ellipticCurvePointFp.y) === 0 && - cryptoMath.compareDigits(returnObj.z, ellipticCurvePointFp.z) === 0 && - returnObj.isInMontgomeryForm === ellipticCurvePointFp.isInMontgomeryForm; - } - - function copyTo(source, destination) { - destination.curve = source.curve; - destination.x = source.x.slice(); - destination.y = source.y.slice(); - - if (source.z !== null) { - destination.z = source.z.slice(); - } else { - destination.z = null; - } - - setterSupport || (destination.isAffine = source.isAffine); - destination.isInMontgomeryForm = source.isInMontgomeryForm; - destination.isInfinity = source.isInfinity; - - if (!destination.equals(source)) { - throw new Error("Instances should be equal."); - } - - } - - function clone() { - - var clonePoint = EllipticCurvePointFp( - returnObj.curve, - returnObj.isInfinity, - createArray(returnObj.x), - createArray(returnObj.y), - returnObj.z ? createArray(returnObj.z) : null, - returnObj.isInMontgomeryForm); - - returnObj.ta && (clonePoint.ta = createArray(returnObj.ta)); - returnObj.tb && (clonePoint.tb = createArray(returnObj.tb)); - - return clonePoint; - } - - returnObj = { - equals: function(ellipticCurvePointFp) { - return equals(ellipticCurvePointFp); - }, - copy: function(destination) { - copyTo(this, destination); - return; - }, - clone: function() { - return clone(); - } - }; - - createProperty(returnObj, "curve", curve, function() { - return curve; - }, function(val) { - curve = val; - }); - - createProperty(returnObj, "x", x, function() { - return x; - }, function(val) { - x = val; - }); - createProperty(returnObj, "y", y, function() { - return y; - }, function(val) { - y = val; - }); - createProperty(returnObj, "z", z, function() { - return z; - }, function(val) { - z = val; - }); - - createProperty(returnObj, "isInMontgomeryForm", isInMontgomeryForm, - function() { - return isInMontgomeryForm; - }, - function(val) { - isInMontgomeryForm = val; - }); - createProperty(returnObj, "isInfinity", isInfinity, - function() { - return isInfinity; - }, - function(val) { - isInfinity = val; - }); - createProperty(returnObj, "isAffine", z === null, function() { - return z === null; - }); - - return returnObj; - }; - - var EllipticCurveOperatorFp = function(curve) { - var m_curve = curve; - - var tedCurve = curve.type === 1; - - var fieldElementWidth = curve.p.length; - - var montgomeryMultiplier = cryptoMath.MontgomeryMultiplier(curve.p); - - var montgomerizedA = curve.a.slice(); - montgomeryMultiplier.convertToMontgomeryForm(montgomerizedA); - - var aequalsZero = cryptoMath.isZero(curve.a); - - var one = cryptoMath.One; - - var onemontgomery = createArray(fieldElementWidth); - onemontgomery[0] = 1; - montgomeryMultiplier.convertToMontgomeryForm(onemontgomery); - - var group = cryptoMath.IntegerGroup(cryptoMath.digitsToBytes(montgomeryMultiplier.m), true); - - var temp0 = createArray(fieldElementWidth); - var temp1 = createArray(fieldElementWidth); - var temp2 = createArray(fieldElementWidth); - var temp3 = createArray(fieldElementWidth); - var temp4 = createArray(fieldElementWidth); - var temp5 = createArray(fieldElementWidth); - var temp6 = createArray(fieldElementWidth); - var temp7 = createArray(fieldElementWidth); - var swap0 = createArray(fieldElementWidth); - - var conversionTemp0 = createArray(fieldElementWidth); - var conversionTemp1 = createArray(fieldElementWidth); - var conversionTemp2 = createArray(fieldElementWidth); - - function modSub(left, right, result) { - var resultElement = group.createElementFromInteger(0); - resultElement.m_digits = result; - group.subtract( - group.createElementFromDigits(left), - group.createElementFromDigits(right), - resultElement); - } - - function modAdd(left, right, result) { - var resultElement = group.createElementFromInteger(0); - resultElement.m_digits = result; - group.add( - group.createElementFromDigits(left), - group.createElementFromDigits(right), - resultElement); - } - - function modInv(number, result) { - cryptoMath.modInv(number, m_curve.p, result); - } - - function modDivByTwo(dividend, result) { - - var s = dividend.length; - - var modulus = curve.p; - - if ((dividend[0] & 0x1) === 0x1) { - var carry = 0; - - for (var i = 0; i < s; i += 1) { - carry += dividend[i] + modulus[i]; - result[i] = carry & cryptoMath.DIGIT_MASK; - carry = carry >>> cryptoMath.DIGIT_BITS; - } - - carry = carry << cryptoMath.DIGIT_BITS - 1; - - cryptoMath.shiftRight(result, result); - - result[s - 1] |= carry; - } else { - cryptoMath.shiftRight(dividend, result); - } - - } - - function montgomeryMultiply(left, right, result) { - montgomeryMultiplier.montgomeryMultiply( - left, - right, - result); - } - - function montgomerySquare(left, result) { - montgomeryMultiplier.montgomeryMultiply( - left, - left, - result); - } - - function correctInversion(digits) { - var results = createArray(digits.length); - montgomeryMultiply(digits, montgomeryMultiplier.rCubedModm, results); - for (var i = 0; i < results.length; i += 1) { - digits[i] = results[i]; - } - } - - function doubleAequalsNeg3(point, outputPoint) { - if (point.isInfinity) { - outputPoint.isInfinity = true; - return; - } - - montgomerySquare(point.z, temp1); - - montgomeryMultiply(point.z, point.y, temp4); - - modAdd(point.x, temp1, temp2); - - modSub(point.x, temp1, temp1); - - outputPoint.z = temp4.slice(); - - montgomeryMultiply(temp1, temp2, temp3); - - modDivByTwo(temp3, temp2); - - modAdd(temp3, temp2, temp1); - - montgomerySquare(point.y, temp2); - - montgomerySquare(temp1, temp4); - - montgomeryMultiply(point.x, temp2, temp3); - - modSub(temp4, temp3, temp4); - - modSub(temp4, temp3, outputPoint.x); - - modSub(temp3, outputPoint.x, temp4); - - montgomerySquare(temp2, temp3); - - montgomeryMultiply(temp1, temp4, temp2); - - modSub(temp2, temp3, outputPoint.y); - - outputPoint.isInfinity = false; - outputPoint.isInMontgomeryForm = true; - } - - function doubleAequals0(point, outputPoint) { - if (point.isInfinity) { - outputPoint.isInfinity = true; - return; - } - - montgomerySquare(point.y, temp3); - - montgomerySquare(point.x, temp4); - - modAdd(temp4, temp4, temp0); - modAdd(temp0, temp4, temp4); - - montgomeryMultiply(point.x, temp3, temp5); - - montgomerySquare(temp3, temp0); - - modDivByTwo(temp4, temp1); - - montgomerySquare(temp1, temp3); - - montgomeryMultiply(point.y, point.z, swap0); - for (var i = 0; i < swap0.length; i += 1) { - outputPoint.z[i] = swap0[i]; - } - - modSub(temp3, temp5, outputPoint.x); - modSub(outputPoint.x, temp5, outputPoint.x); - - modSub(temp5, outputPoint.x, temp4); - - montgomeryMultiply(temp1, temp4, temp2); - - modSub(temp2, temp0, outputPoint.y); - - outputPoint.isInfinity = false; - outputPoint.isInMontgomeryForm = true; - } - - function generatePrecomputationTable(w, generatorPoint) { - var validationPoint = generatorPoint.clone(); - convertToStandardForm(validationPoint); - if (!validatePoint(validationPoint)) { - throw new Error("Invalid Parameter"); - } - - var pointJac = generatorPoint.clone(); - convertToJacobianForm(pointJac); - - var tablePos = [generatorPoint.clone()]; - - var qJac = pointJac.clone(); - - var px2 = pointJac.clone(); - double(pointJac, px2); - convertToAffineForm(px2); - - var qAff; - - for (var i = 1; i < Math.pow(2, w - 2); i++) { - - mixedAdd(qJac, px2, qJac); - - qAff = qJac.clone(); - convertToAffineForm(qAff); - - tablePos[i] = qAff; - } - - return tablePos; - } - - function double(point, outputPoint) { - if (typeof point === "undefined") { - throw new Error("point undefined"); - } - if (typeof outputPoint === "undefined") { - throw new Error("outputPoint undefined"); - } - - if (point.isAffine) { - throw new Error("Given point was in Affine form. Use convertToJacobian() first."); - } - - if (!point.isInMontgomeryForm) { - throw new Error("Given point must be in Montgomery form. Use montgomeryize() first."); - } - if (aequalsZero) { - doubleAequals0(point, outputPoint); - } else { - doubleAequalsNeg3(point, outputPoint); - } - - } - - function mixedDoubleAdd(jacobianPoint, affinePoint, outputPoint) { - if (jacobianPoint.isInfinity) { - affinePoint.copy(outputPoint); - this.convertToJacobianForm(outputPoint); - return; - } - - if (affinePoint.isInfinity) { - jacobianPoint.copy(outputPoint); - return; - } - - montgomerySquare(jacobianPoint.z, temp5); - - montgomeryMultiply(jacobianPoint.z, temp5, temp6); - - montgomeryMultiply(affinePoint.x, temp5, temp4); - - montgomeryMultiply(affinePoint.y, temp6, temp5); - - modSub(temp4, jacobianPoint.x, temp1); - - modSub(temp5, jacobianPoint.y, temp2); - - if (cryptoMath.isZero(temp1)) { - if (cryptoMath.isZero(temp2)) { - double(jacobianPoint, outputPoint); - mixedAdd(outputPoint, affinePoint, outputPoint); - return; - } else { - outputPoint.x = jacobianPoint.x.slice(0); - outputPoint.y = jacobianPoint.y.slice(0); - outputPoint.z = jacobianPoint.z.slice(0); - return; - } - } - - montgomerySquare(temp2, temp4); - - montgomerySquare(temp1, temp6); - - montgomeryMultiply(temp6, jacobianPoint.x, temp5); - - montgomeryMultiply(temp1, temp6, temp0); - - modSub(temp4, temp5, temp3); - modSub(temp3, temp5, temp3); - - montgomeryMultiply(jacobianPoint.z, temp1, temp4); - - modSub(temp3, temp5, temp3); - - montgomeryMultiply(temp0, jacobianPoint.y, temp6); - - modSub(temp3, temp0, temp3); - - if (cryptoMath.isZero(temp3)) { - for (i = 0; i < outputPoint.x.length; i++) { - outputPoint.x[i] = 0; - outputPoint.y[i] = 0; - outputPoint.z[i] = 0; - } - outputPoint.y[0] = 1; - return; - } - - modAdd(temp6, temp6, temp1); - - montgomeryMultiply(temp4, temp3, outputPoint.z); - - montgomeryMultiply(temp2, temp3, temp4); - - montgomerySquare(temp3, temp0); - - modAdd(temp1, temp4, temp1); - - montgomeryMultiply(temp0, temp5, temp4); - - montgomerySquare(temp1, temp7); - - montgomeryMultiply(temp0, temp3, temp5); - - modSub(temp7, temp4, outputPoint.x); - modSub(outputPoint.x, temp4, outputPoint.x); - - modSub(outputPoint.x, temp5, outputPoint.x); - - modSub(outputPoint.x, temp4, temp3); - - montgomeryMultiply(temp5, temp6, temp0); - - montgomeryMultiply(temp1, temp3, temp4); - - modSub(temp4, temp0, outputPoint.y); - - outputPoint.isInfinity = false; - outputPoint.isInMontgomeryForm = true; - - } - - function mixedAdd(jacobianPoint, affinePoint, outputPoint) { - if (jacobianPoint === null) { - throw new Error("jacobianPoint"); - } - - if (affinePoint === null) { - throw new Error("affinePoint"); - } - - if (outputPoint === null) { - throw new Error("outputPoint"); - } - - if (jacobianPoint.curve !== affinePoint.curve || - jacobianPoint.curve !== outputPoint.curve) { - throw new Error("All points must be from the same curve object."); - } - - if (jacobianPoint.isAffine) { - throw new Error( - "Given jacobianPoint was in Affine form. Use ConvertToJacobian()\ - before calling DoubleJacobianAddAffinePoints()."); - } - - if (!affinePoint.isAffine) { - throw new Error( - "Given affinePoint was in Jacobian form. Use ConvertToAffine() before \ - calling DoubleJacobianAddAffinePoints()."); - } - - if (outputPoint.isAffine) { - throw new Error( - "Given jacobianPoint was in Jacobian form. Use ConvertToJacobian() before \ - calling DoubleJacobianAddAffinePoints()."); - } - - if (!jacobianPoint.isInMontgomeryForm) { - throw new Error("Jacobian point must be in Montgomery form"); - } - - if (!affinePoint.isInMontgomeryForm) { - throw new Error("Affine point must be in Montgomery form"); - } - - if (jacobianPoint.isInfinity) { - affinePoint.copy(outputPoint); - this.convertToJacobianForm(outputPoint); - return; - } - - if (affinePoint.isInfinity) { - jacobianPoint.copy(outputPoint); - return; - } - - montgomerySquare(jacobianPoint.z, temp1); - - montgomeryMultiply(temp1, jacobianPoint.z, temp2); - - montgomeryMultiply(temp1, affinePoint.x, temp3); - - montgomeryMultiply(temp2, affinePoint.y, temp4); - - modSub(temp3, jacobianPoint.x, temp1); - - modSub(temp4, jacobianPoint.y, temp2); - - var i; - for (i = 0; i < temp1.length; i += 1) { - if (temp1[i] !== 0) { - - montgomeryMultiply(jacobianPoint.z, temp1, temp0); - for (var j = 0; j < fieldElementWidth; j += 1) { - outputPoint.z[j] = temp0[j]; - } - - montgomerySquare(temp1, temp3); - - montgomeryMultiply(temp3, temp1, temp4); - - montgomeryMultiply(temp3, jacobianPoint.x, temp5); - - modAdd(temp5, temp5, temp1); - - montgomerySquare(temp2, outputPoint.x); - - modSub(outputPoint.x, temp1, outputPoint.x); - - modSub(outputPoint.x, temp4, outputPoint.x); - - modSub(temp5, outputPoint.x, temp3); - - montgomeryMultiply(temp2, temp3, temp5); - - montgomeryMultiply(jacobianPoint.y, temp4, temp6); - - modSub(temp5, temp6, outputPoint.y); - - outputPoint.isInfinity = false; - outputPoint.isInMontgomeryForm = true; - - return; - } - } - - for (i = 0; i < temp2.length; i += 1) { - if (temp2[i] !== 0) { - outputPoint.isInfinity = true; - outputPoint.isInMontgomeryForm = true; - return; - } - } - affinePoint.copy(outputPoint); - this.convertToJacobianForm(outputPoint); - this.double(outputPoint, outputPoint); - outputPoint.isInMontgomeryForm = true; - - } - - function scalarMultiply(k, point, outputPoint, multiplyBy4) { - if (point.isInfinity || cryptoMath.isZero(k)) { - outputPoint.isInfinity = true; - return; - } - - if (cryptoMath.compareDigits(k, curve.order) >= 0) { - throw new Error("The scalar k must be in the range 1 <= k < order."); - } - - k = k.slice(); - - if (point.curve.type === 1) { - - var pointIsEP = typeof point.ta !== "undefined"; - - if (!pointIsEP) { - convertToExtendedProjective(point); - } - - scalarMultiplyTed(k, point, outputPoint, multiplyBy4); - - if (!pointIsEP) { - normalizeTed(point); - } - - } else { - - var pointIsMF = point.isInMontgomeryForm, - outputIsMF = outputPoint.isInMontgomeryForm, - outputIsAffine = outputPoint.isAffine; - - if (!pointIsMF) { - convertToMontgomeryForm(point); - } - - if (!outputIsMF) { - convertToMontgomeryForm(outputPoint); - } - - scalarMultiplyW(k, point, outputPoint); - - if (outputIsAffine) { - convertToAffineForm(outputPoint); - } - - if (!pointIsMF) { - convertToStandardForm(point); - } - - if (!outputIsMF) { - convertToStandardForm(outputPoint); - } - } - - return; - - } - - function scalarMultiplyW(k, point, outputPoint) { - var validationPoint = point.clone(); - convertToStandardForm(validationPoint); - - if (!validatePoint(validationPoint)) { - throw new Error("Invalid Parameters."); - } - - var odd = k[0] & 1, - tempk = []; - - modSub(point.curve.order, k, tempk); - for (i = 0; i < k.length; i++) { - k[i] = odd - 1 & (k[i] ^ tempk[i]) ^ k[i]; - } - - var w = fieldElementWidth <= 8 ? 5 : 6; - var m = point.curve.p.length * cryptoMath.DIGIT_BITS; - var t = Math.ceil(m / (w - 1)); - - var kDigits = cryptoMath.fixedWindowRecode(k, w, t); - - var Tm = generatePrecomputationTable(w, point); - - var position = - Math.floor(Math.abs(kDigits[t]) - 1) / 2; - - var Q = Tm[position].clone(); - convertToJacobianForm(Q); - - for (var i = t - 1; i >= 0; i--) { - - for (var j = 0; j < w - 2; j++) { - double(Q, Q); - } - - position = Math.floor((Math.abs(kDigits[i]) - 1) / 2); - - var L = tableLookupW(Tm, position); - - modSub(L.curve.p, L.y, tempk); - var mask = -(kDigits[i] >>> 31); - for (var n = 0; n < L.y.length; n++) { - L.y[n] = (L.y[n] & ~mask) | (tempk[n] & mask); - } - - mixedDoubleAdd(Q, L, Q); - - } - - modSub(point.curve.p, Q.y, tempk); - for (i = 0; i < Q.y.length; i++) { - Q.y[i] = odd - 1 & (Q.y[i] ^ tempk[i]) ^ Q.y[i]; - } - - Q.copy(outputPoint); - - return; - - } - - function tableLookupW(table, index) { - - var mask, - L; - - for (var i = 0; i < table.length; i++) { - mask = +(i === index); - L = [L, table[i].clone()][mask]; - } - - return L; - } - - function tableLookupW0(table, index) { - - var pos = (index + 1) % table.length; - - for (var i = 0; i < table.length; i++) { - var L = table[pos].clone(); - pos = (pos + 1) % table.length; - } - - return L; - } - - function negate(point, outputPoint) { - if (point !== outputPoint) { - point.copy(outputPoint); - } - modSub(point.curve.p, point.y, outputPoint.y); - } - - function convertToMontgomeryForm(point) { - if (point.isInMontgomeryForm) { - throw new Error("The given point is already in Montgomery form."); - } - - if (!point.isInfinity) { - montgomeryMultiplier.convertToMontgomeryForm(point.x); - montgomeryMultiplier.convertToMontgomeryForm(point.y); - - if (point.z !== null) { - montgomeryMultiplier.convertToMontgomeryForm(point.z); - } - - if (typeof point.ta !== "undefined") { - montgomeryMultiplier.convertToMontgomeryForm(point.ta); - montgomeryMultiplier.convertToMontgomeryForm(point.tb); - } - } - - point.isInMontgomeryForm = true; - } - - function convertToStandardForm(point) { - if (!point.isInMontgomeryForm) { - throw new Error("The given point is not in montgomery form."); - } - - if (!point.isInfinity) { - montgomeryMultiplier.convertToStandardForm(point.x); - montgomeryMultiplier.convertToStandardForm(point.y); - if (point.z !== null) { - montgomeryMultiplier.convertToStandardForm(point.z); - } - if (typeof point.ta !== "undefined") { - montgomeryMultiplier.convertToStandardForm(point.ta); - montgomeryMultiplier.convertToStandardForm(point.tb); - } - } - - point.isInMontgomeryForm = false; - - } - - function convertToAffineForm(point) { - if (point.isInfinity) { - point.z = null; - setterSupport || (point.isAffine = true); - return; - } - - cryptoMath.modInv(point.z, curve.p, conversionTemp2, true); - - if (point.isInMontgomeryForm) { - montgomeryMultiply(conversionTemp2, montgomeryMultiplier.rCubedModm, conversionTemp1); - var swap = conversionTemp2; - conversionTemp2 = conversionTemp1; - conversionTemp1 = swap; - } - - montgomerySquare(conversionTemp2, conversionTemp0); - - montgomeryMultiply(point.x, conversionTemp0, conversionTemp1); - for (var i = 0; i < fieldElementWidth; i += 1) { - point.x[i] = conversionTemp1[i]; - } - - montgomeryMultiply(point.y, conversionTemp0, conversionTemp1); - montgomeryMultiply(conversionTemp1, conversionTemp2, point.y); - - point.z = null; - - delete point.ta; - delete point.tb; - - setterSupport || (point.isAffine = true); - } - - function convertToJacobianForm(point) { - if (!point.isAffine) { - throw new Error("The given point is not in Affine form."); - } - - setterSupport || (point.isAffine = false); - - var clonedDigits, - i, - zOne = point.isInMontgomeryForm ? onemontgomery : one; - - clonedDigits = createArray(zOne.length); - for (i = 0; i < zOne.length; i += 1) { - clonedDigits[i] = zOne[i]; - } - - point.z = clonedDigits; - - return; - } - - function validatePoint(point) { - if (point.isInfinity) { - return false; - } - - cryptoMath.modMul(point.y, point.y, point.curve.p, temp1); - - cryptoMath.modMul(point.x, point.x, point.curve.p, temp2); - cryptoMath.modMul(point.x, temp2, point.curve.p, temp3); - modAdd(temp3, point.curve.b, temp2); - cryptoMath.modMul(point.x, point.curve.a, point.curve.p, temp3); - modAdd(temp2, temp3, temp2); - modSub(temp1, temp2, temp1); - - if (cryptoMath.isZero(temp1) === false) { - return false; - } - - return true; - } - - function validatePointTed(point) { - - if (point.ta) { - point = point.clone(); - normalizeTed(point); - } - - cryptoMath.modMul(point.y, point.y, point.curve.p, temp3); - cryptoMath.modMul(point.x, point.x, point.curve.p, temp2); - - cryptoMath.add(temp2, temp3, temp1); - cryptoMath.reduce(temp4, point.curve.p, temp4); - - cryptoMath.modMul(temp2, temp3, point.curve.p, temp4); - cryptoMath.modMul(point.curve.d, temp4, point.curve.p, temp3); - - cryptoMath.add(temp3, [1], temp2); - cryptoMath.reduce(temp2, point.curve.p, temp2); - - cryptoMath.subtract(temp1, temp2, temp1); - - if (cryptoMath.isZero(temp1) === false) { - cryptoMath.reduce(temp1, point.curve.p, temp1); - if (cryptoMath.isZero(temp1) === false) { - return false; - } - } - - return true; - } - - function generatePrecomputationTableTed(npoints, point) { - - var Q = point.clone(), - P2 = Q.clone(), - T = []; - - T[0] = convert_R1_to_R2(point); - doubleTed(Q, Q); - P2 = convert_R1_to_R2(Q); - Q = point.clone(); - - for (var i = 1; i < npoints; i++) { - addTedExtended(P2, Q, Q); - T[i] = convert_R1_to_R2(Q); - } - - return T; - } - - function convertToExtendedProjective(affinePoint) { - affinePoint.ta = affinePoint.x.slice(); - affinePoint.tb = affinePoint.y.slice(); - affinePoint.z = [1]; - } - - function scalarMultiplyTed(k, point, outputPoint, multiplyBy4) { - - if (!validatePointTed(point)) { - throw new Error("Invalid Parameter"); - } - - var rbits = point.curve.rbits; - multiplyBy4 = typeof multiplyBy4 === "undefined" ? true : multiplyBy4; - - var w = fieldElementWidth <= 8 ? 5 : 6; - - var t = Math.floor((rbits + (w - 2)) / (w - 1)); - var i, j; - - k = k.slice(); - - var T = point.clone(); - - convertToExtendedProjective(T); - - if (multiplyBy4) { - doubleTed(T, T); - doubleTed(T, T); - } - - var precomputationTable = generatePrecomputationTableTed(1 << w - 2, T); - - var odd = k[0] & 1, - tempk = [], - kisNeg; - - modSub(point.curve.order, k, tempk); - for (i = 0; i < k.length; i++) { - k[i] = odd - 1 & (k[i] ^ tempk[i]) ^ k[i]; - } - - var kDigits = cryptoMath.fixedWindowRecode(k, w, t); - - var position = - Math.floor(Math.abs(kDigits[t]) - 1) / 2; - - var R = precomputationTable[position]; - - T.x = R.x.slice(); - T.y = R.y.slice(); - T.z = R.z.slice(); - - for (i = t - 1; i >= 0; i--) { - - for (j = 0; j < w - 1; j++) { - doubleTed(T, T); - } - - position = Math.floor((Math.abs(kDigits[i]) - 1) / 2); - - var L = tableLookupTed(precomputationTable, position); - - var mask = -(kDigits[i] >>> 31); - - modSub(point.curve.p, L.x, tempk); - for (var m = 0; m < L.x.length; m++) { - L.x[m] = (L.x[m] & ~mask) | (tempk[m] & mask); - } - - modSub(point.curve.p, L.td, tempk); - for (m = 0; m < L.td.length; m++) { - L.td[m] = (L.td[m] & ~mask) | (tempk[m] & mask); - } - - addTedExtended(L, T, T); - } - - modSub(point.curve.p, T.x, tempk); - for (i = 0; i < T.x.length; i++) { - T.x[i] = odd - 1 & (T.x[i] ^ tempk[i]) ^ T.x[i]; - } - - normalizeTed(T); - - outputPoint.x = T.x.slice(); - outputPoint.y = T.y.slice(); - - return; - - } - - function tableLookupTed(table, index) { - - var pos = (index + 1) % table.length; - - for (var i = 0; i < table.length; i++) { - var L = { - x: table[pos].x.slice(), - y: table[pos].y.slice(), - z: table[pos].z.slice(), - td: table[pos].td.slice() - }; - pos = (pos + 1) % table.length; - } - - return L; - } - - function normalizeTed(point) { - - cryptoMath.modInv(point.z, curve.p, conversionTemp2, true); - - cryptoMath.modMul(point.x, conversionTemp2, curve.p, point.x); - - cryptoMath.modMul(point.y, conversionTemp2, curve.p, point.y); - - delete point.ta; - delete point.tb; - - point.z = null; - - return; - } - - function doubleTed(point, outputPoint) { - - if (typeof point.ta === "undefined") { - throw new Error("Point should be in Extended Projective form."); - } - - cryptoMath.modMul(point.x, point.x, point.curve.p, temp0); - - cryptoMath.modMul(point.y, point.y, point.curve.p, temp1); - - cryptoMath.modMul(point.z, point.z, point.curve.p, point.ta); - modSub(temp1, temp0, outputPoint.tb); - modAdd(temp0, temp1, temp0); - - modAdd(point.ta, point.ta, point.ta); - - modAdd(point.y, point.y, point.y); - - modSub(point.ta, temp0, temp1); - - cryptoMath.modMul(point.x, point.y, point.curve.p, outputPoint.ta); - - cryptoMath.modMul(temp0, outputPoint.tb, point.curve.p, outputPoint.y); - - cryptoMath.modMul(temp1, outputPoint.ta, point.curve.p, outputPoint.x); - - cryptoMath.modMul(temp0, temp1, point.curve.p, outputPoint.z); - - return; - } - - function addTed(point1, point2, outputPoint) { - - var cm = cryptoMath; - - if (typeof point1.ta === "undefined") { - throw new Error("Point1 should be in Extended Projective form."); - } - - if (typeof point2.ta === "undefined") { - throw new Error("Point2 should be in Extended Projective form."); - } - var qq = convert_R1_to_R2(point1); - - addTedExtended(qq, point2, outputPoint); - - return; - } - - function convert_R1_to_R2(point) { - - var curve = point.curve, - modulus = curve.p, - qq = { - x: point.x.slice(), - y: point.y.slice(), - z: point.z.slice(), - td: [], - curve: point.curve - }; - - cryptoMath.modMul(point.ta, point.tb, modulus, conversionTemp0); - - cryptoMath.modMul(conversionTemp0, curve.d, modulus, qq.td); - - return qq; - } - - function addTedExtended(qq, point2, outputPoint) { - - var cm = cryptoMath; - var modulus = point2.curve.p; - - temp1 = []; - temp2 = []; - temp3 = []; - - cm.modMul(point2.z, qq.z, modulus, temp3); - - cm.modMul(point2.ta, point2.tb, modulus, temp1); - - modAdd(point2.x, point2.y, point2.ta); - - cm.modMul(temp1, qq.td, modulus, temp2); - - modAdd(qq.x, qq.y, point2.tb); - - modSub(temp3, temp2, temp1); - - modAdd(temp3, temp2, temp3); - - cm.modMul(point2.ta, point2.tb, modulus, temp2); - - cm.modMul(point2.x, qq.x, modulus, point2.z); - - cm.modMul(point2.y, qq.y, modulus, point2.x); - - modSub(temp2, point2.z, temp2); - - modSub(point2.x, point2.z, outputPoint.ta); - - modSub(temp2, point2.x, outputPoint.tb); - - cm.modMul(outputPoint.ta, temp3, modulus, outputPoint.y); - - cm.modMul(outputPoint.tb, temp1, modulus, outputPoint.x); - - cm.modMul(temp3, temp1, modulus, outputPoint.z); - - return; - } - - function convertTedToWeierstrass(tedPoint, wPoint) { - var a = tedPoint.curve.a.slice(), - d = tedPoint.curve.d.slice(), - p = tedPoint.curve.p, - modMul = cryptoMath.modMul, - modInv = cryptoMath.modInv; - - temp1 = [5]; - - modMul(a, temp1, p, temp2); - - modSub(temp2, d, temp2); - - modMul(d, temp1, p, temp3); - - modSub(a, temp3, temp1); - - modMul(tedPoint.y, temp1, p, temp3); - - modAdd(temp3, temp2, temp2); - - temp1 = [1]; - - modSub(temp1, tedPoint.y, temp3); - - temp1 = [12]; - - modMul(temp1, temp3, p, temp4); - - modInv(temp4, p, temp4, true); - - modMul(tedPoint.x, temp3, p, temp1); - - modAdd(temp1, temp1, temp3); - - modAdd(temp3, temp3, temp3); - - modInv(temp3, p, temp3, true); - - modMul(temp4, temp2, p, wPoint.x); - - temp1 = [1]; - - modAdd(tedPoint.y, temp1, temp1); - - modSub(a, d, temp2); - - modMul(temp1, temp2, p, temp4); - - modMul(temp4, temp3, p, wPoint.y); - - return; - } - - function convertWeierstrassToTed(wPoint, tedPoint) { - - var a = tedPoint.curve.a.slice(), - d = tedPoint.curve.d.slice(), - p = tedPoint.curve.p, - modMul = cryptoMath.modMul, - modInv = cryptoMath.modInv; - - modAdd(wPoint.x, wPoint.x, temp1); - - modAdd(wPoint.x, temp1, temp1); - - modAdd(temp1, temp1, temp1); - - modSub(temp1, a, temp2); - - modSub(temp2, d, temp2); - - modAdd(wPoint.y, wPoint.y, temp3); - - modAdd(wPoint.y, temp3, temp3); - - modAdd(temp3, temp3, temp3); - - modInv(temp3, p, temp3, true); - - modMul(temp2, temp3, p, tedPoint.x); - - modAdd(temp1, temp1, temp1); - - modAdd(temp1, d, temp2); - - modAdd(temp1, a, temp1); - - modAdd(a, a, temp3); - - modSub(temp2, temp3, temp2); - - modSub(temp2, temp3, temp2); - - modSub(temp2, a, temp2); - - modAdd(d, d, temp3); - - modSub(temp1, temp3, temp1); - - modSub(temp1, temp3, temp1); - - modSub(temp1, d, temp1); - - modInv(temp1, p, temp1, true); - - modMul(temp1, temp2, p, tedPoint.y); - - return; - } - - var methods = { - - convertToMontgomeryForm: convertToMontgomeryForm, - - convertToStandardForm: convertToStandardForm, - - convertToAffineForm: convertToAffineForm, - - convertToJacobianForm: convertToJacobianForm, - - generatePrecomputationTable: function(w, generatorPoint) { - return generatePrecomputationTable(w, generatorPoint); - } - - }; - - if (tedCurve) { - - methods.double = doubleTed; - methods.add = addTed; - methods.scalarMultiply = scalarMultiply; - methods.normalize = normalizeTed; - methods.convertToExtendedProjective = convertToExtendedProjective; - methods.convertTedToWeierstrass = convertTedToWeierstrass; - methods.convertWeierstrassToTed = convertWeierstrassToTed; - methods.validatePoint = validatePointTed; - methods.generatePrecomputationTable = function(w, generatorPoint) { - return generatePrecomputationTableTed(w, generatorPoint); - }; - } else { - - methods.double = double; - methods.mixedDoubleAdd = mixedDoubleAdd; - methods.mixedAdd = mixedAdd; - methods.scalarMultiply = scalarMultiply; - methods.negate = negate; - methods.validatePoint = validatePoint; - } - - return methods; - - }; - - var sec1EncodingFp = function() { - return { - encodePoint: function(point) { - if (!point) { - throw new Error("point"); - } - - if (!point.isAffine) { - throw new Error("Point must be in affine form."); - } - - if (point.isInMontgomeryForm) { - throw new Error("Point must not be in Montgomery form."); - } - - if (point.isInfinity) { - return createArray(1); - } else { - var xOctetString = cryptoMath.digitsToBytes(point.x); - var yOctetString = cryptoMath.digitsToBytes(point.y); - var pOctetString = cryptoMath.digitsToBytes(point.curve.p); - var mlen = pOctetString.length; - if (mlen < xOctetString.length || mlen < yOctetString.length) { - throw new Error("Point coordinate(s) are bigger than the field order."); - } - var output = createArray(2 * mlen + 1); - - output[0] = 0x04; - var offset = mlen - xOctetString.length; - for (var i = 0; i < xOctetString.length; i++) { - output[i + 1 + offset] = xOctetString[i]; - } - offset = mlen - yOctetString.length; - for (i = 0; i < yOctetString.length; i++) { - output[mlen + i + 1 + offset] = yOctetString[i]; - } - - return output; - } - - }, - decodePoint: function(encoded, curve) { - if (encoded.length < 1) { - throw new Error("Byte array must have non-zero length"); - } - - var pOctetString = cryptoMath.digitsToBytes(curve.p); - var mlen = pOctetString.length; - - if (encoded[0] === 0x0 && encoded.length === 1) { - return curve.createPointAtInfinity(); - } else if (encoded[0] === 0x04 && encoded.length === 1 + 2 * mlen) { - var xbytes = createArray(mlen); - var ybytes = createArray(mlen); - - for (var i = 0; i < mlen; i++) { - xbytes[i] = encoded[i + 1]; - ybytes[i] = encoded[mlen + i + 1]; - } - - var x = cryptoMath.bytesToDigits(xbytes); - var y = cryptoMath.bytesToDigits(ybytes); - - return EllipticCurvePointFp(curve, false, x, y); - } else { - throw new Error("Unsupported encoding format"); - } - } - }; - }; - - var ModularSquareRootSolver = function(modulus) { - var p = modulus; - - var specialK = []; - - if (typeof modulus === "undefined") { - throw new Error("modulus"); - } - - if (cryptoMath.isEven(modulus)) { - throw new Error("Only odd moduli are supported"); - } - - var mul = cryptoMath.MontgomeryMultiplier(p); - - if (p[0] % 4 === 3) { - cryptoMath.add(p, cryptoMath.One, specialK); - cryptoMath.shiftRight(specialK, specialK, 2); - } else { - specialK = null; - } - - var temp0 = new Array(p.length); - var temp1 = new Array(p.length); - - function squareRootNistCurves(a) { - var beta = cryptoMath.intToDigits(0, 16); - mul.modExp(a, specialK, beta); - - var aPrime = [0]; - cryptoMath.modMul(beta, beta, mul.m, aPrime); - - if (cryptoMath.compareDigits(a, aPrime) !== 0) { - return null; - } - - return beta; - } - - var publicMethods = { - - squareRoot: function(a) { - if (specialK !== null) { - return squareRootNistCurves(a); - } else { - throw new Error("GeneralCase not supported."); - } - }, - - jacobiSymbol: function(a) { - var modEightMask = 0x7, - modFourMask = 0x3, - aPrime, - pPrime; - - aPrime = a.slice(); - pPrime = p.slice(); - - cryptoMath.reduce(aPrime, pPrime, aPrime, temp0, temp1); - - var t = 1; - - while (!cryptoMath.isZero(aPrime)) { - while (cryptoMath.isEven(aPrime)) { - cryptoMath.shiftRight(aPrime, aPrime); - - var pMod8 = pPrime[0] & modEightMask; - if (pMod8 === 3 || pMod8 === 5) { - t = -t; - } - } - - var tmp = aPrime; - aPrime = pPrime; - pPrime = tmp; - - var aMod4 = aPrime[0] & modFourMask; - var pMod4 = pPrime[0] & modFourMask; - if (aMod4 === 3 && pMod4 === 3) { - t = -t; - } - - cryptoMath.reduce(aPrime, pPrime, aPrime, temp0, temp1); - } - - if (cryptoMath.compareDigits(pPrime, cryptoMath.One) === 0) { - return t; - } else { - return 0; - } - } - - }; - - return publicMethods; - }; - - var curvesInternal = {}; - - var createCurve = function(curveName) { - - var curveData = curvesInternal[curveName.toUpperCase()]; - - if (!curveData) { - throw new Error(curveName + " Unsupported curve."); - } - - if (curveData.type === 0) { - return createWeierstrassCurve(curveData); - } - - if (curveData.type === 1) { - return createTedCurve(curveData); - } - - throw new Error(curveName + " Unsupported curve type."); - }; - - var validateEccPoint = function(curveName, x, y, z) { - var curve = createCurve(curveName); - var point = new EllipticCurvePointFp(curve, false, btd(x), btd(y), z && btd(z), false); - var opp = new EllipticCurveOperatorFp(curve); - return opp.validatePoint(point); - }; - - return { - createCurve: createCurve, - curves: curvesInternal, - sec1EncodingFp: sec1EncodingFp, - validatePoint: validateEccPoint, - EllipticCurvePointFp: EllipticCurvePointFp, - EllipticCurveOperatorFp: EllipticCurveOperatorFp, - ModularSquareRootSolver: ModularSquareRootSolver - }; - } - - var cryptoECC = cryptoECC || MsrcryptoECC(); - - var curve_P256 = { - name: "P-256", - type: 0, - p: [0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], - a: [0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC], - b: [0x5A, 0xC6, 0x35, 0xD8, 0xAA, 0x3A, 0x93, 0xE7, 0xB3, 0xEB, 0xBD, 0x55, 0x76, 0x98, 0x86, 0xBC, 0x65, 0x1D, 0x06, 0xB0, 0xCC, 0x53, 0xB0, 0xF6, 0x3B, 0xCE, 0x3C, 0x3E, 0x27, 0xD2, 0x60, 0x4B], - order: [0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, 0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51], - gx: [0x6B, 0x17, 0xD1, 0xF2, 0xE1, 0x2C, 0x42, 0x47, 0xF8, 0xBC, 0xE6, 0xE5, 0x63, 0xA4, 0x40, 0xF2, 0x77, 0x03, 0x7D, 0x81, 0x2D, 0xEB, 0x33, 0xA0, 0xF4, 0xA1, 0x39, 0x45, 0xD8, 0x98, 0xC2, 0x96], - gy: [0x4F, 0xE3, 0x42, 0xE2, 0xFE, 0x1A, 0x7F, 0x9B, 0x8E, 0xE7, 0xEB, 0x4A, 0x7C, 0x0F, 0x9E, 0x16, 0x2B, 0xCE, 0x33, 0x57, 0x6B, 0x31, 0x5E, 0xCE, 0xCB, 0xB6, 0x40, 0x68, 0x37, 0xBF, 0x51, 0xF5], - cf: 1 - }; - - var curve_P384 = { - name: "P-384", - type: 0, - p: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF], - a: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFC], - b: [0xB3, 0x31, 0x2F, 0xA7, 0xE2, 0x3E, 0xE7, 0xE4, 0x98, 0x8E, 0x05, 0x6B, 0xE3, 0xF8, 0x2D, 0x19, 0x18, 0x1D, 0x9C, 0x6E, 0xFE, 0x81, 0x41, 0x12, 0x03, 0x14, 0x08, 0x8F, 0x50, 0x13, 0x87, 0x5A, 0xC6, 0x56, 0x39, 0x8D, 0x8A, 0x2E, 0xD1, 0x9D, 0x2A, 0x85, 0xC8, 0xED, 0xD3, 0xEC, 0x2A, 0xEF], - order: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC7, 0x63, 0x4D, 0x81, 0xF4, 0x37, 0x2D, 0xDF, 0x58, 0x1A, 0x0D, 0xB2, 0x48, 0xB0, 0xA7, 0x7A, 0xEC, 0xEC, 0x19, 0x6A, 0xCC, 0xC5, 0x29, 0x73], - gx: [0xAA, 0x87, 0xCA, 0x22, 0xBE, 0x8B, 0x05, 0x37, 0x8E, 0xB1, 0xC7, 0x1E, 0xF3, 0x20, 0xAD, 0x74, 0x6E, 0x1D, 0x3B, 0x62, 0x8B, 0xA7, 0x9B, 0x98, 0x59, 0xF7, 0x41, 0xE0, 0x82, 0x54, 0x2A, 0x38, 0x55, 0x02, 0xF2, 0x5D, 0xBF, 0x55, 0x29, 0x6C, 0x3A, 0x54, 0x5E, 0x38, 0x72, 0x76, 0x0A, 0xB7], - gy: [0x36, 0x17, 0xDE, 0x4A, 0x96, 0x26, 0x2C, 0x6F, 0x5D, 0x9E, 0x98, 0xBF, 0x92, 0x92, 0xDC, 0x29, 0xF8, 0xF4, 0x1D, 0xBD, 0x28, 0x9A, 0x14, 0x7C, 0xE9, 0xDA, 0x31, 0x13, 0xB5, 0xF0, 0xB8, 0xC0, 0x0A, 0x60, 0xB1, 0xCE, 0x1D, 0x7E, 0x81, 0x9D, 0x7A, 0x43, 0x1D, 0x7C, 0x90, 0xEA, 0x0E, 0x5F], - cf: 1 - }; - - var curve_P521 = { - name: "P-521", - type: 0, - p: [0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], - a: [0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC], - b: [0x00, 0x51, 0x95, 0x3E, 0xB9, 0x61, 0x8E, 0x1C, 0x9A, 0x1F, 0x92, 0x9A, 0x21, 0xA0, 0xB6, 0x85, 0x40, 0xEE, 0xA2, 0xDA, 0x72, 0x5B, 0x99, 0xB3, 0x15, 0xF3, 0xB8, 0xB4, 0x89, 0x91, 0x8E, 0xF1, 0x09, 0xE1, 0x56, 0x19, 0x39, 0x51, 0xEC, 0x7E, 0x93, 0x7B, 0x16, 0x52, 0xC0, 0xBD, 0x3B, 0xB1, 0xBF, 0x07, 0x35, 0x73, 0xDF, 0x88, 0x3D, 0x2C, 0x34, 0xF1, 0xEF, 0x45, 0x1F, 0xD4, 0x6B, 0x50, 0x3F, 0x00], - order: [0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFA, 0x51, 0x86, 0x87, 0x83, 0xBF, 0x2F, 0x96, 0x6B, 0x7F, 0xCC, 0x01, 0x48, 0xF7, 0x09, 0xA5, 0xD0, 0x3B, 0xB5, 0xC9, 0xB8, 0x89, 0x9C, 0x47, 0xAE, 0xBB, 0x6F, 0xB7, 0x1E, 0x91, 0x38, 0x64, 0x09], - gx: [0x00, 0xC6, 0x85, 0x8E, 0x06, 0xB7, 0x04, 0x04, 0xE9, 0xCD, 0x9E, 0x3E, 0xCB, 0x66, 0x23, 0x95, 0xB4, 0x42, 0x9C, 0x64, 0x81, 0x39, 0x05, 0x3F, 0xB5, 0x21, 0xF8, 0x28, 0xAF, 0x60, 0x6B, 0x4D, 0x3D, 0xBA, 0xA1, 0x4B, 0x5E, 0x77, 0xEF, 0xE7, 0x59, 0x28, 0xFE, 0x1D, 0xC1, 0x27, 0xA2, 0xFF, 0xA8, 0xDE, 0x33, 0x48, 0xB3, 0xC1, 0x85, 0x6A, 0x42, 0x9B, 0xF9, 0x7E, 0x7E, 0x31, 0xC2, 0xE5, 0xBD, 0x66], - gy: [0x01, 0x18, 0x39, 0x29, 0x6A, 0x78, 0x9A, 0x3B, 0xC0, 0x04, 0x5C, 0x8A, 0x5F, 0xB4, 0x2C, 0x7D, 0x1B, 0xD9, 0x98, 0xF5, 0x44, 0x49, 0x57, 0x9B, 0x44, 0x68, 0x17, 0xAF, 0xBD, 0x17, 0x27, 0x3E, 0x66, 0x2C, 0x97, 0xEE, 0x72, 0x99, 0x5E, 0xF4, 0x26, 0x40, 0xC5, 0x50, 0xB9, 0x01, 0x3F, 0xAD, 0x07, 0x61, 0x35, 0x3C, 0x70, 0x86, 0xA2, 0x72, 0xC2, 0x40, 0x88, 0xBE, 0x94, 0x76, 0x9F, 0xD1, 0x66, 0x50], - cf: 1 - }; - - if (typeof cryptoECC !== "undefined") { - cryptoECC.curves["P-256"] = curve_P256; - cryptoECC.curves["P-384"] = curve_P384; - cryptoECC.curves["P-521"] = curve_P521; - } - - var curve_BN254 = { - name: "BN-254", - type: 0, - p: [0x25, 0x23, 0x64, 0x82, 0x40, 0x00, 0x00, 0x01, 0xBA, 0x34, 0x4D, 0x80, 0x00, 0x00, 0x00, 0x08, 0x61, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xA7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13], - a: [0x00], - b: [0x02], - order: [0x25, 0x23, 0x64, 0x82, 0x40, 0x00, 0x00, 0x01, 0xBA, 0x34, 0x4D, 0x80, 0x00, 0x00, 0x00, 0x07, 0xFF, 0x9F, 0x80, 0x00, 0x00, 0x00, 0x00, 0x10, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D], - gx: [0x25, 0x23, 0x64, 0x82, 0x40, 0x00, 0x00, 0x01, 0xBA, 0x34, 0x4D, 0x80, 0x00, 0x00, 0x00, 0x08, 0x61, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xA7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12], - gy: [0x01], - cf: 1 - }; - - if (typeof cryptoECC !== "undefined") { - cryptoECC.curves["BN-254"] = curve_BN254; - } - - var curve_numsp256d1 = { - info: ["numsp256d1", 256, 256, 256], - type: 0, - p: [0x43, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), - a: [0x40, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), - b: [0x81, 0x55, 0x02].reverse(), - order: [0x25, 0xa8, 0x51, 0x47, 0x29, 0x20, 0xab, 0x20, 0x60, 0x5c, 0x26, 0xea, 0x75, 0x82, 0x3c, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), - gx: [0xB1, 0xAC, 0x1A, 0xB2, 0x1E, 0xEE, 0x52, 0xBC, 0x3A, 0xC7, 0xD4, 0x03, 0x09, 0x9B, 0x57, 0x83, 0x09, 0xCB, 0x42, 0x4F, 0xA0, 0x95, 0x7A, 0x29, 0x61, 0xDB, 0xAA, 0x5A, 0xB6, 0xD6, 0x9E, 0xBC].reverse(), - gy: [0x9F, 0xDE, 0x84, 0x21, 0xCB, 0xB9, 0xB5, 0x80, 0xBB, 0x0F, 0x31, 0x15, 0xD1, 0xC3, 0x55, 0xC9, 0x35, 0xE0, 0x04, 0x7E, 0xF7, 0x8B, 0x44, 0x73, 0xA6, 0xB6, 0x99, 0x33, 0xF1, 0xC0, 0x8F, 0xD0].reverse(), - cf: 1 - }; - - var curve_numsp256t1 = { - info: ["numsp256t1", 256, 255, 256], - name: "numsp256t1", - type: 1, - p: [0x43, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), - a: [0x01], - d: [0x55, 0xC3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF].reverse(), - order: [0xF5, 0x4A, 0xDD, 0xEE, 0x90, 0xB1, 0x47, 0x1A, 0x9B, 0x43, 0x59, 0x2F, 0xA5, 0x5A, 0x95, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40].reverse(), - gx: [0xDA, 0x13, 0xED, 0x2E, 0x90, 0xC0, 0xDE, 0xA0, 0x86, 0x35, 0x08, 0xE3, 0x0E, 0x8A, 0x39, 0x0C, 0xD6, 0x9B, 0x20, 0x69, 0x5F, 0x3D, 0x1E, 0xCD, 0x7D, 0x23, 0xEA, 0x6A, 0xFB, 0x14, 0x75, 0x8A].reverse(), - gy: [0xE6, 0x89, 0x8A, 0x79, 0xE7, 0x16, 0xA6, 0x2F, 0xD3, 0x6E, 0x85, 0x10, 0xD8, 0x61, 0x5F, 0x71, 0x10, 0x80, 0x4B, 0xA6, 0xD9, 0x65, 0x96, 0xCE, 0xC7, 0x25, 0xD9, 0xD9, 0x9F, 0x3E, 0xD5, 0x44].reverse(), - cf: 4 - }; - - var curve_numsp384d1 = { - info: ["numsp384d1", 384, 384, 384], - name: "numsp384d1", - type: 0, - p: [0xC3, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF - ].reverse(), - a: [0xC0, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF - ].reverse(), - b: [0xBB, 0x77, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF - ].reverse(), - order: [0xb9, 0x61, 0x0e, 0x7b, 0xf6, 0x81, 0x4d, 0x60, 0x7a, 0xe2, 0x37, 0x4c, 0x3d, 0x9d, 0xda, 0xbe, 0x81, 0x68, 0x5d, 0xeb, 0x1e, 0xaf, 0x1e, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff - ].reverse(), - gx: [0x2A, 0x15, 0x98, 0x20, 0x04, 0xBA, 0x9C, 0xEB, 0x7B, 0xC4, 0x61, 0x0F, 0x10, 0xED, 0x2E, 0x52, 0x42, 0xC7, 0x6C, 0x2A, 0x1B, 0x29, 0xBD, 0xF3, 0xF4, 0xF9, 0x81, 0xFB, 0xCD, 0xC1, 0x25, 0x02, - 0xA6, 0xF1, 0x05, 0x41, 0x22, 0xCA, 0x80, 0x48, 0x1C, 0x18, 0x6F, 0xB1, 0xF0, 0x56, 0x79, 0x75 - ].reverse(), - gy: [0x16, 0x07, 0x18, 0x66, 0xEC, 0xB8, 0x74, 0x5C, 0x26, 0xAD, 0xF4, 0xBF, 0xDB, 0xB4, 0xD6, 0xBC, 0x7E, 0x83, 0x1A, 0x12, 0x7D, 0x83, 0x20, 0xB9, 0x9C, 0x73, 0x7F, 0xF8, 0x77, 0x69, 0x04, 0xB0, - 0x7E, 0xCF, 0x84, 0x05, 0x30, 0x3D, 0xE3, 0xD7, 0x38, 0x8E, 0x9B, 0xE1, 0x68, 0xE3, 0xDE, 0xAC - ].reverse(), - cf: 1 - }; - - var curve_numsp384t1 = { - info: ["numsp384t1", 384, 382, 384], - name: "numsp384t1", - type: 1, - p: [0xC3, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF - ].reverse(), - a: [0x01], - d: [0x9F, 0xD1, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF - ].reverse(), - order: [0x7D, 0x89, 0xA3, 0xE6, 0xC4, 0xDC, 0xB9, 0x20, 0x79, 0xC8, 0x35, 0xAB, 0x5A, 0x55, 0xE4, 0x61, 0xCF, 0xE1, 0x6B, 0xB4, 0x1C, 0x1A, 0x47, 0xE2, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F - ].reverse(), - gx: [0xDE, 0x6B, 0x20, 0x6C, 0xE4, 0x40, 0xD5, 0x50, 0x13, 0x94, 0x45, 0x65, 0xB1, 0x92, 0xF2, 0x6F, 0x40, 0x63, 0x31, 0xF3, 0xA8, 0xFF, 0x63, 0x57, 0x00, 0x4C, 0xBE, 0xE5, 0x46, 0xF4, 0x0B, 0xB3, - 0xB5, 0x5D, 0xE5, 0x9A, 0x12, 0xA2, 0xB6, 0xC0, 0x6C, 0x26, 0xA9, 0x45, 0xFB, 0x11, 0xB1, 0x61 - ].reverse(), - gy: [0x92, 0x93, 0x72, 0xF0, 0xE1, 0x03, 0x8D, 0x9D, 0xDC, 0x48, 0xEC, 0x46, 0xF9, 0xB0, 0x72, 0x00, 0x4B, 0x96, 0x45, 0xF6, 0xF7, 0x98, 0x0F, 0x83, 0x56, 0x5F, 0x42, 0xF1, 0x74, 0x82, 0xAD, 0x16, - 0xD7, 0x0D, 0xB1, 0x23, 0xA4, 0xB1, 0x38, 0x87, 0xB0, 0xEE, 0xA6, 0xB9, 0x67, 0x3E, 0x98, 0x82 - ].reverse(), - cf: 4 - }; - - var curve_numsp512d1 = { - info: ["numsp512d1", 512, 512, 512], - name: "numsp512d1", - type: 0, - p: [0xC7, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF - ].reverse(), - a: [0xC4, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF - ].reverse(), - b: [0x9B, 0xD9, 0x01].reverse(), - order: [0x5d, 0x55, 0x33, 0x04, 0x39, 0x3f, 0x15, 0xce, 0x43, 0xd2, 0x7c, 0x60, 0x36, 0x8b, 0x56, 0x3b, 0xc6, 0xbd, 0xd0, 0x97, 0xed, 0x58, 0xc2, 0x4f, 0x1b, 0x83, 0xe7, 0x94, 0xfb, 0xa4, 0x3c, 0x5b, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff - ].reverse(), - gx: [0x57, 0xAE, 0xAB, 0x8C, 0x95, 0x87, 0x82, 0xDC, 0xE2, 0x5D, 0x6F, 0x7D, 0x13, 0x60, 0x5D, 0x1D, 0x83, 0x15, 0x56, 0x25, 0x86, 0x42, 0x79, 0x93, 0x9E, 0x35, 0x6B, 0x07, 0x51, 0xA1, 0x21, 0x50, - 0xF9, 0xD9, 0x06, 0x53, 0xC2, 0xE0, 0x06, 0x45, 0x85, 0xF6, 0x01, 0xB5, 0x3B, 0xD8, 0xCA, 0x98, 0x52, 0x3B, 0x3D, 0xA0, 0x02, 0x70, 0x2B, 0xDA, 0x93, 0x0A, 0x1D, 0x14, 0x47, 0x34, 0xC0, 0x3A - ].reverse(), - gy: [0xA6, 0x27, 0x35, 0x38, 0x60, 0x87, 0xA0, 0x23, 0xE9, 0x0F, 0xFD, 0x4C, 0x1E, 0x5C, 0x2B, 0xCF, 0x02, 0x56, 0x5A, 0xB2, 0x40, 0xA8, 0x21, 0xC1, 0xE9, 0xED, 0x0E, 0x8B, 0xDA, 0x15, 0x84, 0xA2, - 0x14, 0x4F, 0xD1, 0x7B, 0x0C, 0x26, 0x4B, 0x8F, 0x8C, 0xBB, 0xBC, 0xAB, 0xDE, 0xDB, 0x97, 0x4B, 0x00, 0xB1, 0xEB, 0x63, 0xDC, 0xEE, 0x0E, 0xCE, 0xB3, 0x56, 0xAD, 0x29, 0xCA, 0x54, 0x3A, 0x94 - ].reverse(), - cf: 4 - }; - - var curve_numsp512t1 = { - info: ["numsp512t1", 512, 510, 512], - name: "numsp512t1", - type: 1, - p: [0xC7, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF - ].reverse(), - a: [0x01].reverse(), - d: [0xEF, 0xCB, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF - ].reverse(), - order: [0x6D, 0xD4, 0xEE, 0x1B, 0xF5, 0x8C, 0x46, 0x67, 0xFF, 0xEC, 0xEF, 0x6D, 0x78, 0x05, 0x46, 0x2A, 0xF5, 0x86, 0xB6, 0x70, 0xC9, 0xD8, 0x3F, 0x9E, 0xBA, 0x91, 0xCF, 0x2F, 0x6D, 0x63, 0xF0, 0xB4, - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F - ].reverse(), - gx: [0xFE, 0x57, 0xEC, 0x99, 0x29, 0xAB, 0xB9, 0xC5, 0x15, 0xF0, 0xC4, 0x7C, 0x42, 0x25, 0xE5, 0x0F, 0xAD, 0x04, 0x89, 0x56, 0x92, 0xC9, 0xBD, 0x78, 0x0F, 0x73, 0x46, 0xEE, 0x4E, 0xC1, 0x21, 0x46, - 0x47, 0x81, 0x3B, 0x27, 0xBE, 0x7E, 0xA1, 0x27, 0x82, 0xA3, 0xC4, 0x4D, 0x9F, 0xE7, 0xD1, 0x2F, 0x33, 0xC5, 0xD3, 0x88, 0x78, 0xCB, 0x18, 0x7A, 0x9C, 0xB6, 0x8D, 0x12, 0x6D, 0x31, 0x8E, 0xDF - ].reverse(), - gy: [0xE1, 0xF5, 0xE2, 0xC1, 0xC0, 0xDE, 0x6D, 0x32, 0x1F, 0xD0, 0xF1, 0x9B, 0x8A, 0xD3, 0x66, 0x02, 0xFD, 0xC1, 0xEC, 0x2A, 0x86, 0x06, 0x1A, 0x60, 0x62, 0x35, 0x96, 0xE9, 0xF2, 0x53, 0xCA, 0x20, - 0x41, 0x83, 0x9E, 0x90, 0x95, 0x6B, 0x2B, 0xA9, 0x22, 0x9D, 0x25, 0xD8, 0x26, 0xF7, 0x76, 0xE4, 0x6E, 0x25, 0x2A, 0xA8, 0x77, 0xF5, 0xB0, 0x98, 0x71, 0xCA, 0x49, 0x9D, 0xF3, 0xBF, 0x09, 0x6D - ].reverse(), - cf: 4 - }; - - if (typeof cryptoECC !== "undefined") { - cryptoECC.curves.NUMSP256D1 = curve_numsp256d1; - cryptoECC.curves.NUMSP384D1 = curve_numsp384d1; - cryptoECC.curves.NUMSP512D1 = curve_numsp512d1; - cryptoECC.curves.NUMSP256T1 = curve_numsp256t1; - cryptoECC.curves.NUMSP384T1 = curve_numsp384t1; - cryptoECC.curves.NUMSP512T1 = curve_numsp512t1; - } - - var msrcryptoSha = function(name, der, h, k, blockBytes, blockFunction, truncateTo) { - var utils = msrcryptoUtilities; - - var hv = h.slice(), - w = new Array(blockBytes), - buffer = [], - blocksProcessed = 0; - - function hashBlocks(message) { - var blockCount = Math.floor(message.length / blockBytes); - - for (var block = 0; block < blockCount; block++) { - blockFunction(message, block, hv, k, w); - } - - blocksProcessed += blockCount; - - return message.slice(blockCount * blockBytes); - } - - function hashToBytes() { - var hash = []; - - for (var i = 0; i < hv.length; i++) { - hash = hash.concat(utils.int32ToBytes(hv[i])); - } - - hash.length = truncateTo / 8; - - return hash; - } - - function addPadding(messageBytes) { - var padLen = blockBytes - messageBytes.length % blockBytes; - - (padLen <= (blockBytes / 8)) && (padLen += blockBytes); - - var padding = utils.getVector(padLen); - - padding[0] = 128; - - var messageLenBits = (messageBytes.length + blocksProcessed * blockBytes) * 8; - - for (var i = 1; i <= 8; i++) { - padding[padLen - i] = messageLenBits % 0x100; - messageLenBits = Math.floor(messageLenBits / 0x100); - } - return messageBytes.concat(padding); - } - - function computeHash(messageBytes) { - buffer = hashBlocks(messageBytes); - - return finish(); - } - - function process(messageBytes) { - buffer = buffer.concat(messageBytes); - - if (buffer.length >= blockBytes) { - - buffer = hashBlocks(buffer); - } - - return; - } - - function finish() { - if (hashBlocks(addPadding(buffer)).length !== 0) { - throw new Error("buffer.length !== 0"); - } - - var result = hashToBytes(); - - buffer = []; - - hv = h.slice(); - - blocksProcessed = 0; - - return result; - } - - return { - name: name, - computeHash: computeHash, - process: process, - finish: finish, - der: der, - hashLen: truncateTo, - maxMessageSize: 0xFFFFFFFF - }; - - }; - - var msrcryptoSha1 = (function() { - - function hashBlock(message, blockIndex, hv, k, w) { - var t, i, temp, x0, blockSize = 64, - mask = 0xFFFFFFFF; - - var ra = hv[0], - rb = hv[1], - rc = hv[2], - rd = hv[3], - re = hv[4]; - - for (i = 0; i < 16; i++) { - w[i] = utils.bytesToInt32(message, blockIndex * blockSize + i * 4); - } - - for (t = 16; t < 80; t++) { - x0 = w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16]; - w[t] = (x0 << 1) | (x0 >>> 31); - } - - for (i = 0; i < 80; i++) { - - temp = ((ra << 5) | (ra >>> 27)); - - temp += - i >= 60 ? (rb ^ rc ^ rd) : - i >= 40 ? ((rb & rc) ^ (rb & rd) ^ (rc & rd)) : - i >= 20 ? (rb ^ rc ^ rd) : - ((rb & rc) ^ ((~rb) & rd)); - - temp += (re + k[i] + w[i]); - - re = rd; - rd = rc; - rc = ((rb << 30) | (rb >>> 2)); - rb = ra; - ra = temp; - } - - hv[0] += ra & mask; - hv[1] += rb & mask; - hv[2] += rc & mask; - hv[3] += rd & mask; - hv[4] += re & mask; - - return hv; - } - - var utils = msrcryptoUtilities, - upd = utils.unpackData, - h = upd("Z0UjAe/Nq4mYutz+EDJUdsPS4fA=", 4, 1), - k = upd("WoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroY8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdY", 4, 1), - der = upd("MCEwCQYFKw4DAhoFAAQU"); - - return { - sha1: function() { - return msrcryptoSha("SHA-1", der, h, k, 64, hashBlock, 160); - } - }; - - })(); - - if (typeof operations !== "undefined") { - - msrcryptoSha1.instances = {}; - - msrcryptoSha1.getInstance = function(id) { - return msrcryptoSha1.instances[id] || (msrcryptoSha1.instances[id] = msrcryptoSha1.sha1()); - }; - - msrcryptoSha1.deleteInstance = function(id) { - msrcryptoSha1.instances[id] = null; - delete msrcryptoSha1.instances[id]; - }; - - msrcryptoSha1.hash = function(p) { - - if (p.operationSubType === "process") { - msrcryptoSha1.sha1.process(p.buffer); - return; - } - - if (p.operationSubType === "finish") { - return msrcryptoSha1.sha1.finish(); - } - - return msrcryptoSha1.sha1().computeHash(p.buffer); - - }; - - operations.register("digest", "SHA-1", msrcryptoSha1.hash); - - } - - msrcryptoHashFunctions["SHA-1"] = msrcryptoSha1.sha1; - - var msrcryptoSha256 = (function() { - - var utils = msrcryptoUtilities; - - function hashBlock(message, blockIndex, hv, k, w) { - var t, i, temp, x0, x1, blockSize = 64, - mask = 0xFFFFFFFF; - - var ra = hv[0], - rb = hv[1], - rc = hv[2], - rd = hv[3], - re = hv[4], - rf = hv[5], - rg = hv[6], - rh = hv[7]; - - for (i = 0; i < 16; i++) { - w[i] = utils.bytesToInt32(message, blockIndex * blockSize + i * 4); - } - - for (t = 16; t < 64; t++) { - - x0 = w[t - 15]; - x1 = w[t - 2]; - - w[t] = (((x1 >>> 17) | (x1 << 15)) ^ ((x1 >>> 19) | (x1 << 13)) ^ (x1 >>> 10)) + - w[t - 7] + - (((x0 >>> 7) | (x0 << 25)) ^ ((x0 >>> 18) | (x0 << 14)) ^ (x0 >>> 3)) + - w[t - 16]; - - w[t] = w[t] & mask; - } - - for (i = 0; i < 64; i++) { - - temp = rh + - ((re >>> 6 | re << 26) ^ (re >>> 11 | re << 21) ^ (re >>> 25 | re << 7)) + - ((re & rf) ^ ((~re) & rg)) + - k[i] + w[i]; - - rd += temp; - - temp += ((ra >>> 2 | ra << 30) ^ (ra >>> 13 | ra << 19) ^ (ra >>> 22 | ra << 10)) + - ((ra & (rb ^ rc)) ^ (rb & rc)); - - rh = rg; - rg = rf; - rf = re; - re = rd; - rd = rc; - rc = rb; - rb = ra; - ra = temp; - - } - - hv[0] = (hv[0] + ra) >>> 0; - hv[1] = (hv[1] + rb) >>> 0; - hv[2] = (hv[2] + rc) >>> 0; - hv[3] = (hv[3] + rd) >>> 0; - hv[4] = (hv[4] + re) >>> 0; - hv[5] = (hv[5] + rf) >>> 0; - hv[6] = (hv[6] + rg) >>> 0; - hv[7] = (hv[7] + rh) >>> 0; - - return hv; - } - - var k256, h224, h256, der224, der256, upd = utils.unpackData; - - h224 = upd("wQWe2DZ81QcwcN0X9w5ZOf/ACzFoWBURZPmPp776T6Q", 4, 1); - - h256 = upd("agnmZ7tnroU8bvNypU/1OlEOUn+bBWiMH4PZq1vgzRk", 4, 1); - - k256 = upd("QoovmHE3RJG1wPvP6bXbpTlWwltZ8RHxkj+CpKscXtXYB6qYEoNbASQxhb5VDH3Dcr5ddIDesf6b3AanwZvxdOSbacHvvkeGD8GdxiQMocwt6SxvSnSEqlywqdx2+YjamD5RUqgxxm2wAyfIv1l/x8bgC/PVp5FHBspjURQpKWcntwqFLhshOE0sbfxTOA0TZQpzVHZqCruBwskuknIshaK/6KGoGmZLwkuLcMdsUaPRkugZ1pkGJPQONYUQaqBwGaTBFh43bAgnSHdMNLC8tTkcDLNO2KpKW5zKT2gub/N0j4LueKVjb4TIeBSMxwIIkL7/+qRQbOu++aP3xnF48g", 4, 1); - - der224 = upd("MC0wDQYJYIZIAWUDBAIEBQAEHA"); - - der256 = upd("MDEwDQYJYIZIAWUDBAIBBQAEIA"); - - return { - sha224: function() { - return msrcryptoSha("SHA-224", der224, h224, k256, 64, hashBlock, 224); - }, - sha256: function() { - return msrcryptoSha("SHA-256", der256, h256, k256, 64, hashBlock, 256); - } - }; - })(); - - if (typeof operations !== "undefined") { - - msrcryptoSha256.instance224 = msrcryptoSha256.instance224 || msrcryptoSha256.sha224(); - msrcryptoSha256.instance256 = msrcryptoSha256.instance256 || msrcryptoSha256.sha256(); - - msrcryptoSha256.instances = {}; - - msrcryptoSha256.getInstance224 = function(id) { - return msrcryptoSha256.instances[id] || (msrcryptoSha256.instances[id] = msrcryptoSha256.sha224()); - }; - - msrcryptoSha256.getInstance256 = function(id) { - return msrcryptoSha256.instances[id] || (msrcryptoSha256.instances[id] = msrcryptoSha256.sha256()); - }; - - msrcryptoSha256.deleteInstance = function(id) { - msrcryptoSha256.instances[id] = null; - delete msrcryptoSha256.instances[id]; - }; - - msrcryptoSha256.hash256 = function(p) { - - if (p.operationSubType === "process") { - msrcryptoSha256.getInstance256(p.workerid).process(p.buffer); - return null; - } - - if (p.operationSubType === "finish") { - - var result = msrcryptoSha256.getInstance256(p.workerid).finish(); - msrcryptoSha256.deleteInstance(p.workerid); - return result; - } - - if (p.operationSubType === "abort") { - msrcryptoSha256.deleteInstance(p.workerid); - return; - } - - return msrcryptoSha256.instance256.computeHash(p.buffer); - - }; - - msrcryptoSha256.hash224 = function(p) { - - if (p.operationSubType === "process") { - msrcryptoSha256.getInstance224(p.workerid).process(p.buffer); - return; - } - - if (p.operationSubType === "finish") { - var result = msrcryptoSha256.getInstance224(p.workerid).finish(); - } - - if (p.operationSubType === "abort") { - msrcryptoSha224.deleteInstance(p.workerid); - return; - } - - return msrcryptoSha256.instance224.computeHash(p.buffer); - - }; - - operations.register("digest", "SHA-224", msrcryptoSha256.hash224); - operations.register("digest", "SHA-256", msrcryptoSha256.hash256); - } - - msrcryptoHashFunctions["SHA-224"] = msrcryptoSha256.sha224; - msrcryptoHashFunctions["SHA-256"] = msrcryptoSha256.sha256; - - var msrcryptoSha512 = (function() { - - var utils = msrcryptoUtilities; - - function add(x0, x1, y0, y1, resultArray) { - - var lowSum = (x1 + y1) | 0; - - var carry = (lowSum >>> 0 < y1 >>> 0); - - resultArray[0] = (x0 + y0 + carry) | 0; - resultArray[1] = lowSum; - - return; - } - - function hashBlock(message, blockIndex, hv, k, w) { - var t, i, blockBytes = 128, - tah, tal, tbh, tbl, xh, xl, - tc = [], - td = [], - te = [], - index; - - var ah = hv[0], - al = hv[1], - bh = hv[2], - bl = hv[3], - ch = hv[4], - cl = hv[5], - dh = hv[6], - dl = hv[7], - eh = hv[8], - el = hv[9], - fh = hv[10], - fl = hv[11], - gh = hv[12], - gl = hv[13], - hh = hv[14], - hl = hv[15]; - - for (t = 0; t < 32; t++) { - index = blockIndex * blockBytes + t * 4; - w[t] = message.slice(index, index + 4); - w[t] = (w[t][0] << 24) | (w[t][1] << 16) | (w[t][2] << 8) | w[t][3]; - } - - for (t = 32; t < 160; t += 2) { - - xh = w[t - 30]; - xl = w[t - 29]; - - tah = (xh >>> 1 | xl << 31) ^ (xh >>> 8 | xl << 24) ^ (xh >>> 7); - tal = (xl >>> 1 | xh << 31) ^ (xl >>> 8 | xh << 24) ^ (xl >>> 7 | xh << 25); - - xh = w[t - 4]; - xl = w[t - 3]; - - tbh = (xh >>> 19 | xl << 13) ^ (xl >>> 29 | xh << 3) ^ (xh >>> 6); - tbl = (xl >>> 19 | xh << 13) ^ (xh >>> 29 | xl << 3) ^ (xl >>> 6 | xh << 26); - - add(tbh, tbl, w[t - 14], w[t - 13], tc); - - add(tah, tal, tc[0], tc[1], tc); - - add(w[t - 32], w[t - 31], tc[0], tc[1], tc); - - w[t] = tc[0]; - w[t + 1] = tc[1]; - } - - for (i = 0; i < 160; i += 2) { - - tah = (eh >>> 14 | el << 18) ^ (eh >>> 18 | el << 14) ^ (el >>> 9 | eh << 23); - tal = (el >>> 14 | eh << 18) ^ (el >>> 18 | eh << 14) ^ (eh >>> 9 | el << 23); - - tbh = (eh & fh) ^ (gh & ~eh); - tbl = (el & fl) ^ (gl & ~el); - - add(hh, hl, tah, tal, tc); - - add(tbh, tbl, k[i], k[i + 1], td); - - add(tc[0], tc[1], w[i], w[i + 1], te); - - add(td[0], td[1], te[0], te[1], te); - - add(te[0], te[1], dh, dl, tc); - dh = tc[0]; - dl = tc[1]; - - tal = (al >>> 28 | ah << 4) ^ (ah >>> 2 | al << 30) ^ (ah >>> 7 | al << 25); - tah = (ah >>> 28 | al << 4) ^ (al >>> 2 | ah << 30) ^ (al >>> 7 | ah << 25); - - tbl = (al & (bl ^ cl)) ^ (bl & cl); - tbh = (ah & (bh ^ ch)) ^ (bh & ch); - - add(te[0], te[1], tah, tal, tc); - tah = tc[0]; - tal = tc[1]; - - add(tbh, tbl, tah, tal, tc); - tah = tc[0]; - tal = tc[1]; - - hh = gh; - hl = gl; - gh = fh; - gl = fl; - fh = eh; - fl = el; - eh = dh; - el = dl; - dh = ch; - dl = cl; - ch = bh; - cl = bl; - bh = ah; - bl = al; - ah = tah; - al = tal; - } - - add(hv[0], hv[1], ah, al, tc); - hv[0] = tc[0]; - hv[1] = tc[1]; - - add(hv[2], hv[3], bh, bl, tc); - hv[2] = tc[0]; - hv[3] = tc[1]; - - add(hv[4], hv[5], ch, cl, tc); - hv[4] = tc[0]; - hv[5] = tc[1]; - - add(hv[6], hv[7], dh, dl, tc); - hv[6] = tc[0]; - hv[7] = tc[1]; - - add(hv[8], hv[9], eh, el, tc); - hv[8] = tc[0]; - hv[9] = tc[1]; - - add(hv[10], hv[11], fh, fl, tc); - hv[10] = tc[0]; - hv[11] = tc[1]; - - add(hv[12], hv[13], gh, gl, tc); - hv[12] = tc[0]; - hv[13] = tc[1]; - - add(hv[14], hv[15], hh, hl, tc); - hv[14] = tc[0]; - hv[15] = tc[1]; - - return hv; - } - - var h384, h512, k512, - der384, der512, der512_224, der512_256, - upd = utils.unpackData; - - h384 = upd("y7udXcEFnthimikqNnzVB5FZAVowcN0XFS/s2PcOWTlnMyZn/8ALMY60SodoWBUR2wwuDWT5j6dHtUgdvvpPpA==", 4, 1); - - h512 = upd("agnmZ/O8yQi7Z66FhMqnOzxu83L+lPgrpU/1Ol8dNvFRDlJ/reaC0ZsFaIwrPmwfH4PZq/tBvWtb4M0ZE34heQ", 4, 1); - - k512 = upd( - "QoovmNcoriJxN0SRI+9lzbXA+8/sTTsv6bXbpYGJ27w5VsJb80i1OFnxEfG2BdAZkj+CpK8ZT5urHF7" + - "V2m2BGNgHqpijAwJCEoNbAUVwb74kMYW+TuSyjFUMfcPV/7Ticr5ddPJ7iW+A3rH+OxaWsZvcBqclxx" + - "I1wZvxdM9pJpTkm2nBnvFK0u++R4Y4TyXjD8GdxouM1bUkDKHMd6ycZS3pLG9ZKwJ1SnSEqm6m5INcs" + - "KncvUH71Hb5iNqDEVO1mD5RUu5m36uoMcZtLbQyELADJ8iY+yE/v1l/x77vDuTG4AvzPaiPwtWnkUeT" + - "CqclBspjUeADgm8UKSlnCg5ucCe3CoVG0i/8LhshOFwmySZNLG38WsQq7VM4DROdlbPfZQpzVIuvY95" + - "2agq7PHeyqIHCyS5H7a7mknIshRSCNTuiv+ihTPEDZKgaZku8QjABwkuLcND4l5HHbFGjBlS+MNGS6B" + - "nW71IY1pkGJFVlqRD0DjWFV3EgKhBqoHAyu9G4GaTBFrjS0MgeN2wIUUGrUydId0zfjuuZNLC8teGbS" + - "Kg5HAyzxclaY07YqkrjQYrLW5zKT3dj43NoLm/z1rK4o3SPgu5d77L8eKVjb0MXL2CEyHgUofCrcozH" + - "AggaZDnskL7/+iNjHiikUGzr3oK96b75o/eyxnkVxnF48uNyUyvKJz7O6iZhnNGGuMchwMIH6tp91s3" + - "g6x71fU9/7m7ReAbwZ6pyF2+6CmN9xaLImKYRP5gEvvkNrhtxCzUTHEcbKNt39SMEfYQyyqt7QMckkz" + - "yevgoVyb68Qx1nxJwQDUxMxdS+yz5Ctll/KZz8ZX4qX8tvqzrW+uxsRBmMSkdYFw==", 4, 1); - - der384 = upd("MEEwDQYJYIZIAWUDBAICBQAEMA"); - der512 = upd("MFEwDQYJYIZIAWUDBAIDBQAEQA"); - der512_224 = upd("MC0wDQYJYIZIAWUDBAIFBQAEHA"); - der512_256 = upd("MDEwDQYJYIZIAWUDBAIGBQAEIA"); - - return { - sha384: function() { - return msrcryptoSha("SHA-384", der384, h384, k512, 128, hashBlock, 384); - }, - sha512: function() { - return msrcryptoSha("SHA-512", der512, h512, k512, 128, hashBlock, 512); - }, - sha512_224: function() { - return msrcryptoSha("SHA-512.224", der512_224, h512, k512, 128, hashBlock, 224); - }, - sha512_256: function() { - return msrcryptoSha("SHA-512.256", der512_256, h512, k512, 128, hashBlock, 256); - } - }; - - })(); - - if (typeof operations !== "undefined") { - - msrcryptoSha512.instances = {}; - - msrcryptoSha512.getInstance384 = function(id) { - return msrcryptoSha512.instances[id] || (msrcryptoSha512.instances[id] = msrcryptoSha512.sha384()); - }; - - msrcryptoSha512.getInstance512 = function(id) { - return msrcryptoSha512.instances[id] || (msrcryptoSha512.instances[id] = msrcryptoSha512.sha512()); - }; - - msrcryptoSha512.deleteInstance = function(id) { - msrcryptoSha512.instances[id] = null; - delete msrcryptoSha512.instances[id]; - }; - - msrcryptoSha512.hash384 = function(p) { - - if (p.operationSubType === "process") { - msrcryptoSha512.sha384.process(p.buffer); - return; - } - - if (p.operationSubType === "finish") { - return msrcryptoSha512.sha384.finish(); - } - - return msrcryptoSha512.sha384().computeHash(p.buffer); - - }; - - msrcryptoSha512.hash512 = function(p) { - - if (p.operationSubType === "process") { - msrcryptoSha512.sha512.process(p.buffer); - return; - } - - if (p.operationSubType === "finish") { - return msrcryptoSha512.sha512.finish(); - } - - return msrcryptoSha512.sha512().computeHash(p.buffer); - - }; - - operations.register("digest", "SHA-384", msrcryptoSha512.hash384); - operations.register("digest", "SHA-512", msrcryptoSha512.hash512); - } - - msrcryptoHashFunctions["SHA-384"] = msrcryptoSha512.sha384; - msrcryptoHashFunctions["SHA-512"] = msrcryptoSha512.sha512; - - var msrcryptoHmac = function(keyBytes, hashFunction) { - - var blockSize = { - "384": 128, - "512": 128 - } [hashFunction.name.replace(/SHA-/, "")] || 64; - var ipad; - var opad; - var paddedKey = padKey(); - var keyXorOpad; - var keyXorIpad; - var k0IpadText; - - function xorArrays(array1, array2) { - var newArray = new Array(array1); - for (var j = 0; j < array1.length; j++) { - newArray[j] = array1[j] ^ array2[j]; - } - return newArray; - } - - function padZeros(bytes, paddedLength) { - var paddedArray = bytes.slice(); - for (var j = bytes.length; j < paddedLength; j++) { - paddedArray.push(0); - } - return paddedArray; - } - - function padKey() { - - if (keyBytes.length === blockSize) { - return keyBytes; - } - - if (keyBytes.length > blockSize) { - return padZeros(hashFunction.computeHash(keyBytes), blockSize); - } - - return padZeros(keyBytes, blockSize); - - } - - function processHmac(messageBytes) { - - if (!k0IpadText) { - k0IpadText = keyXorIpad.concat(messageBytes); - hashFunction.process(k0IpadText); - } else { - hashFunction.process(messageBytes); - } - return; - } - - function finishHmac() { - - var hashK0IpadText = hashFunction.finish(); - - var k0IpadK0OpadText = keyXorOpad.concat(hashK0IpadText); - - return hashFunction.computeHash(k0IpadK0OpadText); - } - - function clearState() { - keyBytes = null; - hashFunction = null; - paddedKey = null; - } - - ipad = new Array(blockSize); - opad = new Array(blockSize); - for (var i = 0; i < blockSize; i++) { - ipad[i] = 0x36; - opad[i] = 0x5c; - } - keyXorIpad = xorArrays(paddedKey, ipad); - keyXorOpad = xorArrays(paddedKey, opad); - return { - - computeHmac: function(dataBytes, key, hashAlgorithm) { - processHmac(dataBytes); - var result = finishHmac(); - clearState(); - return result; - }, - - process: function(dataBytes, key, hashAlgorithm) { - processHmac(dataBytes); - return null; - }, - - finish: function(key, hashAlgorithm) { - var result = finishHmac(); - clearState(); - return result; - } - - }; - }; - - if (typeof operations !== "undefined") { - - var hmacInstances = {}; - - msrcryptoHmac.signHmac = function(p) { - - var hashName = p.keyHandle.algorithm.hash.name.toUpperCase(), - hashAlg = msrcryptoHashFunctions[hashName](), - result, - id = p.workerid; - - if (!hmacInstances[id]) { - hmacInstances[id] = msrcryptoHmac(p.keyData, hashAlg); - } - - if (p.operationSubType === "process") { - hmacInstances[id].process(p.buffer); - return null; - } - - if (p.operationSubType === "finish") { - result = hmacInstances[id].finish(); - hmacInstances[id] = null; - return result; - } - - result = hmacInstances[id].computeHmac(p.buffer); - hmacInstances[id] = null; - return result; - }; - - msrcryptoHmac.verifyHmac = function(p) { - - var hashName = p.keyHandle.algorithm.hash.name.toUpperCase(), - hashAlg = msrcryptoHashFunctions[hashName](), - result, - id = p.workerid; - - if (!hmacInstances[id]) { - hmacInstances[id] = msrcryptoHmac(p.keyData, hashAlg); - } - - if (p.operationSubType === "process") { - hmacInstances[id].process(p.buffer); - return null; - } - - if (p.operationSubType === "finish") { - result = hmacInstances[id].finish(); - result = msrcryptoUtilities.arraysEqual(result, p.signature); - hmacInstances[id] = null; - return result; - } - - result = hmacInstances[id].computeHmac(p.buffer); - result = msrcryptoUtilities.arraysEqual(result, p.signature); - hmacInstances[id] = null; - return result; - }; - - msrcryptoHmac.generateKey = function(p) { - - var defaultKeyLengths = { - "SHA-1": 64, - "SHA-224": 64, - "SHA-256": 64, - "SHA-384": 128, - "SHA-512": 128 - }; - - var keyLength = p.algorithm.length; - - if (!keyLength) { - keyLength = defaultKeyLengths[p.algorithm.hash.name.toUpperCase()]; - } - - return { - type: "keyGeneration", - keyData: msrcryptoPseudoRandom.getBytes(keyLength), - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: null || p.usages, - type: "secret" - } - }; - }; - - msrcryptoHmac.importKey = function(p) { - var keyObject, - keyBits = p.keyData.length * 8; - - if (p.format === "jwk") { - keyObject = msrcryptoJwk.jwkToKey(p.keyData, p.algorithm, ["k"]); - keyObject.alg = keyObject.alg.replace("HS", "SHA-"); - } else if (p.format === "raw") { - keyObject = { - k: msrcryptoUtilities.toArray(p.keyData) - }; - } else { - throw new Error("unsupported import format"); - } - - return { - type: "keyImport", - keyData: keyObject.k, - keyHandle: { - algorithm: { - name: "HMAC", - hash: { - name: p.algorithm.hash.name - } - }, - extractable: p.extractable || keyObject.extractable, - usages: p.usages, - type: "secret" - } - }; - - }; - - msrcryptoHmac.exportKey = function(p) { - - if (p.format === "jwk") { - return { - type: "keyExport", - keyHandle: msrcryptoJwk.keyToJwk(p.keyHandle, p.keyData) - }; - } - - if (p.format === "raw") { - return { - type: "keyExport", - keyHandle: p.keyData - }; - } - - throw new Error("unsupported export format"); - }; - - operations.register("importKey", "HMAC", msrcryptoHmac.importKey); - operations.register("exportKey", "HMAC", msrcryptoHmac.exportKey); - operations.register("generateKey", "HMAC", msrcryptoHmac.generateKey); - operations.register("sign", "HMAC", msrcryptoHmac.signHmac); - operations.register("verify", "HMAC", msrcryptoHmac.verifyHmac); - } - - var msrcryptoBlockCipher = (function() { - - var aesConstants, - x2, - x3, - x14, - x13, - x11, - x9, - sBoxTable, - invSBoxTable, - rConTable; - - return { - - aes: function(keyBytes) { - - if (!aesConstants) { - aesConstants = msrcryptoUtilities.unpackData("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", 256, false); - x2 = aesConstants[0]; - x3 = aesConstants[1]; - x14 = aesConstants[2]; - x13 = aesConstants[3]; - x11 = aesConstants[4]; - x9 = aesConstants[5]; - sBoxTable = aesConstants[6]; - invSBoxTable = aesConstants[7]; - rConTable = aesConstants[8]; - } - - var blockSize = 128, - keyLength, - nK, - nB = 4, - nR, - key; - - keyLength = keyBytes.length * 8; - - switch (keyLength) { - case 128: - case 192: - case 256: - break; - default: - throw new Error("Unsupported keyLength"); - } - - nK = keyLength / 32; - nR = nK + 6; - - var shiftRows = function(a) { - var tmp = a[1]; - a[1] = a[5]; - a[5] = a[9]; - a[9] = a[13]; - a[13] = tmp; - tmp = a[2]; - a[2] = a[10]; - a[10] = tmp; - tmp = a[6]; - a[6] = a[14]; - a[14] = tmp; - tmp = a[15]; - a[15] = a[11]; - a[11] = a[7]; - a[7] = a[3]; - a[3] = tmp; - }; - - var invShiftRows = function(a) { - var tmp = a[13]; - a[13] = a[9]; - a[9] = a[5]; - a[5] = a[1]; - a[1] = tmp; - tmp = a[10]; - a[10] = a[2]; - a[2] = tmp; - tmp = a[14]; - a[14] = a[6]; - a[6] = tmp; - tmp = a[3]; - a[3] = a[7]; - a[7] = a[11]; - a[11] = a[15]; - a[15] = tmp; - }; - - var mixColumns = function(state) { - var a = state[0], - b = state[1], - c = state[2], - d = state[3], - e = state[4], - f = state[5], - g = state[6], - h = state[7], - i = state[8], - j = state[9], - k = state[10], - l = state[11], - m = state[12], - n = state[13], - o = state[14], - p = state[15]; - - state[0] = x2[a] ^ x3[b] ^ c ^ d; - state[1] = a ^ x2[b] ^ x3[c] ^ d; - state[2] = a ^ b ^ x2[c] ^ x3[d]; - state[3] = x3[a] ^ b ^ c ^ x2[d]; - state[4] = x2[e] ^ x3[f] ^ g ^ h; - state[5] = e ^ x2[f] ^ x3[g] ^ h; - state[6] = e ^ f ^ x2[g] ^ x3[h]; - state[7] = x3[e] ^ f ^ g ^ x2[h]; - state[8] = x2[i] ^ x3[j] ^ k ^ l; - state[9] = i ^ x2[j] ^ x3[k] ^ l; - state[10] = i ^ j ^ x2[k] ^ x3[l]; - state[11] = x3[i] ^ j ^ k ^ x2[l]; - state[12] = x2[m] ^ x3[n] ^ o ^ p; - state[13] = m ^ x2[n] ^ x3[o] ^ p; - state[14] = m ^ n ^ x2[o] ^ x3[p]; - state[15] = x3[m] ^ n ^ o ^ x2[p]; - }; - - var invMixColumns = function(state) { - var a = state[0], - b = state[1], - c = state[2], - d = state[3], - e = state[4], - f = state[5], - g = state[6], - h = state[7], - i = state[8], - j = state[9], - k = state[10], - l = state[11], - m = state[12], - n = state[13], - o = state[14], - p = state[15]; - - state[0] = x14[a] ^ x11[b] ^ x13[c] ^ x9[d]; - state[1] = x9[a] ^ x14[b] ^ x11[c] ^ x13[d]; - state[2] = x13[a] ^ x9[b] ^ x14[c] ^ x11[d]; - state[3] = x11[a] ^ x13[b] ^ x9[c] ^ x14[d]; - state[4] = x14[e] ^ x11[f] ^ x13[g] ^ x9[h]; - state[5] = x9[e] ^ x14[f] ^ x11[g] ^ x13[h]; - state[6] = x13[e] ^ x9[f] ^ x14[g] ^ x11[h]; - state[7] = x11[e] ^ x13[f] ^ x9[g] ^ x14[h]; - state[8] = x14[i] ^ x11[j] ^ x13[k] ^ x9[l]; - state[9] = x9[i] ^ x14[j] ^ x11[k] ^ x13[l]; - state[10] = x13[i] ^ x9[j] ^ x14[k] ^ x11[l]; - state[11] = x11[i] ^ x13[j] ^ x9[k] ^ x14[l]; - state[12] = x14[m] ^ x11[n] ^ x13[o] ^ x9[p]; - state[13] = x9[m] ^ x14[n] ^ x11[o] ^ x13[p]; - state[14] = x13[m] ^ x9[n] ^ x14[o] ^ x11[p]; - state[15] = x11[m] ^ x13[n] ^ x9[o] ^ x14[p]; - }; - - var xorWord = function(a, b) { - return [a[0] ^ b[0], a[1] ^ b[1], a[2] ^ b[2], a[3] ^ b[3]]; - }; - - var addRoundKey = function(state, keySchedule, offset) { - for (var i = 0; i < state.length; i += 1) { - state[i] ^= keySchedule[i + offset]; - } - }; - - var rotWord = function(word) { - var a = word[0]; - word[0] = word[1]; - word[1] = word[2]; - word[2] = word[3]; - word[3] = a; - }; - - var subWord = function(word) { - for (var i = 0; i < word.length; i += 1) { - word[i] = sBoxTable[word[i]]; - } - }; - - var invSubWord = function(word) { - for (var i = 0; i < word.length; i += 1) { - word[i] = invSBoxTable[word[i]]; - } - }; - - var getWord = function(tab, i) { - return [tab[4 * i], tab[4 * i + 1], tab[4 * i + 2], tab[4 * i + 3]]; - }; - - var setWord = function(left, right, indexL, indexR) { - left[4 * indexL] = right[4 * indexR]; - left[4 * indexL + 1] = right[4 * indexR + 1]; - left[4 * indexL + 2] = right[4 * indexR + 2]; - left[4 * indexL + 3] = right[4 * indexR + 3]; - }; - - var expandKey = function(keyIn) { - var temp, res = [], - i = 0; - while (i < 4 * nK) { - res.push(keyIn[i++]); - } - - i = nK; - while (i < nB * (nR + 1)) { - temp = getWord(res, i - 1); - if (i % nK === 0) { - var index = i / nK; - var rcon = [rConTable[index], 0, 0, 0]; - rotWord(temp); - subWord(temp); - temp = xorWord(temp, rcon); - } else if (nK > 6 && i % nK === 4) { - subWord(temp); - } - var newWord = xorWord(getWord(res, i - nK), temp); - setWord(res, newWord, i, 0); - i += 1; - } - return res; - }; - - key = expandKey(keyBytes); - - return { - - encrypt: function(dataBytes) { - var state = dataBytes, - round; - - addRoundKey(state, key, 0); - for (round = 1; round <= nR - 1; round += 1) { - subWord(state); - shiftRows(state); - mixColumns(state); - addRoundKey(state, key, 4 * round * nB); - } - subWord(state); - shiftRows(state); - addRoundKey(state, key, 4 * nR * nB); - - return state; - }, - - decrypt: function(dataBytes) { - var state = dataBytes, - round; - - addRoundKey(state, key, 4 * nR * nB); - for (round = nR - 1; round >= 1; round -= 1) { - invShiftRows(state); - invSubWord(state); - addRoundKey(state, key, 4 * round * nB); - invMixColumns(state); - } - invShiftRows(state); - invSubWord(state); - addRoundKey(state, key, 0); - - return state; - }, - - clear: function() {}, - - keyLength: keyLength, - - blockSize: blockSize - - }; - } - - }; - - })(); - - var msrcryptoPadding = msrcryptoPadding || {}; - - msrcryptoPadding.pkcsv7 = function(blockSize) { - - function pad(messageBlocks) { - var lastIndex = messageBlocks.length - 1 >= 0 ? messageBlocks.length - 1 : 0; - var lastBlock = messageBlocks[lastIndex]; - var lastBlockLength = lastBlock.length; - var createNewBlock = lastBlockLength === blockSize; - - if (createNewBlock) { - var newBlock = []; - var i; - for (i = 0; i < blockSize; i += 1) { - newBlock.push(blockSize); - } - messageBlocks.push(newBlock); - } else { - var byteToAdd = blockSize - lastBlockLength & 0xff; - while (lastBlock.length !== blockSize) { - lastBlock.push(byteToAdd); - } - } - - } - - function unpad(messageBytes) { - var verified = true; - - if (messageBytes.length % blockSize !== 0) { - verified = false; - } - - var lastBlock = messageBytes.slice(-blockSize); - - var padLen = lastBlock[lastBlock.length - 1]; - - for (var i = 0; i < blockSize; i++) { - var isPaddingElement = blockSize - i <= padLen; - var isCorrectValue = lastBlock[i] === padLen; - verified = (isPaddingElement ? isCorrectValue : true) && verified; - } - - var trimLen = verified ? padLen : 0; - - messageBytes.length -= trimLen; - - return verified; - } - - return { - pad: pad, - unpad: unpad - }; - - }; - - var msrcryptoCbc = function(blockCipher) { - - var blockSize = blockCipher.blockSize / 8; - - var paddingScheme = msrcryptoPadding.pkcsv7(blockSize); - - var mergeBlocks = function(tab) { - var res = [], - i, j; - for (i = 0; i < tab.length; i += 1) { - var block = tab[i]; - for (j = 0; j < block.length; j += 1) { - res.push(block[j]); - } - } - return res; - }; - - function getBlocks(dataBytes) { - - var blocks = []; - - mBuffer = mBuffer.concat(dataBytes); - - var blockCount = Math.floor(mBuffer.length / blockSize); - - for (var i = 0; i < blockCount; i++) { - blocks.push(mBuffer.slice(i * blockSize, (i + 1) * blockSize)); - } - - mBuffer = mBuffer.slice(blockCount * blockSize); - - return blocks; - } - - function encryptBlocks(blocks) { - - var result = [], - toEncrypt; - - for (var i = 0; i < blocks.length; i++) { - toEncrypt = msrcryptoUtilities.xorVectors(mIvBytes, blocks[i]); - result.push(blockCipher.encrypt(toEncrypt)); - mIvBytes = result[i]; - } - - return result; - } - - function decryptBlocks(blocks) { - - var result = [], - toDecrypt, - decrypted; - - for (var i = 0; i < blocks.length; i += 1) { - toDecrypt = blocks[i].slice(0, blocks[i].length); - decrypted = blockCipher.decrypt(toDecrypt); - result.push(msrcryptoUtilities.xorVectors(mIvBytes, decrypted)); - mIvBytes = blocks[i]; - } - - return result; - } - - function clearState() { - mBuffer = []; - mResultBuffer = []; - mIvBytes = null; - } - - var mBuffer = [], - mResultBuffer = [], - mIvBytes; - - return { - - init: function(ivBytes) { - - if (ivBytes.length !== blockSize) { - throw new Error("Invalid iv size"); - } - - mIvBytes = ivBytes.slice(); - }, - - encrypt: function(plainBytes) { - var result = encryptBlocks(getBlocks(plainBytes)); - mResultBuffer = mResultBuffer.concat(mergeBlocks(result)); - - return this.finishEncrypt(); - }, - - processEncrypt: function(plainBytes) { - - var result = mergeBlocks(encryptBlocks(getBlocks(plainBytes))); - - return result; - }, - - finishEncrypt: function() { - - var blocks = mBuffer.length === 1 ? [ - [mBuffer[0]] - ] : [mBuffer]; - - paddingScheme.pad(blocks); - - var result = mResultBuffer.concat(mergeBlocks(encryptBlocks(blocks))); - - clearState(); - - return result; - }, - - decrypt: function(cipherBytes) { - this.processDecrypt(cipherBytes); - - return this.finishDecrypt(); - }, - - processDecrypt: function(cipherBytes) { - - var result = decryptBlocks(getBlocks(cipherBytes)); - - mResultBuffer = mResultBuffer.concat(mergeBlocks(result)); - - return; - }, - - finishDecrypt: function() { - - var result = mResultBuffer; - - var verified = paddingScheme.unpad(result); - - clearState(); - - return result; - } - - }; - }; - - if (typeof operations !== "undefined") { - - var cbcInstances = {}; - - msrcryptoCbc.workerEncrypt = function(p) { - - var result, - id = p.workerid; - - if (!cbcInstances[id]) { - cbcInstances[id] = msrcryptoCbc(msrcryptoBlockCipher.aes(p.keyData)); - cbcInstances[id].init(p.algorithm.iv); - } - - if (p.operationSubType === "process") { - return cbcInstances[id].processEncrypt(p.buffer); - } - - if (p.operationSubType === "finish") { - result = cbcInstances[id].finishEncrypt(); - cbcInstances[id] = null; - return result; - } - - result = cbcInstances[id].encrypt(p.buffer); - cbcInstances[id] = null; - return result; - }; - - msrcryptoCbc.workerDecrypt = function(p) { - - var result, - id = p.workerid; - - if (!cbcInstances[id]) { - cbcInstances[id] = msrcryptoCbc(msrcryptoBlockCipher.aes(p.keyData)); - cbcInstances[id].init(p.algorithm.iv); - } - - if (p.operationSubType === "process") { - cbcInstances[id].processDecrypt(p.buffer); - return; - } - - if (p.operationSubType === "finish") { - result = cbcInstances[id].finishDecrypt(); - cbcInstances[id] = null; - return result; - } - - result = cbcInstances[id].decrypt(p.buffer); - cbcInstances[id] = null; - return result; - }; - - msrcryptoCbc.generateKey = function(p) { - - if (p.algorithm.length % 8 !== 0) { - throw new Error(); - } - - return { - type: "keyGeneration", - keyData: msrcryptoPseudoRandom.getBytes(Math.floor(p.algorithm.length / 8)), - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: null || p.usages, - type: "secret" - } - }; - }; - - msrcryptoCbc.importKey = function(p) { - - var keyObject; - var keyBits = p.keyData.length * 8; - - if (p.format === "jwk") { - keyObject = msrcryptoJwk.jwkToKey(p.keyData, p.algorithm, ["k"]); - } else if (p.format === "raw") { - if (keyBits !== 128 && keyBits !== 192 && keyBits !== 256) { - throw new Error("invalid key length (should be 128, 192, or 256 bits)"); - } - keyObject = { - k: msrcryptoUtilities.toArray(p.keyData) - }; - } else { - throw new Error("unsupported import format"); - } - - p.algorithm.length = keyObject.k.length * 8; - - return { - keyData: keyObject.k, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable || keyObject.extractable, - usages: null || p.usages, - type: "secret" - }, - type: "keyImport" - }; - }; - - msrcryptoCbc.exportKey = function(p) { - - if (p.format === "jwk") { - return { - type: "keyExport", - keyHandle: msrcryptoJwk.keyToJwk(p.keyHandle, p.keyData) - }; - } - - if (p.format === "raw") { - return { - type: "keyExport", - keyHandle: p.keyData - }; - } - - throw new Error("unsupported export format"); - }; - - operations.register("importKey", "AES-CBC", msrcryptoCbc.importKey); - operations.register("exportKey", "AES-CBC", msrcryptoCbc.exportKey); - operations.register("generateKey", "AES-CBC", msrcryptoCbc.generateKey); - operations.register("encrypt", "AES-CBC", msrcryptoCbc.workerEncrypt); - operations.register("decrypt", "AES-CBC", msrcryptoCbc.workerDecrypt); - } - - var msrcryptoGcm = function(blockCipher) { - - var utils = msrcryptoUtilities; - - var mBuffer = [], - mIvBytes, - mAdditionalBytes, - mTagLength, - mJ0, - mJ0inc, - mH = blockCipher.encrypt(utils.getVector(16)), - mGHashState = utils.getVector(16), - mGHashBuffer = [], - mCipherText = [], - mGctrCb, - mBytesProcessed = 0; - - function ghash(hashSubkey, dataBytes) { - - var blockCount = Math.floor(dataBytes.length / 16), - dataBlock; - - for (var i = 0; i < blockCount; i++) { - dataBlock = dataBytes.slice(i * 16, i * 16 + 16); - mGHashState = blockMultiplication(utils.xorVectors(mGHashState, dataBlock), hashSubkey); - } - - mGHashBuffer = dataBytes.slice(blockCount * 16); - - return mGHashState; - } - - function finishGHash() { - - var u = 16 * Math.ceil(mBytesProcessed / 16) - mBytesProcessed; - - var lenA = numberTo8Bytes(mAdditionalBytes.length * 8), - lenC = numberTo8Bytes(mBytesProcessed * 8); - - var p = mGHashBuffer.concat(utils.getVector(u)).concat(lenA).concat(lenC); - - return ghash(mH, p); - - } - - function blockMultiplication(blockX, blockY) { - - var z = utils.getVector(16), - v = blockY.slice(0), - mask, - j, i; - - for (i = 0; i < 128; i++) { - - mask = -getBit(blockX, i) & 0xff; - - for (j = 0; j < 16; j++) { - z[j] = z[j] ^ v[j] & mask; - } - - mask = -(v[15] & 1) & 0xff; - - shiftRight(v); - - v[0] ^= 0xe1 & mask; - } - - return z; - } - - function shiftRight(dataBytes) { - - for (var i = dataBytes.length - 1; i > 0; i--) { - dataBytes[i] = (dataBytes[i - 1] & 1) << 7 | dataBytes[i] >>> 1; - } - dataBytes[0] = dataBytes[0] >>> 1; - - return dataBytes; - } - - function getBit(byteArray, bitNumber) { - var byteIndex = Math.floor(bitNumber / 8); - return byteArray[byteIndex] >> 7 - bitNumber % 8 & 1; - } - - function inc(dataBytes) { - - var carry = 256; - for (var i = 1; i <= 4; i++) { - carry = (carry >>> 8) + dataBytes[dataBytes.length - i]; - dataBytes[dataBytes.length - i] = carry & 255; - } - - return dataBytes; - } - - function gctr(icb, dataBytes) { - - var blockCount = Math.ceil(dataBytes.length / 16), - dataBlock, - result = []; - - if (mGctrCb !== icb) { - mGctrCb = icb.slice(); - } - - for (var block = 0; block < blockCount; block++) { - - dataBlock = dataBytes.slice(block * 16, block * 16 + 16); - - var e = blockCipher.encrypt(mGctrCb.slice()); - - result = result.concat(utils.xorVectors(dataBlock, e)); - - mGctrCb = inc(mGctrCb); - } - - return result; - } - - function numberTo8Bytes(integer) { - return [ - 0, 0, 0, 0, - integer >>> 24 & 255, - integer >>> 16 & 255, - integer >>> 8 & 255, - integer & 255 - ]; - } - - function padBlocks(dataBytes) { - var padLen = 16 * Math.ceil(mAdditionalBytes.length / 16) - mAdditionalBytes.length; - return dataBytes.concat(utils.getVector(padLen)); - } - - function clearState() { - mBytesProcessed = 0; - mBuffer = []; - mCipherText = []; - mGHashState = utils.getVector(16); - mGHashBuffer = []; - mGctrCb = mIvBytes = mAdditionalBytes = null; - } - - function init(ivBytes, additionalBytes, tagLength) { - - mAdditionalBytes = additionalBytes || []; - - mTagLength = isNaN(tagLength) ? 128 : tagLength; - if (mTagLength % 8 !== 0) { - throw new Error("DataError"); - } - - mIvBytes = ivBytes; - - if (mIvBytes.length === 12) { - mJ0 = mIvBytes.concat([0, 0, 0, 1]); - - } else { - var l = 16 * Math.ceil(mIvBytes.length / 16) - mIvBytes.length; - - mJ0 = ghash(mH, - mIvBytes - .concat(utils.getVector(l + 8)) - .concat(numberTo8Bytes(mIvBytes.length * 8))); - - mGHashState = utils.getVector(16); - } - - mJ0inc = inc(mJ0.slice()); - - ghash(mH, padBlocks(mAdditionalBytes)); - } - - function encrypt(plainBytes) { - - mBytesProcessed = plainBytes.length; - - var c = gctr(mJ0inc, plainBytes); - - ghash(mH, c); - - var s = finishGHash(); - - var t = gctr(mJ0, s).slice(0, mTagLength / 8); - - clearState(); - - return c.slice().concat(t); - } - - function decrypt(cipherBytes, tagBytes) { - - mBytesProcessed = cipherBytes.length; - - var p = gctr(mJ0inc, cipherBytes); - - ghash(mH, cipherBytes); - - var s = finishGHash(); - - var t = gctr(mJ0, s).slice(0, mTagLength / 8); - - clearState(); - - if (utils.arraysEqual(t, tagBytes)) { - return p; - } else { - return null; - } - } - - function processEncrypt(plainBytes) { - - mBuffer = mBuffer.concat(plainBytes); - - var fullBlocks = mBuffer.slice(0, Math.floor(mBuffer.length / 16) * 16); - - mBytesProcessed += fullBlocks.length; - - mBuffer = mBuffer.slice(fullBlocks.length); - - var c = gctr(mGctrCb || mJ0inc, fullBlocks); - - mCipherText = mCipherText.concat(c); - - ghash(mH, c); - } - - function processDecrypt(cipherBytes) { - - mBuffer = mBuffer.concat(cipherBytes); - - var fullBlocks = mBuffer.slice(0, Math.floor((mBuffer.length - mTagLength / 8) / 16) * 16); - - mBytesProcessed += fullBlocks.length; - - mBuffer = mBuffer.slice(fullBlocks.length); - - var c = gctr(mGctrCb || mJ0inc, fullBlocks); - - mCipherText = mCipherText.concat(c); - - ghash(mH, fullBlocks); - } - - function finishEncrypt() { - - var c = gctr(mGctrCb, mBuffer); - - mCipherText = mCipherText.concat(c); - - mBytesProcessed += mBuffer.length; - - var s = finishGHash(); - - var t = gctr(mJ0, s).slice(0, mTagLength / 8); - - var result = mCipherText.slice().concat(t); - - clearState(); - - return result; - } - - function finishDecrypt() { - - var tagLength = Math.floor(mTagLength / 8); - - var tagBytes = mBuffer.slice(-tagLength); - - mBuffer = mBuffer.slice(0, mBuffer.length - tagLength); - - var c = gctr(mGctrCb, mBuffer); - - mCipherText = mCipherText.concat(c); - - mBytesProcessed += mBuffer.length; - - var s = finishGHash(); - - var t = gctr(mJ0, s).slice(0, mTagLength / 8); - - var result = mCipherText.slice(); - - clearState(); - - if (utils.arraysEqual(t, tagBytes)) { - return result; - } else { - return null; - } - } - - return { - init: init, - encrypt: encrypt, - decrypt: decrypt, - processEncrypt: processEncrypt, - processDecrypt: processDecrypt, - finishEncrypt: finishEncrypt, - finishDecrypt: finishDecrypt - }; - - }; - - if (typeof operations !== "undefined") { - - var gcmInstances = {}; - - msrcryptoGcm.encrypt = function(p) { - - var result, - id = p.workerid; - - if (!gcmInstances[id]) { - gcmInstances[id] = msrcryptoGcm(msrcryptoBlockCipher.aes(p.keyData)); - gcmInstances[id].init(p.algorithm.iv, p.algorithm.additionalData, p.algorithm.tagLength); - } - - if (p.operationSubType === "process") { - gcmInstances[id].processEncrypt(p.buffer); - return; - } - - if (p.operationSubType === "finish") { - result = gcmInstances[id].finishEncrypt(); - gcmInstances[id] = null; - return result; - } - - result = gcmInstances[id].encrypt(p.buffer); - gcmInstances[id] = null; - return result; - }; - - msrcryptoGcm.decrypt = function(p) { - - var result, - id = p.workerid; - - if (!gcmInstances[id]) { - gcmInstances[id] = msrcryptoGcm(msrcryptoBlockCipher.aes(p.keyData)); - gcmInstances[id].init(p.algorithm.iv, p.algorithm.additionalData, p.algorithm.tagLength); - } - - if (p.operationSubType === "process") { - gcmInstances[id].processDecrypt(p.buffer); - return; - } - - if (p.operationSubType === "finish") { - result = gcmInstances[id].finishDecrypt(); - gcmInstances[id] = null; - if (result === null) { - throw new Error("OperationError"); - } - return result; - } - - var tagLength = p.algorithm.tagLength ? Math.floor(p.algorithm.tagLength / 8) : 16; - var cipherBytes = p.buffer.slice(0, p.buffer.length - tagLength); - var tagBytes = p.buffer.slice(-tagLength); - - result = gcmInstances[id].decrypt(cipherBytes, tagBytes); - gcmInstances[id] = null; - - if (result === null) { - throw new Error("OperationError"); - } - - return result; - }; - - msrcryptoGcm.generateKey = function(p) { - - if (p.algorithm.length % 8 !== 0) { - throw new Error(); - } - - return { - type: "keyGeneration", - keyData: msrcryptoPseudoRandom.getBytes(Math.floor(p.algorithm.length / 8)), - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: null || p.usages, - type: "secret" - } - }; - }; - - msrcryptoGcm.importKey = function(p) { - - var keyObject, - keyBits = p.keyData.length * 8; - - if (p.format === "jwk") { - keyObject = msrcryptoJwk.jwkToKey(p.keyData, p.algorithm, ["k"]); - } else if (p.format === "raw") { - if (keyBits !== 128 && keyBits !== 192 && keyBits !== 256) { - throw new Error("invalid key length (should be 128, 192, or 256 bits)"); - } - keyObject = { - k: msrcryptoUtilities.toArray(p.keyData) - }; - } else { - throw new Error("unsupported import format"); - } - - return { - type: "keyImport", - keyData: keyObject.k, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable || keyObject.extractable, - usages: null || p.usages, - type: "secret" - } - }; - }; - - msrcryptoGcm.exportKey = function(p) { - - if (p.format === "jwk") { - return { - type: "keyExport", - keyHandle: msrcryptoJwk.keyToJwk(p.keyHandle, p.keyData) - }; - } - - if (p.format === "raw") { - return { - type: "keyExport", - keyHandle: p.keyData - }; - } - - throw new Error("unsupported export format"); - }; - - operations.register("importKey", "AES-GCM", msrcryptoGcm.importKey); - operations.register("exportKey", "AES-GCM", msrcryptoGcm.exportKey); - operations.register("generateKey", "AES-GCM", msrcryptoGcm.generateKey); - operations.register("encrypt", "AES-GCM", msrcryptoGcm.encrypt); - operations.register("decrypt", "AES-GCM", msrcryptoGcm.decrypt); - } - - var msrcryptoAESKW = function(blockCipher) { - function encrypt(buffer) { - var plain = [ - [0] - ]; - for (var i = 0; i < buffer.length; i += 8) { - plain.push(buffer.slice(i, i + 8)); - } - - var A = [166, 166, 166, 166, 166, 166, 166, 166]; - var n = plain.length - 1; - var registers = []; - - for (var i = 1; i <= n; i++) { - registers[i] = plain[i]; - } - - for (var j = 0; j <= 5; j++) { - for (var i = 1; i <= n; i++) { - var t = n * j + i; - - var enc = blockCipher.encrypt(A.concat(registers[i])); - - registers[i] = enc.slice(8); - - A = enc.slice(0, 8); - for (var ai = 7; t > 0; ai--, t >>>= 8) { - A[ai] ^= t & 255; - } - } - } - - var C = A; - for (var i = 1; i <= n; i++) { - C = C.concat(registers[i]); - } - - return C; - } - - function decrypt(buffer) { - var cipher = []; - for (var i = 0; i < buffer.length; i += 8) { - cipher.push(buffer.slice(i, i + 8)); - } - - var n = cipher.length - 1; - var registers = []; - var plain = []; - - var A = cipher[0]; - for (var i = 1; i <= n; i++) { - registers[i] = cipher[i]; - } - - for (var j = 5; j >= 0; j--) { - for (var i = n; i >= 1; i--) { - var t = n * j + i; - for (var ai = 7; t > 0; ai--, t >>>= 8) { - A[ai] ^= t & 255; - } - var B = blockCipher.decrypt(A.concat(registers[i])); - A = B.slice(0, 8); - registers[i] = B.slice(8); - } - } - - if (A.join(",") !== "166,166,166,166,166,166,166,166") { - throw msrcryptoUtilities.error("OperationError", ""); - } - - for (var i = 1; i <= n; i++) { - plain = plain.concat(registers[i]); - } - - return plain; - } - - return { - encrypt: encrypt, - decrypt: decrypt - }; - }; - - if (typeof operations !== "undefined") { - var aeskwInstances = {}; - - msrcryptoAESKW.workerEncrypt = function(p) { - var result, - id = p.workerid; - - if (p.buffer.length % 8 !== 0) { - throw msrcryptoUtilities.error( - "DataError", - "The AES-KW input data length is invalid: not a multiple of 8 bytes" - ); - } - - if (!aeskwInstances[id]) { - aeskwInstances[id] = msrcryptoAESKW(msrcryptoBlockCipher.aes(p.keyData)); - } - - result = aeskwInstances[id].encrypt(p.buffer); - aeskwInstances[id] = null; - return result; - }; - - msrcryptoAESKW.workerDecrypt = function(p) { - var result, - id = p.workerid; - - if (p.buffer.length % 8 !== 0) { - throw msrcryptoUtilities.error( - "DataError", - "The AES-KW input data length is invalid: not a multiple of 8 bytes" - ); - } - - if (!aeskwInstances[id]) { - aeskwInstances[id] = msrcryptoAESKW(msrcryptoBlockCipher.aes(p.keyData)); - } - - result = aeskwInstances[id].decrypt(p.buffer); - aeskwInstances[id] = null; - return result; - }; - - msrcryptoAESKW.generateKey = function(p) { - if (p.algorithm.length % 8 !== 0) { - throw msrcryptoUtilities.error("OperationError", "AES key length must be 128, 192, or 256 bits"); - } - - return { - type: "keyGeneration", - keyData: msrcryptoPseudoRandom.getBytes(Math.floor(p.algorithm.length / 8)), - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: null || p.usages, - type: "secret" - } - }; - }; - - msrcryptoAESKW.importKey = function(p) { - var keyObject; - var keyBits = p.keyData.length * 8; - - if (p.format === "jwk") { - keyObject = msrcryptoJwk.jwkToKey(p.keyData, p.algorithm, ["k"]); - } else if (p.format === "raw") { - if (keyBits !== 128 && keyBits !== 192 && keyBits !== 256) { - throw msrcryptoUtilities.error("OperationError", "AES key length must be 128, 192, or 256 bits"); - } - keyObject = { - k: msrcryptoUtilities.toArray(p.keyData) - }; - } else { - throw new TypeError("Invalid keyFormat argument"); - } - - p.algorithm.length = keyObject.k.length * 8; - - return { - keyData: keyObject.k, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable || keyObject.extractable, - usages: null || p.usages, - type: "secret" - }, - type: "keyImport" - }; - }; - - msrcryptoAESKW.exportKey = function(p) { - if (p.format === "jwk") { - return { - type: "keyExport", - keyHandle: msrcryptoJwk.keyToJwk(p.keyHandle, p.keyData) - }; - } - - if (p.format === "raw") { - return { - type: "keyExport", - keyHandle: p.keyData - }; - } - - throw new TypeError("Invalid keyFormat argument"); - }; - - operations.register("importKey", "AES-KW", msrcryptoAESKW.importKey); - operations.register("exportKey", "AES-KW", msrcryptoAESKW.exportKey); - operations.register("generateKey", "AES-KW", msrcryptoAESKW.generateKey); - operations.register("encrypt", "AES-KW", msrcryptoAESKW.workerEncrypt); - operations.register("decrypt", "AES-KW", msrcryptoAESKW.workerDecrypt); - } - - function MsrcryptoPrng() { - if (!(this instanceof MsrcryptoPrng)) { - throw new Error("create MsrcryptoPrng object with new keyword"); - } - - var initialized = false; - - var key; - var v; - var keyLen; - var seedLen; - var reseedCounter = 1; - var reseedInterval = Math.pow(2, 48); - - initialize(); - - function addOne(counter) { - var i; - for (i = counter.length - 1; i >= 0; i -= 1) { - counter[i] += 1; - if (counter[i] >= 256) { - counter[i] = 0; - } - if (counter[i]) { - break; - } - } - } - - function initialize() { - key = msrcryptoUtilities.getVector(32); - v = msrcryptoUtilities.getVector(16); - keyLen = 32; - seedLen = 48; - reseedCounter = 1; - } - - function reseed(entropy, additionalEntropy) { - additionalEntropy = additionalEntropy || [0]; - if (additionalEntropy.length > seedLen) { - throw new Error("Incorrect entropy or additionalEntropy length"); - } - additionalEntropy = additionalEntropy.concat(msrcryptoUtilities.getVector(seedLen - additionalEntropy.length)); - - entropy = entropy.concat(msrcryptoUtilities.getVector((seedLen - (entropy.length % seedLen)) % seedLen)); - for (var i = 0; i < entropy.length; i += seedLen) { - var seedMaterial = msrcryptoUtilities.xorVectors(entropy.slice(i, i + seedLen), additionalEntropy); - update(seedMaterial); - } - reseedCounter = 1; - } - - function update(providedData) { - var temp = []; - var blockCipher = new msrcryptoBlockCipher.aes(key); - while (temp.length < seedLen) { - addOne(v); - var toEncrypt = v.slice(0, 16); - var outputBlock = blockCipher.encrypt(toEncrypt); - temp = temp.concat(outputBlock); - } - temp = msrcryptoUtilities.xorVectors(temp, providedData); - key = temp.slice(0, keyLen); - v = temp.slice(keyLen); - } - - function generate(requestedBytes, additionalInput) { - if (requestedBytes >= 65536) { - throw new Error("too much random requested"); - } - if (reseedCounter > reseedInterval) { - throw new Error("Reseeding is required"); - } - if (additionalInput && additionalInput.length > 0) { - while (additionalInput.length < seedLen) { - additionalInput = additionalInput.concat( - msrcryptoUtilities.getVector(seedLen - additionalInput.length)); - } - update(additionalInput); - } else { - additionalInput = msrcryptoUtilities.getVector(seedLen); - } - var temp = []; - var blockCipher = new msrcryptoBlockCipher.aes(key); - while (temp.length < requestedBytes) { - addOne(v); - var toEncrypt = v.slice(0, v.length); - var outputBlock = blockCipher.encrypt(toEncrypt); - temp = temp.concat(outputBlock); - } - temp = temp.slice(0, requestedBytes); - update(additionalInput); - reseedCounter += 1; - return temp; - } - - return { - reseed: reseed, - getBytes: function(length, additionalInput) { - if (!initialized) { - throw new Error("can't get randomness before initialization"); - } - return generate(length, additionalInput); - }, - getNonZeroBytes: function(length, additionalInput) { - if (!initialized) { - throw new Error("can't get randomness before initialization"); - } - var result = []; - var buff; - while (result.length < length) { - buff = generate(length, additionalInput); - for (var i = 0; i < buff.length; i += 1) { - if (buff[i] !== 0) { - result.push(buff[i]); - } - } - } - return result.slice(0, length); - }, - init: function(entropy, personalization) { - if (entropy.length < seedLen) { - throw new Error("Initial entropy length too short"); - } - initialize(); - reseed(entropy, personalization); - initialized = true; - } - }; - } - - var msrcryptoPseudoRandom = new MsrcryptoPrng(); - - function MsrcryptoEntropy(global) { - var poolLength = 48; - var collectorPool = []; - var collectorPoolLength = 128; - var collectorsRegistered = 0; - var entropyPoolPrng = new MsrcryptoPrng(); - var initialized = false; - var cryptographicPRNGPresent = false; - var globalScope = global; - - function collectEntropy() { - - var headerList = ["Cookie", "RedirectUri", "ETag", "x-ms-client-antiforgery-id", "x-ms-client-request-id", - "x-ms-client-session-id", "SubscriptionPool" - ]; - - var i, pool = []; - - for (i = 0; i < poolLength; i += 1) { - pool[i] = Math.floor(Math.random() * 256); - } - - var prngCrypto = globalScope.crypto || globalScope.msCrypto; - if (prngCrypto && typeof prngCrypto.getRandomValues === "function") { - if (global.Uint8Array) { - var res = new global.Uint8Array(poolLength); - prngCrypto.getRandomValues(res); - pool = pool.concat(Array.apply(null, res)); - cryptographicPRNGPresent = true; - } - } - - if (typeof XMLHttpRequest !== "undefined") { - var req = new XMLHttpRequest(); - for (i = 0; i < headerList.length; i += 1) { - try { - var header = req.getResponseHeader(headerList[i]); - if (header) { - var arr = msrcryptoUtilities.stringToBytes(header); - pool = pool.concat(arr); - } - } catch (err) {} - } - } - if (!cryptographicPRNGPresent && canCollect) { - pool = pool.concat(collectorPool.splice(0, collectorPool.length)); - collectors.startCollectors(); - } - - initialized ? entropyPoolPrng.reseed(pool) : entropyPoolPrng.init(pool); - initialized = true; - } - - function updatePool(entropyData) { - for (var i = 0; i < entropyData.length; ++i) { - collectorPool.push(entropyData[i]); - } - if (collectorPool.length >= collectorPoolLength) { - collectors.stopCollectors(); - } - } - - var canCollect = (global && global.addEventListener) || - (typeof document !== "undefined" && document.attachEvent); - var collectors = (function() { - return { - startCollectors: function() { - if (!this.collectorsRegistered) { - if (global.addEventListener) { - global.addEventListener("mousemove", this.MouseEventCallBack, true); - global.addEventListener("load", this.LoadTimeCallBack, true); - } else if (document.attachEvent) { - document.attachEvent("onmousemove", this.MouseEventCallBack); - document.attachEvent("onload", this.LoadTimeCallBack); - } else { - throw new Error("Can't attach events for entropy collection"); - } - - this.collectorsRegistered = 1; - } - }, - stopCollectors: function() { - if (this.collectorsRegistered) { - if (global.removeEventListener) { - global.removeEventListener("mousemove", this.MouseEventCallBack, 1); - global.removeEventListener("load", this.LoadTimeCallBack, 1); - } else if (global.detachEvent) { - global.detachEvent("onmousemove", this.MouseEventCallBack); - global.detachEvent("onload", this.LoadTimeCallBack); - } - - this.collectorsRegistered = 0; - } - }, - MouseEventCallBack: function(eventData) { - var d = (new Date()).valueOf(); - var x = eventData.x || eventData.clientX || eventData.offsetX || 0; - var y = eventData.y || eventData.clientY || eventData.offsetY || 0; - var arr = [d & 0x0ff, (d >> 8) & 0x0ff, (d >> 16) & 0x0ff, (d >> 24) & 0x0ff, - x & 0x0ff, (x >> 8) & 0x0ff, y & 0x0ff, (y >> 8) & 0x0ff - ]; - - updatePool(arr); - }, - LoadTimeCallBack: function() { - var d = (new Date()).valueOf(); - var dateArray = [d & 0x0ff, (d >> 8) & 0x0ff, (d >> 16) & 0x0ff, (d >> 24) & 0x0ff]; - - updatePool(dateArray); - } - }; - })(); - - return { - init: function() { - collectEntropy(); - - if (!cryptographicPRNGPresent && !collectorsRegistered && canCollect) { - try { - collectors.startCollectors(); - } catch (e) {} - } - }, - - reseed: function(entropy) { - entropyPoolPrng.reseed(entropy); - }, - - read: function(length) { - if (!initialized) { - throw new Error("Entropy pool is not initialized."); - } - - var ret = entropyPoolPrng.getBytes(length); - - collectEntropy(); - - return ret; - } - }; - } - - var prime = (function() { - - var smallPrimes = []; - - var trialValues = []; - - var MAX_SMALL_PRIMES = 4096 * 4; - - function primeSieve(max) { - var numbers = new Array(max + 1), - results = [], - i, j, - limit = Math.sqrt(max) | 0; - - for (i = 3; i <= limit; i += 2) { - for (j = i * i; j <= max; j += i * 2) { - numbers[j] = 0; - } - } - - for (i = 3; i <= max; i += 2) { - if (numbers[i] !== 0) { - results.push(i); - } - } - - return results; - } - - function incrementalTrialDivision(increment) { - var i, - len = trialValues.length; - - for (i = 0; i < len; i++) { - if ((trialValues[i] + increment) % smallPrimes[i] === 0) { - return false; - } - } - - return true; - } - - function setupIncrementalTrialDivision(candidate) { - - var i, j, r, p, y, - primeCount, - len = candidate.length - 1, - db = cryptoMath.DIGIT_BASE, - h = candidate[len]; - - if (smallPrimes.length === 0) { - smallPrimes = primeSieve(MAX_SMALL_PRIMES); - } - primeCount = smallPrimes.length; - - trialValues = new Array(primeCount); - - for (i = 0; i < primeCount; i++) { - - j = len; - y = smallPrimes[i]; - - if (h < y) { - r = h; - j--; - } else { - r = 0; - } - - while (j >= 0) { - p = r * db + candidate[j--]; - r = p - (p / y | 0) * y; - } - - trialValues[i] = r; - } - - return; - } - - function largestDivisibleByPowerOfTwo(number) { - - var k = 0, - i = 0, - s = 0, - j; - if (cryptoMath.isZero(number)) { - return 0; - } - for (k = 0; number[k] === 0; k++) {} - for (i = 0, j = 2; number[k] % j === 0; j *= 2, i++) {} - return k * cryptoMath.DIGIT_BITS + i; - } - - function sizeInBits(digits) { - - var k = 0, - i = 0, - j = 0; - if (cryptoMath.isZero(digits)) { - return 0; - } - for (k = digits.length - 1; digits[k] === 0; k--) {} - for (i = cryptoMath.DIGIT_BITS - 1, j = (1 << i); i > 0; j = j >>> 1, i--) { - if ((digits[k] & j) !== 0) { - break; - } - } - return k * cryptoMath.DIGIT_BITS + i; - } - - function millerRabin(number, iterations) { - - var w = number; - var wminus1 = []; - cryptoMath.subtract(w, [1], wminus1); - - var a = largestDivisibleByPowerOfTwo(wminus1); - - var m = []; - cryptoMath.shiftRight(wminus1, m, a); - - var wlen = sizeInBits(w); - var b; - var montmul = cryptoMath.MontgomeryMultiplier(w); - - for (var i = 1; i <= iterations; i++) { - - var status = false; - - do { - b = getRandomOddNumber(wlen); - } while (cryptoMath.compareDigits(b, wminus1) >= 0); - - var z = []; - - montmul.modExp(b, m, z, true); - - if (cryptoMath.compareDigits(z, [1]) === 0 || cryptoMath.compareDigits(z, wminus1) === 0) { - continue; - } - - for (var j = 1; j < a; j++) { - - montmul.montgomeryMultiply(z, z, z); - - if (cryptoMath.compareDigits(z, wminus1) === 0) { - status = true; - break; - } - - if (cryptoMath.compareDigits(z, [1]) === 0) { - return false; - } - } - - if (status === false) { - return false; - } - } - - return true; - } - - function generatePrime(bits) { - - var candidate = getRandomOddNumber(bits), - inc = 0, - possiblePrime, - isPrime = false, - candidatePlusInc = []; - - setupIncrementalTrialDivision(candidate); - - while (true) { - - possiblePrime = incrementalTrialDivision(inc); - - if (possiblePrime) { - cryptoMath.add(candidate, [inc], candidatePlusInc); - if (millerRabin(candidatePlusInc, 6) === true) { - return candidatePlusInc; - } - } - - inc += 2; - } - - } - - function getRandomOddNumber(bits) { - - var numBytes = Math.ceil(bits / 8), - bytes = msrcryptoPseudoRandom.getBytes(numBytes), - digits; - - bytes[0] |= 128; - bytes[bytes.length - 1] |= 1; - - return cryptoMath.bytesToDigits(bytes); - - } - - return { - generatePrime: generatePrime - }; - - })(); - - var msrcryptoRsaBase = function(keyStruct) { - - var utils = msrcryptoUtilities, - keyIsPrivate = keyStruct.hasOwnProperty("n") && keyStruct.hasOwnProperty("d"), - keyIsCrt = keyStruct.hasOwnProperty("p") && keyStruct.hasOwnProperty("q"), - modulusLength = keyStruct.n.length; - - function toBytes(digits) { - - var bytes = cryptoMath.digitsToBytes(digits); - - utils.padFront(bytes, 0, modulusLength); - - return bytes; - } - - function modExp(dataBytes, expBytes, modulusBytes) { - var exponent = cryptoMath.bytesToDigits(expBytes); - - var group = cryptoMath.IntegerGroup(modulusBytes); - var base = group.createElementFromBytes(dataBytes); - var result = group.modexp(base, exponent); - - return result.m_digits; - } - - function decryptModExp(cipherBytes) { - - var resultElement = modExp(cipherBytes, keyStruct.d, keyStruct.n); - - return toBytes(resultElement); - } - - function decryptCrt(cipherBytes) { - - var b2d = cryptoMath.bytesToDigits, - p = keyStruct.p, - q = keyStruct.q, - dp = keyStruct.dp, - dq = keyStruct.dq, - invQ = keyStruct.qi, - pDigits = b2d(p), - qDigits = b2d(q), - temp = new Array(pDigits.length + qDigits.length), - m1Digits = new Array(pDigits.length + 1), - m2Digits = new Array(qDigits.length + 1), - cDigits = b2d(cipherBytes), - mm = cryptoMath.MontgomeryMultiplier, - mmp = new mm(keyStruct.ctxp ? undefined : pDigits, keyStruct.ctxp), - mmq = new mm(keyStruct.ctxq ? undefined : qDigits, keyStruct.ctxq); - - mmp.reduce(cDigits, temp); - mmp.modExp(temp, b2d(dp), m1Digits); - - mmq.reduce(cDigits, temp); - mmq.modExp(temp, b2d(dq), m2Digits); - - var carry = cryptoMath.subtract(m1Digits, m2Digits, temp); - if (carry !== 0) { - cryptoMath.subtract(m2Digits, m1Digits, temp); - } - - cryptoMath.modMul(temp, b2d(invQ), pDigits, cDigits); - if (carry !== 0) { - cryptoMath.subtract(pDigits, cDigits, cDigits); - } - - cryptoMath.multiply(cDigits, qDigits, temp); - cryptoMath.add(m2Digits, temp, m1Digits); - - return toBytes(m1Digits); - } - - return { - - encrypt: function(messageBytes) { - - var bytes = toBytes(modExp(messageBytes, keyStruct.e, keyStruct.n, true)); - return bytes; - - }, - - decrypt: function(cipherBytes) { - - if (keyIsCrt) { - return decryptCrt(cipherBytes); - } - - if (keyIsPrivate) { - return decryptModExp(cipherBytes); - } - - throw new Error("missing private key"); - } - }; - - }; - - var rsaShared = { - - mgf1: function(seedBytes, maskLen, hashFunction) { - - var t = [], - bytes, hash, counter, - hashByteLen = hashFunction.hashLen / 8; - - for (counter = 0; counter <= Math.floor(maskLen / hashByteLen); counter += 1) { - - bytes = [ - counter >>> 24 & 0xff, - counter >>> 16 & 0xff, - counter >>> 8 & 0xff, - counter & 0xff - ]; - hash = hashFunction.computeHash(seedBytes.concat(bytes)); - - t = t.concat(hash); - } - - return t.slice(0, maskLen); - }, - - checkMessageVsMaxHash: function(messageBytes, hashFunction) { - - if (messageBytes.length > (hashFunction.maxMessageSize || 0xFFFFFFFF)) { - throw new Error("message too long"); - } - - return; - } - - }; - - var rsaMode = rsaMode || {}; - - rsaMode.oaep = function(keyStruct, hashFunction) { - - var utils = msrcryptoUtilities, - random = msrcryptoPseudoRandom, - size = keyStruct.n.length; - - if (hashFunction === null) { - throw new Error("must supply hashFunction"); - } - - function pad(message, label) { - - var lHash, psLen, psArray, i, db, seed; - var dbMask, maskeddb, seedMask, maskedSeed; - var encodedMessage; - - if (message.length > (size - 2 * (hashFunction.hashLen / 8) - 2)) { - throw new Error("Message too long."); - } - - if (label == null) { - label = []; - } - - lHash = hashFunction.computeHash(label); - - psLen = size - message.length - (2 * lHash.length) - 2; - psArray = utils.getVector(psLen); - - db = lHash.concat(psArray, [1], message); - - seed = random.getBytes(lHash.length); - - dbMask = rsaShared.mgf1(seed, size - lHash.length - 1, hashFunction); - - maskeddb = utils.xorVectors(db, dbMask); - - seedMask = rsaShared.mgf1(maskeddb, lHash.length, hashFunction); - - maskedSeed = utils.xorVectors(seed, seedMask); - - encodedMessage = [0].concat(maskedSeed).concat(maskeddb); - - message = encodedMessage.slice(); - - return message; - } - - function unpad(encodedBytes, labelBytes) { - - var lHash, maskedSeed, maskeddb, seedMask; - var seed, dbMask, db; - var lHashp, i = 0; - var valid = encodedBytes[0] === 0; - - if (!labelBytes) { - labelBytes = []; - } - - lHash = hashFunction.computeHash(labelBytes); - - maskedSeed = encodedBytes.slice(1, lHash.length + 1); - maskeddb = encodedBytes.slice(lHash.length + 1); - - seedMask = rsaShared.mgf1(maskeddb, lHash.length, hashFunction); - seed = utils.xorVectors(maskedSeed, seedMask); - dbMask = rsaShared.mgf1(seed, size - lHash.length - 1, hashFunction); - - db = utils.xorVectors(maskeddb, dbMask); - - lHashp = db.slice(0, lHash.length); - - valid = valid && utils.arraysEqual(lHash, lHashp); - - db = db.slice(lHash.length); - - while (!db[i++]) {} - - return { - valid: valid, - data: db.slice(i) - }; - } - - return { - - pad: function(messageBytes, labelBytes) { - return pad(messageBytes, labelBytes); - }, - - unpad: function(encodedBytes, labelBytes) { - return unpad(encodedBytes, labelBytes); - } - }; - - }; - - var rsaMode = rsaMode || {}; - - rsaMode.pkcs1Encrypt = function(keyStruct) { - - var random = msrcryptoPseudoRandom, - size = keyStruct.n.length; - - function pad(data) { - - var randomness; - - if (data.length > size - 11) { - throw new Error("message too long"); - } - - randomness = random.getNonZeroBytes(size - data.length - 3); - - return [0, 2].concat(randomness, [0], data); - } - - function validatePadding(paddedData) { - var paddingValid = paddedData[0] === 0 && paddedData[1] === 2; - - for (var i = 2; i < 10; i++) { - paddingValid = paddingValid && !!paddedData[i]; - } - - return paddingValid; - } - - function unpad(paddedData) { - - var i, - paddingIsValid = validatePadding(paddedData), - startOfData = 0; - - for (i = 1; i < paddedData.length; i += 1) { - startOfData = startOfData || +!paddedData[i] && i + 1; - } - - startOfData = (-paddingIsValid && startOfData); - - return { - data: paddedData.slice(startOfData), - valid: paddingIsValid - }; - } - - return { - - pad: function(messageBytes) { - return pad(messageBytes); - }, - - unpad: function(encodedBytes) { - return unpad(encodedBytes); - } - }; - - }; - - rsaMode.pkcs1Sign = function(keyStruct, hashFunction) { - - var utils = msrcryptoUtilities, - size = keyStruct.n.length; - - function emsa_pkcs1_v15_encode(messageBytes) { - - var paddedData, - hash, - tlen; - - hash = hashFunction.computeHash(messageBytes.slice()); - - paddedData = hashFunction.der.concat(hash); - - tlen = paddedData.length; - - if (size < tlen + 11) { - throw new Error("intended encoded message length too short"); - } - - return [0x00, 0x01].concat( - utils.getVector(size - tlen - 3, 0xFF), - [0], - paddedData); - } - - return { - - sign: function(messageBytes) { - return emsa_pkcs1_v15_encode(messageBytes); - }, - - verify: function(signatureBytes, messageBytes) { - var emp = emsa_pkcs1_v15_encode(messageBytes); - - return utils.arraysEqual(signatureBytes, emp); - - } - }; - }; - - var rsaMode = rsaMode || {}; - - rsaMode.pss = function(keyStruct, hashFunction) { - var utils = msrcryptoUtilities, - random = msrcryptoPseudoRandom; - - function emsa_pss_encode(messageBytes, saltLength, salt) { - var modulusBits = cryptoMath.bitLength(keyStruct.n), - emBits = modulusBits - 1, - emLen = Math.ceil(emBits / 8), - mHash = hashFunction.computeHash(messageBytes); - - saltLength = salt ? salt.length : saltLength == null ? mHash.length : saltLength; - - if (emLen < mHash.length + saltLength + 2) { - throw new Error("encoding error"); - } - - salt = salt || random.getBytes(saltLength); - - var mp = [0, 0, 0, 0, 0, 0, 0, 0].concat(mHash, salt); - - var h = hashFunction.computeHash(mp); - - var ps = utils.getVector(emLen - salt.length - h.length - 2); - - var db = ps.concat([1], salt); - - var dbMask = rsaShared.mgf1(h, emLen - h.length - 1, hashFunction); - - var maskedDb = utils.xorVectors(db, dbMask); - - var mask = 0; - for (var i = 0; i < 8 - (8 * emLen - emBits); i++) { - mask += 1 << i; - } - maskedDb[0] &= mask; - - var em = maskedDb.concat(h, [0xbc]); - - return em; - } - - function emsa_pss_verify(signatureBytes, messageBytes, saltLength) { - var modulusBits = cryptoMath.bitLength(keyStruct.n); - - var emBits = modulusBits - 1; - - var emLen = Math.ceil(emBits / 8); - - var mHash = hashFunction.computeHash(messageBytes); - - var hLen = mHash.length; - - saltLength = saltLength == null ? hLen : saltLength; - - if (emLen < hLen + saltLength + 2) { - return false; - } - - var maskedDb = signatureBytes.slice(0, emLen - hLen - 1); - - var h = signatureBytes.slice(maskedDb.length, maskedDb.length + hLen); - - var dbMask = rsaShared.mgf1(h, emLen - hLen - 1, hashFunction); - - var db = utils.xorVectors(maskedDb, dbMask); - - db[0] &= 0xff >>> (8 - (8 * emLen - emBits)); - - for (var i = 0; i < emLen - hLen - saltLength - 2; i++) { - if (db[i] !== 0) { - return false; - } - } - - if (db[emLen - hLen - saltLength - 2] !== 0x01) { - return false; - } - - var salt = db.slice(db.length - saltLength); - - var mp = [0, 0, 0, 0, 0, 0, 0, 0].concat(mHash, salt); - - var hp = hashFunction.computeHash(mp); - - return utils.arraysEqual(hp, h); - } - - return { - sign: function(messageBytes, saltLength, salt) { - return emsa_pss_encode(messageBytes, saltLength, salt); - }, - - verify: function(signatureBytes, messageBytes, saltLength) { - return emsa_pss_verify(signatureBytes, messageBytes, saltLength); - } - }; - }; - - var msrcryptoRsa = function(keyStruct, mode, hashFunction) { - var rsaBase = msrcryptoRsaBase(keyStruct); - - if (!mode) { - throw new Error("padding mode"); - } - - function checkHash() { - if (!hashFunction || !hashFunction.computeHash) { - throw new Error("missing hash function"); - } - } - - var paddingFunction = null, - unPaddingFunction = null; - - var padding; - - switch (mode) { - - case "RSAES-PKCS1-V1_5": - padding = rsaMode.pkcs1Encrypt(keyStruct); - break; - - case "RSASSA-PKCS1-V1_5": - checkHash(); - padding = rsaMode.pkcs1Sign(keyStruct, hashFunction); - break; - - case "RSA-OAEP": - checkHash(); - padding = rsaMode.oaep(keyStruct, hashFunction); - break; - - case "RSA-PSS": - checkHash(); - padding = rsaMode.pss(keyStruct, hashFunction); - break; - - case "raw": - padding = { - pad: function(mb) { - return mb; - }, - unpad: function(eb) { - return eb; - } - }; - break; - - default: - throw new Error("invalid mode"); - } - - if (padding) { - paddingFunction = padding.pad || padding.sign; - unPaddingFunction = padding.unpad || padding.verify; - } - - var returnObj = { - encrypt: function(dataBytes, labelBytes) { - var paddedData; - var encryptedData; - - if (paddingFunction !== null) { - paddedData = paddingFunction(dataBytes, labelBytes); - } else { - paddedData = dataBytes.slice(); - } - - encryptedData = rsaBase.encrypt(paddedData); - - return encryptedData; - }, - - decrypt: function(cipherBytes, labelBytes) { - var decryptedData = rsaBase.decrypt(cipherBytes); - - if (unPaddingFunction !== null) { - decryptedData = unPaddingFunction(decryptedData, labelBytes); - if (decryptedData.valid === false) { - throw new Error("OperationError"); - } - - decryptedData = decryptedData.data; - - } else { - decryptedData = decryptedData.slice(0); - } - - return decryptedData; - }, - - signData: function(messageBytes, saltLength, salt) { - return rsaBase.decrypt(paddingFunction(messageBytes, saltLength, salt)); - }, - - verifySignature: function( - signature, - messageBytes, - saltLength - ) { - var decryptedSig = rsaBase.encrypt(signature); - - return unPaddingFunction(decryptedSig, messageBytes, saltLength); - }, - - generateKeyPair: function(bits) { - var keyPair = genRsaKeyFromRandom(bits); - }, - - mode: mode - }; - - return returnObj; - }; - - if (typeof operations !== "undefined") { - msrcryptoRsa.sign = function(p) { - var rsaObj, - hashName = p.keyHandle.algorithm.hash.name, - hashFunc = msrcryptoHashFunctions[hashName.toUpperCase()](), - saltLength = p.algorithm.saltLength, - salt = p.algorithm.salt; - - rsaObj = msrcryptoRsa(p.keyData, p.algorithm.name, hashFunc); - - return rsaObj.signData(p.buffer, saltLength, salt); - }; - - msrcryptoRsa.verify = function(p) { - var hashName = p.keyHandle.algorithm.hash.name, - hashFunc = msrcryptoHashFunctions[hashName.toUpperCase()](), - rsaObj, - saltLength = p.algorithm.saltLength; - - rsaObj = msrcryptoRsa(p.keyData, p.algorithm.name, hashFunc); - - return rsaObj.verifySignature(p.signature, p.buffer, saltLength); - }; - - msrcryptoRsa.workerEncrypt = function(p) { - var result, rsaObj, hashFunc, hashName; - - switch (p.algorithm.name) { - - case "RSAES-PKCS1-V1_5": - rsaObj = msrcryptoRsa(p.keyData, p.algorithm.name); - result = rsaObj.encrypt(p.buffer); - break; - - case "RSA-OAEP": - hashName = p.keyHandle.algorithm.hash.name; - if (!hashName) { - throw new Error("unsupported hash algorithm"); - } - hashFunc = msrcryptoHashFunctions[hashName.toUpperCase()](); - rsaObj = msrcryptoRsa(p.keyData, p.algorithm.name, hashFunc); - result = rsaObj.encrypt(p.buffer); - break; - - default: - throw new Error("unsupported algorithm"); - } - - return result; - }; - - msrcryptoRsa.workerDecrypt = function(p) { - var result, rsaObj, hashFunc; - - switch (p.algorithm.name) { - - case "RSAES-PKCS1-V1_5": - rsaObj = msrcryptoRsa(p.keyData, p.algorithm.name); - result = rsaObj.decrypt(p.buffer); - break; - - case "RSA-OAEP": - var hashName = p.keyHandle.algorithm.hash.name; - if (!hashName) { - throw new Error("unsupported hash algorithm"); - } - hashFunc = msrcryptoHashFunctions[hashName.toUpperCase()](); - rsaObj = msrcryptoRsa(p.keyData, p.algorithm.name, hashFunc); - result = rsaObj.decrypt(p.buffer); - break; - - default: - throw new Error("unsupported algorithm"); - } - - return result; - }; - - msrcryptoRsa.importKey = function(p) { - - var keyObject; - - if (p.format === "jwk") { - - keyObject = msrcryptoJwk.jwkToKey(p.keyData, p.algorithm, ["n", "e", "d", "p", "q", "dp", "dq", "qi"]); - - if (keyObject.d) { - keyObject.ctxp = new cryptoMath.MontgomeryMultiplier(cryptoMath.bytesToDigits(keyObject.p)).ctx; - keyObject.ctxq = new cryptoMath.MontgomeryMultiplier(cryptoMath.bytesToDigits(keyObject.q)).ctx; - } - - } else if (p.format === "spki") { - - var publicKeyInfo = asn1.parse(p.keyData); - - if (publicKeyInfo == null) { - throw new Error("invalid key data."); - } - - var octetString = publicKeyInfo[1]; - var keySequence = asn1.parse(octetString.data.slice(octetString.header + 1), true); - - if (keySequence == null) { - throw new Error("invalid key data."); - } - - var n = keySequence[0], - e = keySequence[1]; - - if (n.type !== "INTEGER" || e.type !== "INTEGER") { - throw new Error("invalid key data."); - } - - n = n.data.slice(n.header); - e = e.data.slice(e.header); - - if (n[0] === 0 && n[1] & 128) { - n = n.slice(1); - } - if (e[0] === 0 && e[1] & 128) { - e = e.slice(1); - } - - keyObject = { - n: n, - e: e - }; - - } else if (p.format === "pkcs8") { - var publicKeyInfo = asn1.parse(p.keyData); - - if (publicKeyInfo == null) { - throw new Error("invalid key data."); - } - - var octetString = publicKeyInfo[2]; - var keySequence = asn1.parse(octetString.data.slice(octetString.header), true); - - if (keySequence == null) { - throw new Error("invalid key data."); - } - - var keyProps = ["n", "e", "d", "p", "q", "dp", "dq", "qi"]; - keyObject = {}; - - for (var i = 1; i < keySequence.length; i++) { - var int = keySequence[i]; - int = int.data.slice(int.header); - if (int[0] === 0 && int[1] & 128) { - int = int.slice(1); - } - keyObject[keyProps[i - 1]] = int; - } - } else { - throw new Error("unsupported key import format."); - } - - return { - type: "keyImport", - keyData: keyObject, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: p.usages, - type: keyObject.d || keyObject.dq ? "private" : "public" - } - }; - }; - - msrcryptoRsa.exportKey = function(p) { - var RSA_ENCRYPTION = "1.2.840.113549.1.1.1"; - - if (p.format === "jwk") { - var jsonKeyStringArray = msrcryptoJwk.keyToJwk(p.keyHandle, p.keyData); - return { - type: "keyExport", - keyHandle: jsonKeyStringArray - }; - } - - if (p.format === "spki") { - var bytes = asn1.encode({ - SEQUENCE: [{ - SEQUENCE: [{ - "OBJECT IDENTIFIER": RSA_ENCRYPTION - }, { - NULL: 1 - }] - }, - { - "BIT STRING": { - SEQUENCE: [{ - INTEGER: p.keyData.n - }, { - INTEGER: p.keyData.e - }] - } - } - ] - }); - - return { - type: "keyExport", - keyHandle: bytes - }; - } - - if (p.format === "pkcs8") { - var bytes = asn1.encode({ - SEQUENCE: [{ - INTEGER: 0 - }, - { - SEQUENCE: [{ - "OBJECT IDENTIFIER": RSA_ENCRYPTION - }, { - NULL: 1 - }] - }, - { - "OCTET STRING": { - SEQUENCE: [{ - INTEGER: 0 - }, - { - INTEGER: p.keyData.n - }, - { - INTEGER: p.keyData.e - }, - { - INTEGER: p.keyData.d - }, - { - INTEGER: p.keyData.p - }, - { - INTEGER: p.keyData.q - }, - { - INTEGER: p.keyData.dp - }, - { - INTEGER: p.keyData.dq - }, - { - INTEGER: p.keyData.qi - } - ] - } - } - ] - }); - - return { - type: "keyExport", - keyHandle: bytes - }; - } - - throw new Error(p.format + " not implemented"); - }; - - msrcryptoRsa.genRsaKeyFromRandom = function(bits, e) { - var exp = e ? cryptoMath.bytesToDigits(e) : [65537]; - - do { - var p = prime.generatePrime(bits / 2); - - var q = prime.generatePrime(bits / 2); - - if (cryptoMath.compareDigits(q, p) > 0) { - var t = p; - p = q; - q = t; - } - - var n = []; - cryptoMath.multiply(p, q, n); - - var p_1 = []; - cryptoMath.subtract(p, [1], p_1); - - var q_1 = []; - cryptoMath.subtract(q, [1], q_1); - - var p_1q_1 = []; - cryptoMath.multiply(p_1, q_1, p_1q_1); - - var gcd = []; - cryptoMath.gcd(exp, p_1q_1, gcd); - - var gcdEqual1 = cryptoMath.compareDigits(gcd, cryptoMath.One) === 0; - - } while (!gcdEqual1); - - var d = []; - cryptoMath.modInv(exp, p_1q_1, d); - - var dp = []; - cryptoMath.reduce(d, p_1, dp); - - var dq = []; - cryptoMath.reduce(d, q_1, dq); - - var qi = []; - cryptoMath.modInv(q, p, qi); - - var d2b = cryptoMath.digitsToBytes; - - return { - privateKey: { - n: d2b(n), - e: d2b(exp), - d: d2b(d), - p: d2b(p), - q: d2b(q), - dp: d2b(dp), - dq: d2b(dq), - qi: d2b(qi) - }, - publicKey: { - n: d2b(n), - e: d2b(exp) - } - }; - }; - - msrcryptoRsa.generateKeyPair = function(p) { - if (typeof p.algorithm.modulusLength === "undefined") { - throw new Error("missing modulusLength"); - } - - var keyPair; - var b2d = cryptoMath.bytesToDigits; - - switch (p.algorithm.modulusLength) { - case 1024: - case 2048: - case 4096: - keyPair = msrcryptoRsa.genRsaKeyFromRandom(p.algorithm.modulusLength, p.algorithm.publicExponent); - break; - default: - throw new Error("invalid modulusLength"); - } - - var pk = keyPair.privateKey; - pk.ctxp = (new cryptoMath.MontgomeryMultiplier(b2d(pk.p))).ctx; - pk.ctxq = (new cryptoMath.MontgomeryMultiplier(b2d(pk.q))).ctx; - - var algName = p.algorithm.name; - var rsaKeyType = algName.slice(algName.indexOf("-") + 1).toUpperCase(); - - var publicUsage, privateUsage; - - if (algName === "RSASSA-PKCS1-V1_5" || algName === "RSA-PSS") { - publicUsage = ["verify"]; - privateUsage = ["sign"]; - } else { - publicUsage = ["encrypt"]; - privateUsage = ["decrypt"]; - } - - return { - type: "keyGeneration", - keyPair: { - publicKey: { - keyData: keyPair.publicKey, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: null || publicUsage, - type: "public" - } - }, - privateKey: { - keyData: keyPair.privateKey, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: null || privateUsage, - type: "private" - } - } - } - }; - }; - - operations.register("sign", "RSASSA-PKCS1-V1_5", msrcryptoRsa.sign); - operations.register("sign", "RSA-PSS", msrcryptoRsa.sign); - - operations.register("verify", "RSASSA-PKCS1-V1_5", msrcryptoRsa.verify); - operations.register("verify", "RSA-PSS", msrcryptoRsa.verify); - - operations.register("encrypt", "RSAES-PKCS1-V1_5", msrcryptoRsa.workerEncrypt); - operations.register("decrypt", "RSAES-PKCS1-V1_5", msrcryptoRsa.workerDecrypt); - operations.register("encrypt", "RSA-OAEP", msrcryptoRsa.workerEncrypt); - operations.register("decrypt", "RSA-OAEP", msrcryptoRsa.workerDecrypt); - - operations.register("importKey", "RSA-OAEP", msrcryptoRsa.importKey); - operations.register("importKey", "RSAES-PKCS1-V1_5", msrcryptoRsa.importKey); - operations.register("importKey", "RSASSA-PKCS1-V1_5", msrcryptoRsa.importKey); - operations.register("importKey", "RSA-PSS", msrcryptoRsa.importKey); - - operations.register("exportKey", "RSA-OAEP", msrcryptoRsa.exportKey); - operations.register("exportKey", "RSAES-PKCS1-V1_5", msrcryptoRsa.exportKey); - operations.register("exportKey", "RSASSA-PKCS1-V1_5", msrcryptoRsa.exportKey); - operations.register("exportKey", "RSA-PSS", msrcryptoRsa.exportKey); - - operations.register("generateKey", "RSA-OAEP", msrcryptoRsa.generateKeyPair); - operations.register("generateKey", "RSAES-PKCS1-V1_5", msrcryptoRsa.generateKeyPair); - operations.register("generateKey", "RSASSA-PKCS1-V1_5", msrcryptoRsa.generateKeyPair); - operations.register("generateKey", "RSA-PSS", msrcryptoRsa.generateKeyPair); - } - - var msrcryptoConcatKdf = (function() { - - function deriveBits(p) { - - var hashName = p.algorithm.hash.name, - hashFunction = msrcryptoHashFunctions[hashName.toUpperCase()](), - alg = p.algorithm; - - var otherInfo = - utils.toArray(alg.algorithmId).concat( - utils.toArray(alg.partyUInfo), - utils.toArray(alg.partyVInfo), - utils.toArray(alg.publicInfo) || [], - utils.toArray(alg.privateInfo) || []); - - var reps = Math.ceil(p.length / hashFunction.hashLen), - counter = 1, - digest = p.keyData.concat(otherInfo), - output = []; - - for (var i = 0; i < reps; i++) { - var data = utils.int32ToBytes(counter++).concat(digest); - var h = hashFunction.computeHash(data); - output = output.concat(h); - } - - return output.slice(0, p.length / 8); - - } - - return { - deriveBits: deriveBits - }; - - }()); - - var msrcryptoConcatKdfInstance = null; - - if (typeof operations !== "undefined") { - - msrcryptoConcatKdf.importKey = function(p) { - var keyData; - - if (p.format === "raw") { - keyData = msrcryptoUtilities.toArray(p.keyData); - } else { - throw new Error("unsupported import format"); - } - - if (p.extractable !== false) { - throw new Error("only extractable=false is supported."); - } - - return { - type: "keyImport", - keyData: keyData, - keyHandle: { - algorithm: { - name: "CONCAT" - }, - extractable: false, - usages: p.usages, - type: "secret" - } - }; - - }; - - operations.register("deriveBits", "CONCAT", msrcryptoConcatKdf.deriveBits); - operations.register("importKey", "CONCAT", msrcryptoConcatKdf.importKey); - } - - var msrcryptoPbkdf2 = (function() { - - function deriveBits(p) { - - var algorithm = p.algorithm, - keyBytes = p.keyData, - bits = p.length, - iterations = algorithm.iterations, - saltBytes = Array.apply(null, algorithm.salt), - byteLen = Math.ceil(bits / 8), - hLen, - blockCount, - output = []; - - switch (algorithm.hash.name.toUpperCase()) { - case "SHA-1": - hLen = 20; - break; - case "SHA-256": - hLen = 32; - break; - case "SHA-384": - hLen = 48; - break; - case "SHA-512": - hLen = 64; - break; - default: - throw new Error("Unsupported hash algorithm"); - } - - blockCount = Math.ceil(byteLen / hLen); - - var hmacKey = msrcryptoHmac.importKey({ - format: "raw", - keyData: keyBytes, - algorithm: { - name: "HMAC", - hash: algorithm.hash - } - }); - - var hmacContext = { - algorithm: algorithm, - keyHandle: hmacKey.keyHandle, - keyData: hmacKey.keyData, - workerid: 0, - buffer: null - }; - - function F(S, c, i) { - - var result = [], - u = S.concat([i >>> 24 & 0xFF, i >>> 16 & 0xFF, i >>> 8 & 0xFF, i & 0xFF]); - - for (var j = 0; j < c; j++) { - hmacContext.buffer = u; - u = msrcryptoHmac.signHmac(hmacContext); - for (var k = 0; k < hLen; k++) { - result[k] = ~~result[k] ^ u[k]; - } - } - - return result; - } - - for (var block = 1; block <= blockCount; block++) { - output = output.concat(F(saltBytes, iterations, block)); - } - - output.length = byteLen; - - return output; - } - - return { - - deriveBits: deriveBits - - }; - - }()); - - var msrcryptoKdfInstance = null; - - if (typeof operations !== "undefined") { - - msrcryptoPbkdf2.importKey = function(p) { - var keyData; - - if (p.format === "raw") { - keyData = msrcryptoUtilities.toArray(p.keyData); - } else { - throw new Error("unsupported import format"); - } - - if (p.extractable !== false) { - throw new Error("only extractable=false is supported."); - } - - return { - type: "keyImport", - keyData: keyData, - keyHandle: { - algorithm: { - name: "PBKDF2" - }, - extractable: false, - usages: p.usages, - type: "secret" - } - }; - - }; - - operations.register("deriveBits", "PBKDF2", msrcryptoPbkdf2.deriveBits); - operations.register("importKey", "PBKDF2", msrcryptoPbkdf2.importKey); - } - - var msrcryptoHkdf = (function() { - - function deriveBits(p) { - - var algorithm = p.algorithm, - keyBytes = p.keyData, - bits = p.length, - saltBytes = algorithm.salt, - byteLen = Math.ceil(bits / 8), - hLen, - output = [], - infoBytes = msrcryptoUtilities.toArray(algorithm.info), - t = [], - i, - hmacContext; - - switch (algorithm.hash.name.toUpperCase()) { - case "SHA-1": - hLen = 20; - break; - case "SHA-256": - hLen = 32; - break; - case "SHA-384": - hLen = 48; - break; - case "SHA-512": - hLen = 64; - break; - default: - throw new Error("Unsupported hash algorithm."); - } - - if (algorithm.salt == null) { - throw new Error("HkdfParams: salt: Missing required property."); - } - - if (algorithm.info == null) { - throw new Error("HkdfParams: info: Missing required property."); - } - - if (bits % 8 !== 0) { - throw new Error("The length provided for HKDF is not a multiple of 8 bits."); - } - - if (byteLen > 255 * hLen) { - throw new Error("The length provided for HKDF is too large."); - } - - if (saltBytes.length === 0) { - saltBytes = msrcryptoUtilities.getVector(hLen); - } - - hmacContext = { - workerid: 0, - keyHandle: { - algorithm: algorithm - }, - keyData: saltBytes, - buffer: keyBytes - }; - - hmacContext.keyData = msrcryptoHmac.signHmac(hmacContext); - - for (i = 0; i < Math.ceil(byteLen / hLen); i++) { - hmacContext.buffer = t.concat(infoBytes).concat([1 + i]); - t = msrcryptoHmac.signHmac(hmacContext); - output = output.concat(t); - } - - return output.slice(0, byteLen); - } - - return { - - deriveBits: deriveBits - - }; - - }()); - - var msrcryptoKdfInstance = null; - - if (typeof operations !== "undefined") { - - msrcryptoHkdf.importKey = function(p) { - var keyData; - - if (p.format === "raw") { - keyData = msrcryptoUtilities.toArray(p.keyData); - } else { - throw new Error("unsupported import format"); - } - - if (p.extractable !== false) { - throw new Error("only extractable=false is supported."); - } - - return { - type: "keyImport", - keyData: keyData, - keyHandle: { - algorithm: { - name: "HKDF" - }, - extractable: false, - usages: p.usages, - type: "secret" - } - }; - - }; - - operations.register("deriveBits", "HKDF", msrcryptoHkdf.deriveBits); - operations.register("importKey", "HKDF", msrcryptoHkdf.importKey); - } - - var msrcryptoHkdfCtr = (function() { - - function deriveBits(p) { - - var algorithm = p.algorithm, - keyBytes = p.keyData, - bits = p.length, - labelBytes = algorithm.label, - contextBytes = algorithm.context, - byteLen = Math.ceil(bits / 8), - hLen, - output = [], - i, - hmacContext; - - switch (algorithm.hash.name.toUpperCase()) { - case "SHA-1": - hLen = 20; - break; - case "SHA-256": - hLen = 32; - break; - case "SHA-384": - hLen = 48; - break; - case "SHA-512": - hLen = 64; - break; - default: - throw new Error("Unsupported hash algorithm."); - } - - if (algorithm.label == null) { - throw new Error("HkdfCtrParams: label: Missing required property."); - } - - if (algorithm.context == null) { - throw new Error("HkdfCtrParams: context: Missing required property."); - } - - if (bits % 8 !== 0) { - throw new Error("The length provided for HKDF-CTR is not a multiple of 8 bits."); - } - - if (byteLen > 255 * hLen) { - throw new Error("The length provided for HKDF-CTR is too large."); - } - - hmacContext = { - workerid: 0, - keyHandle: { - algorithm: algorithm - }, - keyData: keyBytes, - buffer: keyBytes - }; - - var fixed = labelBytes.concat([0], contextBytes, utils.int32ToBytes(bits)); - - for (i = 1; i <= Math.ceil(byteLen / hLen); i++) { - hmacContext.buffer = utils.int32ToBytes(i).concat(fixed); - output = output.concat(msrcryptoHmac.signHmac(hmacContext)); - } - - return output.slice(0, byteLen); - } - - return { - deriveBits: deriveBits - }; - - }()); - - if (typeof operations !== "undefined") { - - msrcryptoHkdfCtr.importKey = function(p) { - var keyData; - - if (p.format === "raw") { - keyData = msrcryptoUtilities.toArray(p.keyData); - } else { - throw new Error("unsupported import format"); - } - - if (p.extractable !== false) { - throw new Error("only extractable=false is supported."); - } - - return { - type: "keyImport", - keyData: keyData, - keyHandle: { - algorithm: { - name: "HKDF-CTR" - }, - extractable: false, - usages: p.usages, - type: "secret" - } - }; - - }; - - operations.register("deriveBits", "HKDF-CTR", msrcryptoHkdfCtr.deriveBits); - operations.register("importKey", "HKDF-CTR", msrcryptoHkdfCtr.importKey); - } - - var msrcryptoEcdh = function(curve) { - - var btd = cryptoMath.bytesToDigits, - dtb = cryptoMath.digitsToBytes, - e = curve, - ecop = new cryptoECC.EllipticCurveOperatorFp(curve); - - function generateKey(privateKeyBytes) { - var privateKey = [], - randomBytes = msrcryptoPseudoRandom.getBytes( - curve.order.length * cryptoMath.DIGIT_NUM_BYTES); - - cryptoMath.reduce( - cryptoMath.bytesToDigits(randomBytes), - e.order, - privateKey); - - var publicKey = e.allocatePointStorage(); - - ecop.scalarMultiply(privateKey, e.generator, publicKey); - - return { - privateKey: { - x: dtb(publicKey.x), - y: dtb(publicKey.y), - d: dtb(privateKey) - }, - publicKey: { - x: dtb(publicKey.x), - y: dtb(publicKey.y) - } - }; - } - - function deriveBits(privateKey, publicKey, length) { - - var publicPoint = new cryptoECC.EllipticCurvePointFp( - e, false, btd(publicKey.x), btd(publicKey.y), null, false); - - var sharedSecretPoint = e.allocatePointStorage(); - ecop.convertToJacobianForm(sharedSecretPoint); - ecop.convertToMontgomeryForm(sharedSecretPoint); - - ecop.scalarMultiply(btd(privateKey.d), publicPoint, sharedSecretPoint); - - ecop.convertToAffineForm(sharedSecretPoint); - ecop.convertToStandardForm(sharedSecretPoint); - - var secretBytes = cryptoMath.digitsToBytes(sharedSecretPoint.x, true, publicKey.x.length); - - if (length && secretBytes.length * 8 < length) { - throw new Error("DataError"); - } - - secretBytes = length ? secretBytes.slice(0, Math.ceil(length / 8)) : secretBytes; - - var bits = length % 8; - var mask = bits === 0 ? 0xFF : 0xFF00 >>> bits; - secretBytes[secretBytes.length - 1] = secretBytes[secretBytes.length - 1] & mask; - - return secretBytes; - } - - function computePublicKey(privateKeyBytes) { - - if (!e.generator.isInMontgomeryForm) { - ecop.convertToMontgomeryForm(e.generator); - } - - var publicKey = e.allocatePointStorage(); - ecop.convertToJacobianForm(publicKey); - ecop.convertToMontgomeryForm(publicKey); - ecop.scalarMultiply(btd(privateKeyBytes), e.generator, publicKey); - - return { - x: dtb(publicKey.x), - y: dtb(publicKey.y) - }; - } - - return { - - generateKey: generateKey, - deriveBits: deriveBits, - computePublicKey: computePublicKey - }; - - }; - - var ecdhInstance = null; - - if (typeof operations !== "undefined") { - - msrcryptoEcdh.deriveBits = function(p) { - - var curve = cryptoECC.createCurve(p.algorithm.namedCurve.toUpperCase()); - - var privateKey = p.keyData; - - var publicKey = p.additionalKeyData; - - ecdhInstance = msrcryptoEcdh(curve); - - var secretBytes = ecdhInstance.deriveBits(privateKey, publicKey, p.length); - - return secretBytes; - }; - - msrcryptoEcdh.deriveKey = function(p) { - - throw new Error("not supported"); - - return secretBytes; - }; - - msrcryptoEcdh.generateKey = function(p) { - - var curve = cryptoECC.createCurve(p.algorithm.namedCurve.toUpperCase()); - - ecdhInstance = msrcryptoEcdh(curve); - - var keyPairData = ecdhInstance.generateKey(); - - return { - type: "keyPairGeneration", - keyPair: { - publicKey: { - keyData: keyPairData.publicKey, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: [], - type: "public" - } - }, - privateKey: { - keyData: keyPairData.privateKey, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: p.usages, - type: "private" - } - } - } - }; - }; - - msrcryptoEcdh.importKey = function(p) { - - try { - - if (p.format === "raw") { - - var keyData = p.keyData; - - if (keyData[0] !== 4) { - throw new Error("DataError"); - } - - var elementSize = ~~((keyData.length - 1) / 2); - - var curveName = p.algorithm.namedCurve.toUpperCase(); - - var x = keyData.slice(1, elementSize + 1), - y = keyData.slice(elementSize + 1); - - if (cryptoECC.validatePoint(curveName, x, y) === false) { - throw new Error("DataError"); - } - - return { - type: "keyImport", - keyData: { - x: x, - y: y - }, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable || false, - usages: p.usages, - type: "public" - } - }; - } - - if (p.format === "jwk") { - - var keyObject = msrcryptoJwk.jwkToKey(p.keyData, p.algorithm, ["x", "y", "d", "crv"]); - - if (keyObject.d && (!keyObject.x || !keyObject.y)) { - - var curve = cryptoECC.createCurve(p.algorithm.namedCurve.toUpperCase()); - - ecdhInstance = msrcryptoEcdh(curve); - - var publicKey = ecdhInstance.computePublicKey(keyObject.d); - - keyObject.x = publicKey.x; - keyObject.y = publicKey.y; - } - - if (cryptoECC.validatePoint(p.algorithm.namedCurve.toUpperCase(), keyObject.x, keyObject.y) === false) { - throw new Error("DataError"); - } - - return { - type: "keyImport", - keyData: keyObject, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable || keyObject.extractable, - usages: p.usages, - type: keyObject.d ? "private" : "public" - } - }; - } - - if (p.format === "spki") { - - var lengths = { - "P-256": 32, - "P-384": 48, - "P-521": 66 - } - - var partLen = lengths[p.algorithm.namedCurve]; - - var privateKeyInfo = asn1.parse(p.keyData); - - if (privateKeyInfo == null) { - throw new Error("invalid key data."); - } - - var bitString = privateKeyInfo[1]; - - var keySequence = bitString.data.slice(bitString.header + 1); - - if (keySequence == null || keySequence.shift() !== 4 || keySequence.length !== partLen * 2) { - throw new Error("invalid key data."); - } - - var x = keySequence.slice(0, partLen), - y = keySequence.slice(partLen) - - if (!msrcryptoUtilities.isBytes(x) || !msrcryptoUtilities.isBytes(y)) { - throw new Error("invalid key data."); - } - - var keyObject = { - x: x, - y: y - }; - - if (cryptoECC.validatePoint(p.algorithm.namedCurve.toUpperCase(), keyObject.x, keyObject.y) === false) { - throw new Error("DataError"); - } - - return { - type: "keyImport", - keyData: keyObject, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: p.usages, - type: "public" - } - }; - - } - - if (p.format === "pkcs8") { - - var lengths = { - "P-256": 32, - "P-384": 48, - "P-521": 66 - } - - var partLen = lengths[p.algorithm.namedCurve]; - - var privateKeyInfo = asn1.parse(p.keyData); - - if (privateKeyInfo == null) { - throw new Error("invalid key data."); - } - - var octetString = privateKeyInfo[2]; - var keySequence = asn1.parse(octetString.data.slice(octetString.header)); - - if (keySequence == null) { - throw new Error("invalid key data."); - } - - var d = keySequence[1].data.slice(keySequence[1].header); - - var bitString = asn1.parse(keySequence[2][0].data); - - var keySequence = bitString.data.slice(bitString.header + 1); - - if (keySequence == null || keySequence.shift() !== 4 || keySequence.length !== partLen * 2) { - throw new Error("invalid key data."); - } - - var x = keySequence.slice(0, partLen), - y = keySequence.slice(partLen) - - if (!msrcryptoUtilities.isBytes(x) || !msrcryptoUtilities.isBytes(y)) { - throw new Error("invalid key data."); - } - - var keyObject = { - x: x, - y: y, - d: d - }; - - if (cryptoECC.validatePoint(p.algorithm.namedCurve.toUpperCase(), keyObject.x, keyObject.y) === false) { - throw new Error("DataError"); - } - - return { - type: "keyImport", - keyData: keyObject, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: p.usages, - type: "private" - } - }; - - } - - } catch (err) { - throw new msrcryptoUtilities.error("DataError", ""); - } - - }; - - msrcryptoEcdh.exportKey = function(p) { - var EC_PUBLICKEY = "1.2.840.10045.2.1"; - var curveOid = { - "P-256": "1.2.840.10045.3.1.7 ", - "P-384": "1.3.132.0.34", - "P-521": "1.3.132.0.35" - } - - if (p.format === "raw" && p.keyHandle.type === "public") { - - var keyData = [4].concat(p.keyData.x, p.keyData.y); - - return { - type: "keyExport", - keyHandle: keyData - }; - } - - if (p.format === "jwk") { - var jsonKeyStringArray = msrcryptoJwk.keyToJwk(p.keyHandle, p.keyData); - return { - type: "keyExport", - keyHandle: jsonKeyStringArray - }; - } - - if (p.format === "spki") { - var bytes = asn1.encode({ - SEQUENCE: [{ - SEQUENCE: [{ - "OBJECT IDENTIFIER": EC_PUBLICKEY - }, - { - "OBJECT IDENTIFIER": curveOid[p.algorithm.namedCurve] - } - ] - }, - { - "BIT STRING": [4].concat(p.keyData.x, p.keyData.y) - } - ] - }); - - return { - type: "keyExport", - keyHandle: bytes - }; - } - - if (p.format === "pkcs8") { - var bytes = asn1.encode({ - SEQUENCE: [{ - INTEGER: 0 - }, - { - SEQUENCE: [{ - "OBJECT IDENTIFIER": EC_PUBLICKEY - }, - { - "OBJECT IDENTIFIER": curveOid[p.algorithm.namedCurve] - } - ] - }, - { - "OCTET STRING": { - SEQUENCE: [{ - INTEGER: 1 - }, - { - "OCTET STRING": p.keyData.d - }, - { - APPLICATION: [{ - "BIT STRING": [4].concat(p.keyData.x, p.keyData.y) - }], - tag: 1 - } - ] - } - } - ] - }); - - return { - type: "keyExport", - keyHandle: bytes - }; - } - - throw new Error("unsupported export format."); - }; - - operations.register("importKey", "ECDH", msrcryptoEcdh.importKey); - operations.register("exportKey", "ECDH", msrcryptoEcdh.exportKey); - operations.register("generateKey", "ECDH", msrcryptoEcdh.generateKey); - operations.register("deriveBits", "ECDH", msrcryptoEcdh.deriveBits); - operations.register("deriveKey", "ECDH", msrcryptoEcdh.deriveKey); - } - - var msrcryptoEcdsa = function(curve) { - - var btd = cryptoMath.bytesToDigits, - dtb = cryptoMath.digitsToBytes, - ecop = new cryptoECC.EllipticCurveOperatorFp(curve), - orderByteLength = dtb(curve.order).length, - tedCurve = curve.type === 1; - - function createKey(privateKeyBytes) { - return createKeyInternal(btd(privateKeyBytes)); - } - - function createKeyInternal(privateKeyDigits) { - - var publicKey = curve.allocatePointStorage(); - - ecop.scalarMultiply(privateKeyDigits, curve.generator, publicKey); - - return { - publicKey: publicKey, - privateKey: privateKeyDigits - }; - } - - function generateKey(randomBytes) { - - var privateKey = []; - - if (!randomBytes) { - randomBytes = msrcryptoPseudoRandom.getBytes( - curve.order.length * cryptoMath.DIGIT_NUM_BYTES); - } - - cryptoMath.reduce( - cryptoMath.bytesToDigits(randomBytes), - curve.order, - privateKey); - - return createKeyInternal(privateKey); - } - - function getDigest(messageBytes) { - - if (messageBytes.length > orderByteLength) { - messageBytes.length = orderByteLength; - } - - var digest = btd(messageBytes); - - if (tedCurve) { - var shift = 8 - curve.rbits % 8; - cryptoMath.shiftRight(digest, digest, shift); - } - - cryptoMath.reduce(digest, curve.order, digest); - - return digest; - } - - function sign(privateKey, messageBytes, ephemeralKey) { - - if (!ephemeralKey) { - ephemeralKey = generateKey(); - } - - var r = ephemeralKey.publicKey.x, - k = ephemeralKey.privateKey, - d = btd(privateKey.d), - digest = getDigest(messageBytes.slice()), - s = [], - tmp = [], - signature = null; - - cryptoMath.reduce(r, curve.order, r); - cryptoMath.modMul(r, d, curve.order, s); - cryptoMath.add(s, digest, s); - cryptoMath.reduce(s, curve.order, s); - cryptoMath.modInvCT(k, curve.order, tmp); - cryptoMath.modMul(s, tmp, curve.order, s); - - var rBytes = msrcryptoUtilities.padFront(dtb(r, true, orderByteLength), 0, orderByteLength); - var sBytes = msrcryptoUtilities.padFront(dtb(s, true, orderByteLength), 0, orderByteLength); - - signature = rBytes.concat(sBytes); - - return signature; - } - - function verify(publicKey, signatureBytes, messageBytes) { - - var split = Math.floor(signatureBytes.length / 2), - r = btd(signatureBytes.slice(0, split)), - s = btd(signatureBytes.slice(split)), - digest = getDigest(messageBytes.slice()), - u1 = [], - u2 = []; - - var publicPoint = new cryptoECC.EllipticCurvePointFp( - curve, false, btd(publicKey.x), btd(publicKey.y), null, false); - - cryptoMath.modInv(s, curve.order, s); - cryptoMath.modMul(digest, s, curve.order, u1); - cryptoMath.modMul(r, s, curve.order, u2); - - var r0 = curve.allocatePointStorage(); - var r1 = curve.allocatePointStorage(); - - if (tedCurve) { - cryptoMath.add(u1, u1, u1); - cryptoMath.add(u1, u1, u1); - cryptoMath.reduce(u1, curve.order, u1); - ecop.scalarMultiply(u1, curve.generator, r0, false); - ecop.scalarMultiply(u2, publicPoint, r1, false); - ecop.convertToExtendedProjective(r0); - ecop.convertToExtendedProjective(r1); - ecop.add(r1, r0, r0); - ecop.normalize(r0); - - } else { - ecop.scalarMultiply(u1, curve.generator, r0); - ecop.scalarMultiply(u2, publicPoint, r1); - ecop.convertToJacobianForm(r0); - ecop.convertToMontgomeryForm(r0); - ecop.convertToMontgomeryForm(r1); - ecop.mixedAdd(r0, r1, r0); - ecop.convertToAffineForm(r0); - ecop.convertToStandardForm(r0); - } - - if (r0.isInfinity) { - return false; - } - - cryptoMath.reduce(r0.x, curve.order, r0.x); - - return cryptoMath.compareDigits(r0.x, r) === 0; - } - - return { - createKey: createKey, - generateKey: generateKey, - sign: sign, - verify: verify - }; - - }; - - if (typeof operations !== "undefined") { - - msrcryptoEcdsa.sign = function(p) { - - msrcryptoUtilities.checkParam(p.algorithm.hash, "Object", "algorithm.hash"); - msrcryptoUtilities.checkParam(p.algorithm.hash.name, "String", "algorithm.hash.name"); - msrcryptoUtilities.checkParam(p.keyHandle.algorithm.namedCurve, "String", "p.keyHandle.algorithm.namedCurve"); - - var hashName = p.algorithm.hash.name, - curve = cryptoECC.createCurve(p.keyHandle.algorithm.namedCurve.toUpperCase()), - hashFunc = msrcryptoHashFunctions[hashName.toUpperCase()](), - digest = hashFunc.computeHash(p.buffer); - - var ecdsa = msrcryptoEcdsa(curve); - - return ecdsa.sign(p.keyData, digest); - }; - - msrcryptoEcdsa.verify = function(p) { - - var hashName = p.algorithm.hash.name, - curve = cryptoECC.createCurve(p.keyHandle.algorithm.namedCurve.toUpperCase()), - hashFunc = msrcryptoHashFunctions[hashName.toUpperCase()](), - digest = hashFunc.computeHash(p.buffer); - - var ecdsa = msrcryptoEcdsa(curve); - - return ecdsa.verify(p.keyData, p.signature, digest); - }; - - msrcryptoEcdsa.generateKey = function(p) { - - var curve = cryptoECC.createCurve(p.algorithm.namedCurve.toUpperCase()); - - var ecdsa = msrcryptoEcdsa(curve); - - var keyPairData = ecdsa.generateKey(); - - var dtb = cryptoMath.digitsToBytes; - - function padTo8BytesIncrement(array) { - return array; - } - var x = padTo8BytesIncrement(dtb(keyPairData.publicKey.x)); - var y = padTo8BytesIncrement(dtb(keyPairData.publicKey.y)); - var d = padTo8BytesIncrement(dtb(keyPairData.privateKey)); - - return { - type: "keyPairGeneration", - keyPair: { - publicKey: { - keyData: { - x: x, - y: y - }, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: ["verify"], - type: "public" - } - }, - privateKey: { - keyData: { - x: x, - y: y, - d: d - }, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: ["sign"], - type: "private" - } - } - } - }; - - }; - - msrcryptoEcdsa.importKey = function(p) { - - if (p.format === "raw") { - - var keyData = p.keyData; - - if (keyData[0] !== 4) { - throw new Error("DataError"); - } - - var elementSize = ~~((keyData.length - 1) / 2); - - var curveName = p.algorithm.namedCurve.toUpperCase(); - - var x = keyData.slice(1, elementSize + 1), - y = keyData.slice(elementSize + 1); - - if (cryptoECC.validatePoint(curveName, x, y) === false) { - throw new Error("DataError"); - } - - return { - type: "keyImport", - keyData: { - x: x, - y: y - }, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: p.usages, - type: "public" - } - }; - } - - if (p.format === "jwk") { - var keyObject = msrcryptoJwk.jwkToKey(p.keyData, p.algorithm, ["x", "y", "d", "crv"]); - - if (keyObject.d && (!keyObject.x || !keyObject.y)) { - - var curve = msrcryptoEcdsa.curves[p.algorithm.namedCurve](); - - var ecdsa = msrcryptoEcdsa(curve); - - var publicKey = ecdsa.computePublicKey(keyObject.d); - - keyObject.x = publicKey.x; - keyObject.y = publicKey.y; - } - - if (cryptoECC.validatePoint(p.algorithm.namedCurve.toUpperCase(), keyObject.x, keyObject.y) === false) { - throw new Error("DataError"); - } - - return { - type: "keyImport", - keyData: keyObject, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable || keyObject.extractable, - usages: null || p.usages, - type: keyObject.d ? "private" : "public" - } - }; - } - - if (p.format === "spki") { - - var lengths = { - "P-256": 32, - "P-384": 48, - "P-521": 66 - } - - var partLen = lengths[p.algorithm.namedCurve]; - - var privateKeyInfo = asn1.parse(p.keyData); - - if (privateKeyInfo == null) { - throw new Error("invalid key data."); - } - - var bitString = privateKeyInfo[1]; - - var keySequence = bitString.data.slice(bitString.header + 1); - - if (keySequence == null || keySequence.shift() !== 4 || keySequence.length !== partLen * 2) { - throw new Error("invalid key data."); - } - - var x = keySequence.slice(0, partLen), - y = keySequence.slice(partLen) - - if (!msrcryptoUtilities.isBytes(x) || !msrcryptoUtilities.isBytes(y)) { - throw new Error("invalid key data."); - } - - var keyObject = { - x: x, - y: y - }; - - if (cryptoECC.validatePoint(p.algorithm.namedCurve.toUpperCase(), keyObject.x, keyObject.y) === false) { - throw new Error("DataError"); - } - - return { - type: "keyImport", - keyData: keyObject, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: p.usages, - type: "public" - } - }; - - } - - if (p.format === "pkcs8") { - - var lengths = { - "P-256": 32, - "P-384": 48, - "P-521": 66 - } - - var partLen = lengths[p.algorithm.namedCurve]; - - var privateKeyInfo = asn1.parse(p.keyData); - - if (privateKeyInfo == null) { - throw new Error("invalid key data."); - } - - var octetString = privateKeyInfo[2]; - var keySequence = asn1.parse(octetString.data.slice(octetString.header)); - - if (keySequence == null) { - throw new Error("invalid key data."); - } - - var d = keySequence[1].data.slice(keySequence[1].header); - - var bitString = asn1.parse(keySequence[2][0].data); - - var keySequence = bitString.data.slice(bitString.header + 1); - - if (keySequence == null || keySequence.shift() !== 4 || keySequence.length !== partLen * 2) { - throw new Error("invalid key data."); - } - - var x = keySequence.slice(0, partLen), - y = keySequence.slice(partLen) - - if (!msrcryptoUtilities.isBytes(x) || !msrcryptoUtilities.isBytes(y)) { - throw new Error("invalid key data."); - } - - var keyObject = { - x: x, - y: y, - d: d - }; - - if (cryptoECC.validatePoint(p.algorithm.namedCurve.toUpperCase(), keyObject.x, keyObject.y) === false) { - throw new Error("DataError"); - } - - return { - type: "keyImport", - keyData: keyObject, - keyHandle: { - algorithm: p.algorithm, - extractable: p.extractable, - usages: p.usages, - type: "private" - } - }; - - } - - }; - - msrcryptoEcdsa.exportKey = function(p) { - var EC_PUBLICKEY = "1.2.840.10045.2.1"; - var curveOid = { - "P-256": "1.2.840.10045.3.1.7 ", - "P-384": "1.3.132.0.34", - "P-521": "1.3.132.0.35" - } - - if (p.format === "raw" && p.keyHandle.type === "public") { - - var keyData = [4].concat(p.keyData.x, p.keyData.y); - - return { - type: "keyExport", - keyHandle: keyData - }; - } - - if (p.format === "jwk") { - var jsonKeyStringArray = msrcryptoJwk.keyToJwk(p.keyHandle, p.keyData); - return { - type: "keyExport", - keyHandle: jsonKeyStringArray - }; - } - - if (p.format === "spki") { - var bytes = asn1.encode({ - SEQUENCE: [{ - SEQUENCE: [{ - "OBJECT IDENTIFIER": EC_PUBLICKEY - }, - { - "OBJECT IDENTIFIER": curveOid[p.algorithm.namedCurve] - } - ] - }, - { - "BIT STRING": [4].concat(p.keyData.x, p.keyData.y) - } - ] - }); - - return { - type: "keyExport", - keyHandle: bytes - }; - } - - if (p.format === "pkcs8") { - var bytes = asn1.encode({ - SEQUENCE: [{ - INTEGER: 0 - }, - { - SEQUENCE: [{ - "OBJECT IDENTIFIER": EC_PUBLICKEY - }, - { - "OBJECT IDENTIFIER": curveOid[p.algorithm.namedCurve] - } - ] - }, - { - "OCTET STRING": { - SEQUENCE: [{ - INTEGER: 1 - }, - { - "OCTET STRING": p.keyData.d - }, - { - APPLICATION: [{ - "BIT STRING": [4].concat(p.keyData.x, p.keyData.y) - }], - tag: 1 - } - ] - } - } - ] - }); - - return { - type: "keyExport", - keyHandle: bytes - }; - } - - throw new Error("unsupported export format."); - - }; - - operations.register("sign", "ECDSA", msrcryptoEcdsa.sign); - operations.register("verify", "ECDSA", msrcryptoEcdsa.verify); - operations.register("generateKey", "ECDSA", msrcryptoEcdsa.generateKey); - operations.register("importKey", "ECDSA", msrcryptoEcdsa.importKey); - operations.register("exportKey", "ECDSA", msrcryptoEcdsa.exportKey); - } - - var msrcryptoSubtle; - - var utils = msrcryptoUtilities; - - msrcryptoSubtle = (function() { - - function syncWorker() { - var result; - - function postMessage(data) { - - try { - data.workerid = this.id; - result = msrcryptoWorker.jsCryptoRunner({ - data: data - }); - } catch (ex) { - this.onerror({ - data: ex, - type: "error" - }); - return; - } - - this.onmessage({ - data: result - }); - } - - return { - postMessage: postMessage, - onmessage: null, - onerror: null, - terminate: function() {} - }; - } - - var streamObject = function(op) { - - return { - process: function(buffer) { - return op.process(buffer); - }, - finish: function() { - return op.finish(); - }, - abort: function() { - return op.abort(); - } - }; - }; - - function baseOperation(processResults) { - - var result = null, - oncompleteCallback = null, - onerrorCallback = null, - retObj, - promise, - resolveFunc, - rejectFunc; - - promise = new Promise( - function(resolve, reject) { - resolveFunc = resolve; - rejectFunc = reject; - }); - - function opDispatchEvent(e) { - if (e.type === "error") { - if (rejectFunc) { - e.data && (e.data.stack = "Error") && (e.data.code = 0); - rejectFunc.apply(promise, [e.data || e]); - } - return; - } - - if (e.data.type === "process") { - processResults(e.data.result, true); - return; - } - - if (e.data.type === "finish") { - processResults(e.data.result, true); - return; - } - - this.result = processResults(e.data); - resolveFunc.apply(promise, [this.result]); - - return; - } - - retObj = { - dispatchEvent: opDispatchEvent, - promise: promise, - result: null - }; - - return retObj; - } - - function keyOperation() { - - function processResult(result) { - - var publicKey, - privateKey; - - switch (result.type) { - - case "keyGeneration": - case "keyImport": - case "keyDerive": - if (result.keyPair) { - keys.add(result.keyPair.publicKey.keyHandle, result.keyPair.publicKey.keyData); - keys.add(result.keyPair.privateKey.keyHandle, result.keyPair.privateKey.keyData); - return { - publicKey: result.keyPair.publicKey.keyHandle, - privateKey: result.keyPair.privateKey.keyHandle - }; - } else { - keys.add(result.keyHandle, result.keyData); - return result.keyHandle; - } - - case "keyExport": - return result.keyHandle; - - case "keyPairGeneration": - privateKey = result.keyPair.privateKey; - publicKey = result.keyPair.publicKey; - keys.add(publicKey.keyHandle, publicKey.keyData); - keys.add(privateKey.keyHandle, privateKey.keyData); - return { - publicKey: publicKey.keyHandle, - privateKey: privateKey.keyHandle - }; - - default: - throw new Error("Unknown key operation"); - } - } - - return baseOperation(processResult); - } - - function toArrayBufferIfSupported(dataArray) { - - if (typedArraySupport && dataArray.pop) { - - return (new Uint8Array(dataArray)).buffer; - } - - return dataArray; - } - - function cryptoOperation(cryptoContext) { - - function processResult(result, isProcessCall) { - - result = result && toArrayBufferIfSupported(result); - - if (isProcessCall) { - promiseQueue.resolve(result); - return; - } - - return result; - } - - var promiseQueue = [], - op = baseOperation(processResult); - - op.stream = cryptoContext.algorithm.stream; - - promiseQueue.add = function(label) { - - var resolveFunc, - rejectFunc, - promise = new Promise( - function(resolve, reject) { - resolveFunc = resolve; - rejectFunc = reject; - }); - - promise.label = label; - - promiseQueue.push({ - resolve: resolveFunc, - reject: rejectFunc, - promise: promise - }); - - return promise; - }; - - promiseQueue.resolve = function(result) { - var queueItem = promiseQueue.shift(); - queueItem.resolve.apply(queueItem.promise, [result]); - }; - - op.process = function(buffer) { - cryptoContext.operationSubType = "process"; - cryptoContext.buffer = utils.toArray(buffer); - workerManager.continueJob(this, - utils.clone(cryptoContext)); - - return promiseQueue.add("process"); - }; - - op.finish = function() { - cryptoContext.operationSubType = "finish"; - cryptoContext.buffer = []; - workerManager.continueJob(this, - utils.clone(cryptoContext)); - - return promiseQueue.add("finish"); - }; - - op.abort = function() { - workerManager.abortJob(this); - }; - op.algorithm = cryptoContext.algorithm || null; - op.key = cryptoContext.keyHandle || null; - - return op; - } - - var keys = []; - - keys.add = function(keyHandle, keyData) { - keys.push({ - keyHandle: keyHandle, - keyData: keyData - }); - }; - - keys.remove = function(keyHandle) { - for (var i = 0; i < keys.length; i += 1) { - if (keys[i].keyHandle === keyHandle) { - keys = keys.splice(i, 1); - return; - } - } - }; - - keys.lookup = function(keyHandle) { - for (var i = 0; i < keys.length; i += 1) { - if (keys[i].keyHandle === keyHandle) { - return keys[i].keyData; - } - } - return null; - }; - - var workerManager = (function() { - - var maxWorkers = 12; - - var maxFreeWorkers = 2; - - var workerPool = []; - - var jobQueue = []; - - var jobId = 0; - - var workerId = 0; - - var callbackQueue = []; - - var setFunction = typeof setImmediate === "undefined" ? setTimeout : setImmediate; - - function executeNextCallback() { - callbackQueue.shift()(); - } - - function queueCallback(callback) { - callbackQueue.push(callback); - setFunction(executeNextCallback, 0); - } - - var workerStatus = webWorkerSupport ? "available" : "unavailable"; - - function getFreeWorker() { - - purgeWorkerType(!asyncMode); - - for (var i = 0; i < workerPool.length; i++) { - if (!workerPool[i].busy) { - return workerPool[i]; - } - } - - return null; - } - - function purgeWorkerType(webWorker) { - for (var i = workerPool.length - 1; i >= 0; i -= 1) { - if (workerPool[i].isWebWorker === webWorker) { - workerPool[i].terminate(); - workerPool.splice(i, 1); - } - } - } - - function freeWorkerCount() { - var freeWorkers = 0; - for (var i = 0; i < workerPool.length; i++) { - if (!workerPool[i].busy) { - freeWorkers += 1; - } - } - return freeWorkers; - } - - function addWorkerToPool(worker) { - workerPool.push(worker); - } - - function removeWorkerFromPool(worker) { - for (var i = 0; i < workerPool.length; i++) { - if (workerPool[i] === worker) { - worker.terminate(); - workerPool.splice(i, 1); - return; - } - } - } - - function lookupWorkerByOperation(operation) { - for (var i = 0; i < workerPool.length; i++) { - if (workerPool[i].operation === operation) { - return workerPool[i]; - } - } - return null; - } - - function queueJob(operation, data) { - jobQueue.push({ - operation: operation, - data: data, - id: jobId++ - }); - } - - function jobCompleted(worker) { - - worker.busy = false; - - if (asyncMode) { - if (jobQueue.length > 0) { - - var job = jobQueue.shift(), - i; - - continueJob(job.operation, job.data); - - if (job.data.operationSubType === "process") { - for (i = 0; i < jobQueue.length; i++) { - if (job.operation === jobQueue[i].operation) { - continueJob(jobQueue[i].operation, jobQueue[i].data); - } - } - for (i = jobQueue.length - 1; i >= 0; i--) { - if (job.operation === jobQueue[i].operation) { - jobQueue.splice(i, 1); - } - } - } - } else if (freeWorkerCount() > maxFreeWorkers) { - removeWorkerFromPool(worker); - } - } - - } - - function createNewWorker(operation) { - - var worker; - - if (workerStatus === "pending") { - throw new Error("Creating new worker while workerstatus=pending"); - } - - if (workerStatus === "ready") { - try { - worker = new Worker(scriptUrl); - worker.postMessage({ - prngSeed: msrcryptoPseudoRandom.getBytes(48) - }); - worker.isWebWorker = true; - } catch (ex) { - asyncMode = false; - workerStatus = "failed"; - worker.terminate(); - worker = syncWorker(); - worker.isWebWorker = false; - } - - } else { - worker = syncWorker(); - worker.isWebWorker = false; - } - - worker.operation = operation; - - worker.id = workerId++; - - worker.busy = false; - - worker.onmessage = function(e) { - - if (e.data.initialized === true) { - return; - } - - var op = worker.operation; - - e.target || (e.target = { - data: worker.data - }); - - for (var i = 0; i < jobQueue.length; i++) { - if (jobQueue[i].operation === worker.operation) { - var job = jobQueue[i]; - jobQueue.splice(i, 1); - postMessageToWorker(worker, job.data); - return; - } - } - - if (!(e.data.hasOwnProperty("type") && e.data.type === "process")) { - jobCompleted(worker); - } - - op.dispatchEvent(e); - }; - - worker.onerror = function(e) { - - var op = worker.operation; - - jobCompleted(worker); - - op.dispatchEvent(e); - }; - - addWorkerToPool(worker); - - return worker; - } - - function useWebWorkers(enable) { - if (workerStatus === "unavailable") { - utils.consoleLog("web workers not available in this browser."); - return; - } - - if (enable === true && workerStatus === "ready") { - return; - } - - if (enable === false && workerStatus === "available") { - return; - } - - if (enable === false && workerStatus === "ready") { - asyncMode = false; - workerStatus = "available"; - utils.consoleLog("web workers disabled."); - return; - } - - if (workerStatus === "pending") { - return; - } - - workerStatus = "pending"; - - var worker = new Worker(scriptUrl); - - function setWorkerStatus(e) { - var succeeded = !!(e.data && e.data.initialized === true); - worker.removeEventListener("message", setWorkerStatus, false); - worker.removeEventListener("error", setWorkerStatus, false); - worker.terminate(); - workerStatus = succeeded ? "ready" : "failed"; - asyncMode = succeeded; - utils.consoleLog("web worker initialization " + (succeeded ? "succeeded. Now using web workers." : - "failed. running synchronously." + (e.message || ""))); - if (jobQueue.length > 0) { - var job = jobQueue.shift(); - runJob(job.operation, job.data); - } - return; - } - - worker.addEventListener("message", setWorkerStatus, false); - worker.addEventListener("error", setWorkerStatus, false); - - worker.postMessage({ - prngSeed: msrcryptoPseudoRandom.getBytes(48) - }); - - return; - } - - function abortJob(cryptoOperationObject) { - var worker = lookupWorkerByOperation(cryptoOperationObject); - if (worker) { - removeWorkerFromPool(worker); - } - } - - function runJob(operation, data) { - - var worker = null; - - if (workerStatus === "pending") { - queueJob(operation, data); - return; - } - - worker = getFreeWorker(); - - if (asyncMode && worker === null && workerPool.length >= maxWorkers) { - queueJob(operation, data); - return; - } - - if (worker === null) { - worker = createNewWorker(operation); - } - - if (worker === null) { - queueJob(operation, data); - throw new Error("could not create new worker"); - } - - worker.operation = operation; - - worker.busy = true; - - data.workerid = worker.id; - - postMessageToWorker(worker, data); - } - - function continueJob(operation, data) { - - var worker = lookupWorkerByOperation(operation); - - if (worker) { - postMessageToWorker(worker, data); - return; - } - - runJob(operation, data); - } - - function postMessageToWorker(worker, data) { - data.workerid = worker.id; - - if (asyncMode) { - - worker.postMessage(data); - - } else { - - var func = (function(postData) { - return function() { - return worker.postMessage(postData); - }; - })(data); - - queueCallback(func); - } - - return; - } - - return { - runJob: runJob, - continueJob: continueJob, - abortJob: abortJob, - useWebWorkers: useWebWorkers - }; - - })(); - - function checkOperation(operationType, algorithmName) { - if (!operations.exists(operationType, algorithmName)) { - throw new Error("unsupported algorithm"); - } - } - - var subtleParameters = [{ - name: "algorithm", - type: "Object", - required: true - }, - { - name: "keyHandle", - type: "Object", - required: true - }, - { - name: "buffer", - type: "Array", - required: false - }, - { - name: "signature", - type: "Array", - required: true - }, - { - name: "format", - type: "String", - required: true - }, - { - name: "keyData", - type: "Object", - required: true - }, - { - name: "extractable", - type: "Boolean", - required: false - }, - { - name: "usages", - type: "Array", - required: false - }, - { - name: "derivedKeyType", - type: "Object", - required: true - }, - { - name: "length", - type: "Number", - required: false - }, - { - name: "extractable", - type: "Boolean", - required: true - }, - { - name: "usages", - type: "Array", - required: true - }, - { - name: "keyData", - type: "Array", - required: true - } - ]; - - var subtleParametersSets = { - encrypt: [0, 1, 2], - decrypt: [0, 1, 2], - sign: [0, 1, 2], - verify: [0, 1, 3, 2], - digest: [0, 2], - generateKey: [0, 6, 7], - importKeyRaw: [4, 12, 0, 10, 11], - importKeyJwk: [4, 5, 0, 10, 11], - exportKey: [0, 4, 1, 6, 7], - deriveKey: [0, 1, 8, 6, 7], - deriveBits: [0, 1, 9], - wrapKey: [1, 1, 0], - unwrapKey: [2, 0, 1, 6, 7] - }; - - function lookupKeyData(handle) { - var data = keys.lookup(handle); - - if (!data) { - throw new Error("key not found"); - } - - return data; - } - - function buildParameterCollection(operationName, parameterSet) { - - var parameterCollection = { - operationType: operationName - }, - operationParameterSet, - expectedParam, - actualParam, - i; - - if (operationName === "importKey" && (parameterSet[0] === "raw" || parameterSet[0] === "spki" || parameterSet[0] === "pkcs8")) { - operationName = "importKeyRaw"; - } - - if (operationName === "importKey" && parameterSet[0] === "jwk") { - operationName = "importKeyJwk"; - } - - operationParameterSet = subtleParametersSets[operationName]; - - for (i = 0; i < operationParameterSet.length; i += 1) { - - expectedParam = subtleParameters[operationParameterSet[i]]; - actualParam = parameterSet[i]; - - if (actualParam == null) { - if (expectedParam.required) { - throw new Error(expectedParam.name); - } else { - continue; - } - } - - if (actualParam.subarray) { - actualParam = utils.toArray(actualParam); - } - - if (utils.getObjectType(actualParam) === "ArrayBuffer") { - actualParam = utils.toArray(actualParam); - } - - if (msrcryptoUtilities.getObjectType(actualParam) !== expectedParam.type) { - throw new Error(expectedParam.name); - } - - if (expectedParam.name === "algorithm") { - - actualParam.name = actualParam.name.toUpperCase(); - - if (actualParam.iv) { - actualParam.iv = utils.toArray(actualParam.iv); - } - - if (actualParam.publicExponent) { - actualParam.publicExponent = utils.toArray(actualParam.publicExponent); - } - - if (actualParam.salt) { - actualParam.salt = utils.toArray(actualParam.salt); - } - - if (actualParam.additionalData) { - actualParam.additionalData = utils.toArray(actualParam.additionalData); - } - - if (actualParam.hash && !actualParam.hash.name && utils.getObjectType(actualParam.hash) === "String") { - actualParam.hash = { - name: actualParam.hash - }; - } - } - - if (parameterCollection.hasOwnProperty(expectedParam.name)) { - parameterCollection[expectedParam.name + "1"] = actualParam; - } else { - parameterCollection[expectedParam.name] = actualParam; - } - } - - return parameterCollection; - } - - function executeOperation(operationName, parameterSet, keyFunc) { - - var pc = buildParameterCollection(operationName, parameterSet); - - checkOperation(operationName, pc.algorithm.name); - - if (pc.keyHandle) { - pc.keyData = lookupKeyData(pc.keyHandle); - } - - if (pc.keyHandle1) { - pc.keyData1 = lookupKeyData(pc.keyHandle1); - } - - if (pc.algorithm && pc.algorithm.public) { - pc.additionalKeyData = lookupKeyData(pc.algorithm.public); - } - - var op = keyFunc ? keyOperation(pc) : cryptoOperation(pc); - - if (keyFunc || pc.buffer || operationName === "deriveBits" || operationName === "wrapKey") { - workerManager.runJob(op, pc); - } - - if (op.stream) { - return Promise.resolve(streamObject(op)); - } - - return op.promise; - } - var publicMethods = { - - encrypt: function(algorithm, keyHandle, buffer) { - return executeOperation("encrypt", arguments, 0); - }, - - decrypt: function(algorithm, keyHandle, buffer) { - return executeOperation("decrypt", arguments, 0); - }, - - sign: function(algorithm, keyHandle, buffer) { - return executeOperation("sign", arguments, 0); - }, - - verify: function(algorithm, keyHandle, signature, buffer) { - return executeOperation("verify", arguments, 0); - }, - - digest: function(algorithm, buffer) { - return executeOperation("digest", arguments, 0); - }, - - generateKey: function(algorithm, extractable, keyUsage) { - return executeOperation("generateKey", arguments, 1); - }, - - deriveKey: function(algorithm, baseKey, derivedKeyType, extractable, keyUsage) { - var deriveBits = this.deriveBits, - importKey = this.importKey; - - return new Promise(function(resolve, reject) { - - var keyLength; - - switch (derivedKeyType.name.toUpperCase()) { - case "AES-CBC": - case "AES-GCM": - keyLength = derivedKeyType.length; - break; - case "HMAC": - keyLength = derivedKeyType.length || { - "SHA-1": 512, - "SHA-224": 512, - "SHA-256": 512, - "SHA-384": 1024, - "SHA-512": 1024 - } [derivedKeyType.hash.name.toUpperCase()]; - break; - default: - reject(new Error("No Supported")); - return; - } - - deriveBits(algorithm, baseKey, keyLength) - .then(function(bits) { - return importKey("raw", bits, derivedKeyType, extractable, keyUsage); - }) - .then(function(key) { - resolve(key); - })["catch"](function(err) { - reject(err); - }); - - }); - - }, - - deriveBits: function(algorithm, baseKey, length) { - return executeOperation("deriveBits", arguments, 0); - }, - - importKey: function(format, keyData, algorithm, extractable, keyUsage) { - return executeOperation("importKey", arguments, 1); - }, - - exportKey: function(format, keyHandle) { - return executeOperation("exportKey", [keyHandle.algorithm, format, keyHandle], 1); - }, - - wrapKey: function(format, key, wrappingKey, wrappingKeyAlgorithm) { - var encrypt = this.encrypt, - exportKey = this.exportKey; - - return new Promise(function(resolve, reject) { - - if (key.extractable === false || - wrappingKey.usages.indexOf("wrapKey") < 0 || - wrappingKey.algorithm.name.toUpperCase() !== wrappingKeyAlgorithm.name) { - reject(new Error("InvalidAccessError")); - return; - } - - exportKey(format, key) - - .then(function(keyData) { - - console.log(utils.toBase64(keyData)); - - return encrypt(wrappingKeyAlgorithm, wrappingKey, format === "jwk" ? - utils.stringToBytes(JSON.stringify(keyData, null, 0)) : keyData); - }) - - .then(function(cipherArrayBuffer) { - resolve(cipherArrayBuffer); - }) - - ["catch"](function(err) { - reject(err); - }); - }); - }, - - unwrapKey: function(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) { - var decrypt = this.decrypt, - importKey = this.importKey; - - return new Promise(function(resolve, reject) { - - if (unwrappingKey.usages.indexOf("unwrapKey") < 0 || - unwrappingKey.algorithm.name.toUpperCase() !== unwrapAlgorithm.name) { - reject(new Error("InvalidAccessError")); - return; - } - - decrypt(unwrapAlgorithm, unwrappingKey, wrappedKey) - - .then(function(keyPlain) { - return importKey(format, format === "jwk" ? JSON.parse(utils.bytesToString(keyPlain)) : keyPlain, - unwrappedKeyAlgorithm, extractable, keyUsages); - }) - - .then(function(key) { - resolve(key); - }) - - ["catch"](function(err) { - reject(err); - }); - }); - - } - - }; - - var internalMethods = { - useWebWorkers: workerManager.useWebWorkers - }; - - return { - publicMethods: publicMethods, - internalMethods: internalMethods - }; - - })(); - - var msrcryptoWrapKey = (function() { - - var utils = msrcryptoUtilities; - - function wrapKey(params) { - - var rsaObj = msrcryptoRsa( - params.keyData1, - params.keyHandle1.algorithm.name, - msrcryptoHashFunctions["SHA-1"])(); - - var tagLength = 128; - - var keyToWrapJwk = msrcryptoJwk.keyToJwkOld(params.keyHandle, params.keyData); - - var jweHeader = { - "alg": params.keyHandle1.algorithm.name.toUpperCase(), - "enc": "A128GCM" - }; - - var encodedJweHeader = - utils.toBase64(JSON.stringify(jweHeader), true); - - var cmk = msrcryptoPseudoRandom.getBytes(32); - - var jweEncryptedKey = rsaObj.encrypt(cmk); - - var encodedJweEncryptedKey = utils.toBase64(jweEncryptedKey, true); - - var jweIv = msrcryptoPseudoRandom.getBytes(12); - - var encodedJweIv = utils.toBase64(jweIv, true); - - var additionalData = encodedJweHeader.concat(".", encodedJweEncryptedKey, ".", encodedJweIv); - - var gcm = msrcryptoGcm(msrcryptoBlockCipher.aes(cmk)); - gcm.init(jweIv, utils.stringToBytes(additionalData), tagLength); - - var ciphertextPlusTag = gcm.encrypt(keyToWrapJwk); - - var tag = ciphertextPlusTag.slice(-(tagLength / 8)); - - var encodedIntegrityValue = utils.toBase64(tag, true); - - var encodedCiphertext = - utils.toBase64(ciphertextPlusTag.slice(0, ciphertextPlusTag.length - tag.length), true); - - var jwe = { - - recipients: [{ - header: encodedJweHeader, - encrypted_key: encodedJweEncryptedKey, - integrity_value: encodedIntegrityValue - }], - initialization_vector: encodedJweIv, - ciphertext: encodedCiphertext - - }; - - return utils.stringToBytes(JSON.stringify(jwe)); - - } - - function unwrapKey(params) { - - var b64Tobytes = utils.fromBase64; - - var keyDataJwk = - JSON.parse(String.fromCharCode.apply(null, params.buffer)); - - var header = utils.fromBase64(keyDataJwk.recipients[0].header); - - var encrypted_key = - b64Tobytes(keyDataJwk.recipients[0].encrypted_key); - - var integrity_value = - b64Tobytes(keyDataJwk.recipients[0].integrity_value); - - var initialization_vector = - b64Tobytes(keyDataJwk.initialization_vector); - - var ciphertext = - b64Tobytes(keyDataJwk.ciphertext); - - var hashFunc = msrcryptoHashFunctions["SHA-1"](); - var rsaObj = msrcryptoRsa(params.keyData, params.keyHandle.algorithm.name, hashFunc); - var inKey = rsaObj.decrypt(encrypted_key); - - var additionalData = - keyDataJwk.recipients[0].header.concat(".", keyDataJwk.recipients[0].encrypted_key, ".", - keyDataJwk.initialization_vector); - - var gcm = msrcryptoGcm(msrcryptoBlockCipher.aes(inKey)); - gcm.init(initialization_vector, utils.stringToBytes(additionalData), 128); - - var result = gcm.decrypt(ciphertext, integrity_value); - - var keyObject = msrcryptoJwk.jwkToKey(result, params.algorithm, ["k"]); - - return { - type: "keyImport", - keyData: keyObject.k, - keyHandle: { - algorithm: { - name: params.algorithm.name - }, - extractable: params.extractable || keyObject.extractable, - usages: params.usages, - type: "secret" - } - }; - } - return { - wrapKey: wrapKey, - unwrapKey: unwrapKey - - }; - - })(); - if (typeof operations !== "undefined") { - operations.register("wrapKey", "AES-GCM", msrcryptoWrapKey.wrapKey); - operations.register("unwrapKey", "AES-CBC", msrcryptoWrapKey.unwrapKey); - } - - var publicMethods = { - - subtle: msrcryptoSubtle ? msrcryptoSubtle.publicMethods : null, - - getRandomValues: function(array) { - var i; - var randomValues = msrcryptoPseudoRandom.getBytes(array.length); - for (i = 0; i < array.length; i += 1) { - array[i] = randomValues[i]; - } - return array; - }, - - initPrng: function(entropyData) { - var entropyDataType = Object.prototype.toString.call(entropyData); - - if (entropyDataType !== "[object Array]" && entropyDataType !== "[object Uint8Array]") { - throw new Error("entropyData must be a Array or Uint8Array"); - } - - entropyPool && entropyPool.reseed(entropyData); - - msrcryptoPseudoRandom.reseed(entropyPool.read(48)); - fprngEntropyProvided = true; - }, - - toBase64: function(data, base64Url) { - return msrcryptoUtilities.toBase64(data, base64Url); - }, - - fromBase64: function(base64String) { - return msrcryptoUtilities.fromBase64(base64String); - }, - - textToBytes: function(text) { - return msrcryptoUtilities.stringToBytes(text); - }, - - bytesToText: function(byteArray) { - return msrcryptoUtilities.bytesToString(byteArray); - }, - - asn1: asn1, - - url: scriptUrl, - - version: msrCryptoVersion, - - useWebWorkers: function(useWebWorkers) { - return msrcryptoSubtle ? msrcryptoSubtle.internalMethods.useWebWorkers(useWebWorkers) : null; - } - }; - - - - var entropyPool; - - entropyPool = entropyPool || new MsrcryptoEntropy(global); - - entropyPool.init(); - var localEntropy = entropyPool.read(48); - msrcryptoPseudoRandom.init(localEntropy); - return publicMethods; - - } - - return msrCrypto(); - -})); - -(function(root, factory) { - - if (typeof Promise !== "undefined") { - return; - } - root.Promise = factory(); - -}(this, function() { - - var Promise = function(executor, id) { - if (!(this instanceof Promise)) { - throw new Error("use 'new' keyword with Promise constructor"); - } - - var successResult = null, - failReason = null, - thenResolved = [], - thenRejected = [], - rejectThenPromise = [], - resolveThenPromise = []; - - this.then = function(onCompleted, onRejected) { - - var thenFunctionResult; - - if (successResult) { - thenFunctionResult = onCompleted(successResult.result); - - if (thenFunctionResult && thenFunctionResult.then) { - return thenFunctionResult; - } - - return Promise.resolve(thenFunctionResult); - } - - if (failReason) { - thenFunctionResult = onRejected ? onRejected(failReason.result) : failReason.result; - - if (thenFunctionResult && thenFunctionResult.then) { - return thenFunctionResult; - } - - return Promise.resolve(thenFunctionResult); - } - - thenResolved.push(onCompleted); - if (onRejected) { - thenRejected.push(onRejected); - } - - return new Promise(function(resolve, reject) { - resolveThenPromise.push(resolve); - rejectThenPromise.push(reject); - }); - }; - - this["catch"] = function(onRejected) { - - var catchFunctionResult; - - if (failReason) { - catchFunctionResult = onRejected(failReason.result); - - if (catchFunctionResult && catchFunctionResult.then) { - return catchFunctionResult; - } - - return Promise.resolve(catchFunctionResult); - } - - thenRejected.push(onRejected); - - return new Promise(function(resolve, reject) { - resolveThenPromise.push(resolve); - rejectThenPromise.push(reject); - }); - }; - - function resolve(param) { - var result, i; - - for (i = 0; i < thenResolved.length; i += 1) { - - result = thenResolved[i](param); - - if (result && result.then) { - result.then(resolveThenPromise[i]); - - if (rejectThenPromise[i]) { - result["catch"](rejectThenPromise[i]); - } - - } else { - - if (resolveThenPromise[i]) { - resolveThenPromise[i](result); - } - } - } - - successResult = { - result: param - }; - - return; - } - - function reject(param) { - - var reason, i; - - for (i = 0; i < thenRejected.length; i += 1) { - - reason = thenRejected[i](param); - - if (reason && reason.then) { - reason.then(resolveThenPromise[i], rejectThenPromise[i]); - - } else { - if (resolveThenPromise[i]) { - resolveThenPromise[i](reason); - } - } - } - - failReason = { - result: param - }; - - return; - } - - executor(resolve, reject); - - return; - }; - - Promise.all = function(promiseArray) { - var results = [], - resultCount = 0, - promiseAll; - - function then(index, resolve) { - - return function(result) { - - results[index] = result; - - resultCount += 1; - if (resultCount === promiseArray.length) { - resolve(results); - } - }; - } - - promiseAll = new Promise( - - function(resolve, reject) { - - var i; - - function r(reason) { - reject(reason); - } - - for (i = 0; i < promiseArray.length; i += 1) { - - if (promiseArray[i].then) { - promiseArray[i].then(then(i, resolve)); - promiseArray[i]["catch"](r); - continue; - } - Promise.resolve(promiseArray[i]).then(then(i, resolve)); - } - }); - - return promiseAll; - }; - - Promise.race = function(promiseArray) { - var resolved = false, - promiseRace; - - function then(resolveFunction) { - - return function(result) { - - if (!resolved) { - resolved = true; - resolveFunction(result); - } - }; - } - - promiseRace = new Promise( - - function(resolve, reject) { - - for (var i = 0; i < promiseArray.length; i += 1) { - promiseArray[i].then(then(resolve), then(reject)); - } - }); - - return promiseRace; - }; - - Promise.reject = function(rejectReason) { - return new Promise( - function(resolve, reject) { - reject(rejectReason); - }); - }; - - Promise.resolve = function(resolveResult) { - return new Promise( - function(resolve, reject) { - resolve(resolveResult); - }); - }; - - return Promise; - -})); \ No newline at end of file diff --git a/lib/msrcrypto.min.js b/lib/msrcrypto.min.js deleted file mode 100644 index 8cf1afe..0000000 --- a/lib/msrcrypto.min.js +++ /dev/null @@ -1,18 +0,0 @@ -//******************************************************************************* -// -// Copyright 2020 Microsoft -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -//******************************************************************************* -"use strict";var msrCryptoVersion="1.6.6";!function(e,r){"function"==typeof define&&define.amd?define([],function(){return e.msrCrypto=r(e)}):"object"==typeof exports?module.exports=r(e):e.msrCrypto=r(e)}(this,function(e){e=e||{};return function(){var r={register:function(e,t,n){r[e]||(r[e]={});var o=r[e];o[t]||(o[t]=n)},exists:function(e,t){return!!r[e]&&!!r[e][t]}},t=function(){if("undefined"!=typeof document)try{throw new Error}catch(r){if(r.stack){var e=/\w+:\/\/(.+?\/)*.+\.js/.exec(r.stack);return e&&e.length>0?e[0]:null}}else if("undefined"!=typeof self&&void 0!==self.location)return self.location.href;return null}(),n="undefined"!=typeof Worker,o="function"==typeof importScripts&&self instanceof WorkerGlobalScope,a=!1,s="undefined"!=typeof ArrayBuffer,u=function(){try{return Object.defineProperty({},"oncomplete",{}),!0}catch(e){return!1}}(),l=!1,c=function(e,r,t,n,o){if(u){var a={};n&&(a.get=n),o&&(a.set=o),Object.defineProperty(e,r,a)}else e[r]=t},f={},y=function(){var e="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";function r(r){for(r=r.replace(/-/g,"+").replace(/_/g,"/");r.length%4!=0;)r+="=";var t,n,o,a,i,s,u,l=[];for(r=r.replace(/[^A-Za-z0-9\+\/\=]/g,""),u=0;u>4,n=(15&a)<<4|(i=e.indexOf(r.charAt(u+2)))>>2,o=(3&i)<<6|(s=e.indexOf(r.charAt(u+3))),l.push(t),64!==i&&l.push(n),64!==s&&l.push(o);return l}function t(e){return Object.prototype.toString.call(e).slice(8,-1)}function n(e){return[e>>>24&255,e>>>16&255,e>>>8&255,255&e]}function o(e){if(!e)return[];if(e.pop)return e;if("ArrayBuffer"===t(e)?e=new Uint8Array(e):e.BYTES_PER_ELEMENT>1&&(e=new Uint8Array(e.buffer)),1===e.length)return[e[0]];if(e.length<65536)return Array.apply(null,e);for(var r=new Array(e.length),n=0;n>2,c=(3&i)<<4|(s=p[h+1])>>4,f=(15&s)<<2|(u=p[h+2])>>6,y=63&u,isNaN(s)?f=y=64:isNaN(u)&&(y=64),g=g+e.charAt(l)+e.charAt(c)+e.charAt(f)+e.charAt(y);return n?g.replace(/\+/g,"-").replace(/\//g,"_").replace(/\=/g,""):g},fromBase64:r,checkParam:function(e,r,n){if(!e)throw new Error(n);if(r&&t(e)!==r)throw new Error(n);return!0},getObjectType:t,bytesToHexString:function(e,r){var t="";void 0===r&&(r=!1);for(var n=0;n>>6|192,r[n++]=63&o|128):o<55296||o>57343?(r[n++]=o>>>12|224,r[n++]=o>>>6&63|128,r[n++]=63&o|128):(o=1024*(o-55296)+(e.charCodeAt(++t)-56320)+65536,r[n++]=o>>>18|240,r[n++]=o>>>12&63|128,r[n++]=o>>>6&63|128,r[n++]=63&o|128)}return r},bytesToString:function(e){var r,t="";e=o(e);for(var n=0;n65535){var i=Math.floor((r-65536)/1024)+55296,s=(r-65536)%1024+56320;t+=String.fromCharCode(i,s)}else t+=String.fromCharCode(r)}return t},unpackData:function(e,t,n){var o,a=r(e),i=[];if(isNaN(t))return a;for(o=0;o=2;)r.push(parseInt(e.substring(0,2),16)),e=e.substring(2,e.length);return r},int32ToBytes:n,int32ArrayToBytes:function(e){for(var r=[],t=0;t255)return!1;return!0},error:function(e,r){var t=Error(r);throw t.name=e,t},isBytes:function(e){if(!(e instanceof Array))return!1;for(var r=0;r255||t<0)return!1}return!0},isInteger:a}}(),h=function(){var e={0:"CUSTOM",1:"BOOLEAN",2:"INTEGER",3:"BIT STRING",4:"OCTET STRING",5:"NULL",6:"OBJECT IDENTIFIER",16:"SEQUENCE",17:"SET",19:"PRINTABLE STRING",23:"UTCTime"};function r(e){var r=e.length;if(r<=127)return[r];var n=t(r);return n.unshift(128|n.length),n}function t(e){var r=[];if(0===e)return[0];for(;e>0;)r.unshift(255&e),e>>>=8;return r}return{parse:function r(t,n){n=!!n;var o,a,i,s=e[31&t[0]],u=t[1],l=0,c=!!(32&t[0]);if(128&u)for(l=0,u=0;l<(127&t[1]);l++)u=(u<<8)+t[2+l];if(i=2+l,void 0===s||u>t.length)return null;var f=c?[]:{};if(f.type=s,f.header=i,f.data=t.slice(0,u+i),c||n)for("BIT STRING"===f.type&&0===t[i]&&l++,o=t.slice(i,f.data.length);o.length>0&&null!==(a=r(o));)f.push(a),o=o.slice(a.data.length);return f},encode:function e(n){if(n.hasOwnProperty("INTEGER")){var o=n.INTEGER;return y.isInteger(o)&&(o=t(o)),128&o[0]&&o.unshift(0),[2].concat(r(o),o)}if(n.hasOwnProperty("OCTET STRING"))return(o=n["OCTET STRING"])instanceof Array||(o=e(o)),[4].concat(r(o),o);if(n.hasOwnProperty("BIT STRING"))return(o=n["BIT STRING"])instanceof Array||(o=e(o)),o.unshift(0),[3].concat(r(o),o);if(n.hasOwnProperty("NULL"))return[5,0];if(n.hasOwnProperty("OBJECT IDENTIFIER"))return o=function(e){for(var r=e.split("."),t=[parseInt(40*r[0]+parseInt(r[1]))],n=2;n0;)a.push(127&o|128),o>>>=7;a[0]=127&a[0],t=t.concat(a.reverse())}return t}(n["OBJECT IDENTIFIER"]),[6].concat(r(o),o);if(n.hasOwnProperty("SEQUENCE")){for(var a=n.SEQUENCE,i=(o=[],0);i0;)t[n+o]=e[r+o]}function y(e){var r,t=0;for(r=0;r=0;l--)a+=i[u++]*(255&e[l]),i[u]===n&&(u=0,o[s++]=a,a=0);for(0!==a&&(o[s]=a);null==o[--t];)o[t]=0;return o}function g(r,t){if(void 0===t)if(r<=1)t=1;else{var o=Math.log(r)/Math.LN2;t=Math.ceil(o/e)}for(var a=[];r>0;)a.push(r%n),r=Math.floor(r/n);for(;a.length=0;r--)if(void 0!==e[r]&&0!==e[r])return r;return 0===e[0]?-1:0}function m(e,r){var t,n,o=0;for(n=0;n=e||o<0)throw new Error("bit count must be smaller than DIGIT_BITS and positive in shiftLeft");void 0===a&&(a=r.length);var i=e-o;n[a]=r[a-1]>>>e-o||n[a];for(var s=a-1;s>0;s--)n[s]=(r[s]<>>i)&t;n[0]=r[0]<>=e;for(s=u;s>=e;return o.length=i.length,0!==l&&(o[s]=l&t),l}function E(r,n,o){var a=n.length;if(r.length>=e;for(;i>=e;return s}function b(e,r,n){r="number"==typeof r?[r]:r;var o,i,s,u,l,c,f,y,h=e.length,g=r.length;for(o=0;o=0;m--)h=c*n+r[m],a[m]=h/g&t,c=h-a[m]*g&t;return a.length=k,v(a),i[0]=c,void(i.length=1)}var b=e-1-function(r){for(var t=0,n=0;n>>n&1)&n);return t}(o[E-1]),x=s||[];x.length=E,w(o,x,b,E);var S=u||[];for(S.length=k,w(r,S,b,k),S[k]=S[k]||0,a.length=k-E+1,i.length=E,m=k-E;m>=0;m--){for(l=Math.floor((S[m+E]*n+S[m+E-1])/x[E-1]),c=S[m+E]*n+S[m+E-1]-l*x[E-1];(l>=n||l*x[E-2]>c*n+S[m+E-2])&&(l-=1,(c+=x[E-1])>e;S[m+E]=S[m+E]+y&t}}for(d=0;d>>b|S[d+1]<0);d.subtract(n,m,o.temp2),u(S,n,o.temp2)}function s(e,r,t){var n,o,a,i,s;for(n=0;n>>=1)s===t&&(l[++u]=0,s=0),l[u]+=(1&n)<>>31,i=0;i0),d.subtract(r,l,f),u(s,r,f),v(r)},ctx:n}}return{DIGIT_BITS:e,DIGIT_NUM_BYTES:r,DIGIT_MASK:t,DIGIT_BASE:n,DIGIT_MAX:o,Zero:u,One:l,normalizeDigitArray:v,bytesToDigits:h,stringToDigits:function(e,r){e=e.replace(/^\s+|\s+$/g,"");var t=[0],n=[0];r=r||10;for(var o=0;o=r;)l[0]=l[0]*r,y=y.concat("0");for(t=0;tn&&0===s[0];)s.shift();return s},isZero:y,isEven:function(e){return 0==(1&e[0])},shiftRight:function(r,n,o,a){if(void 0===o)o=1;else if(o>=e||o<0)throw new Error("Invalid bit count for shiftRight");void 0===a&&(a=r.length);for(var i=a-1,s=e-o,u=0;u>>o)&t;n[i]=r[i]>>>o},shiftLeft:w,compareDigits:m,bitLength:function(e){for(var r=0,t=0;r=0&&0===t;){var o=1<=0)throw new Error("The number provided is not an element of this group");return v(r,this.m_digitWidth,!0),l(r,this)},createElementFromDigits:function(e){return d.normalizeDigitArray(e,this.m_digitWidth,!0),l(e,this)},equals:function(e){return 0===m(this.m_modulus,e.m_modulus)},add:function(r,n,o){var a,i=this.m_digitWidth,s=o.m_digits;d.add(r.m_digits,n.m_digits,s);var u=(m(s,this.m_modulus)>>>31)-1&t,l=0;for(a=0;a>=e;s.length=i},subtract:function(r,n,o){var a,i=this.m_digitWidth,s=o.m_digits,u=d.subtract(r.m_digits,n.m_digits,o.m_digits);if(-1===u)for(u=0,a=0;a>=e},multiply:function(e,r,t){return d.modMul(e.m_digits,r.m_digits,this.m_modulus,t.m_digits,s,u)},inverse:function(e,r){d.modInv(e.m_digits,this.m_modulus,r.m_digits)},modexp:function(e,r,t){if(t=t||l([],this),0===m(r,a))t.m_digits=g(1,this.m_digitWidth);else if(0===m(r,i)){for(var n=0;n0&&(n=r,o=e),S(n,o,void 0,void 0,t),v(t)},sequenceEqual:function(e,r){for(var t=e.length===r.length,n=0;n=0;){for(var o=0;o<8;){var a=1<>>=d.DIGIT_BITS;a<<=d.DIGIT_BITS-1,d.shiftRight(t,t),t[n-1]|=a}else d.shiftRight(r,t)}function I(e,r,t){o.montgomeryMultiply(e,r,t)}function M(e,r){o.montgomeryMultiply(e,e,r)}function C(e,r){var t=r.clone();if(F(t),!z(t))throw new Error("Invalid Parameter");var n=r.clone();O(n);var o,a=[r.clone()],i=n.clone(),s=n.clone();K(n,s),U(s);for(var u=1;u=0)throw new Error("The scalar k must be in the range 1 <= k < order.");if(r=r.slice(),1===t.curve.type){var i=void 0!==t.ta;i||L(t),function(e,r,t,o){if(!G(r))throw new Error("Invalid Parameter");var a=r.curve.rbits;o=void 0===o||o;var i,s,u=n<=8?5:6,l=Math.floor((a+(u-2))/(u-1));e=e.slice();var c=r.clone();L(c),o&&(Q(c,c),Q(c,c));var f=q(1<=0;i--){for(s=0;s>>31);A(r.curve.p,v.x,h);for(var k=0;k=0;g--){for(var p=0;p>>31),w=0;w=o&&(c=h(c))},finish:g,der:r,hashLen:i,maxMessageSize:4294967295}},A=function(){function e(e,t,n,o,a){var i,s,u,l,c=4294967295,f=n[0],y=n[1],h=n[2],g=n[3],p=n[4];for(s=0;s<16;s++)a[s]=r.bytesToInt32(e,64*t+4*s);for(i=16;i<80;i++)l=a[i-3]^a[i-8]^a[i-14]^a[i-16],a[i]=l<<1|l>>>31;for(s=0;s<80;s++)u=f<<5|f>>>27,u+=s>=60?y^h^g:s>=40?y&h^y&g^h&g:s>=20?y^h^g:y&h^~y&g,u+=p+o[s]+a[s],p=g,g=h,h=y<<30|y>>>2,y=f,f=u;return n[0]+=f&c,n[1]+=y&c,n[2]+=h&c,n[3]+=g&c,n[4]+=p&c,n}var r=y,t=r.unpackData,n=t("Z0UjAe/Nq4mYutz+EDJUdsPS4fA=",4,1),o=t("WoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlagnmZWoJ5mVqCeZlu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroW7Z66Fu2euhbtnroY8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcjxu83I8bvNyPG7zcymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdbKYsHWymLB1spiwdY",4,1),a=t("MCEwCQYFKw4DAhoFAAQU");return{sha1:function(){return S("SHA-1",a,n,o,64,e,160)}}}();void 0!==r&&(A.instances={},A.getInstance=function(e){return A.instances[e]||(A.instances[e]=A.sha1())},A.deleteInstance=function(e){A.instances[e]=null,delete A.instances[e]},A.hash=function(e){if("process"!==e.operationSubType)return"finish"===e.operationSubType?A.sha1.finish():A.sha1().computeHash(e.buffer);A.sha1.process(e.buffer)},r.register("digest","SHA-1",A.hash)),f["SHA-1"]=A.sha1;var D=function(){var e=y;function r(r,t,n,o,a){var i,s,u,l,c,f=n[0],y=n[1],h=n[2],g=n[3],p=n[4],d=n[5],m=n[6],v=n[7];for(s=0;s<16;s++)a[s]=e.bytesToInt32(r,64*t+4*s);for(i=16;i<64;i++)l=a[i-15],c=a[i-2],a[i]=((c>>>17|c<<15)^(c>>>19|c<<13)^c>>>10)+a[i-7]+((l>>>7|l<<25)^(l>>>18|l<<14)^l>>>3)+a[i-16],a[i]=4294967295&a[i];for(s=0;s<64;s++)g+=u=v+((p>>>6|p<<26)^(p>>>11|p<<21)^(p>>>25|p<<7))+(p&d^~p&m)+o[s]+a[s],u+=((f>>>2|f<<30)^(f>>>13|f<<19)^(f>>>22|f<<10))+(f&(y^h)^y&h),v=m,m=d,d=p,p=g,g=h,h=y,y=f,f=u;return n[0]=n[0]+f>>>0,n[1]=n[1]+y>>>0,n[2]=n[2]+h>>>0,n[3]=n[3]+g>>>0,n[4]=n[4]+p>>>0,n[5]=n[5]+d>>>0,n[6]=n[6]+m>>>0,n[7]=n[7]+v>>>0,n}var t,n,o,a,i,s=e.unpackData;return n=s("wQWe2DZ81QcwcN0X9w5ZOf/ACzFoWBURZPmPp776T6Q",4,1),o=s("agnmZ7tnroU8bvNypU/1OlEOUn+bBWiMH4PZq1vgzRk",4,1),t=s("QoovmHE3RJG1wPvP6bXbpTlWwltZ8RHxkj+CpKscXtXYB6qYEoNbASQxhb5VDH3Dcr5ddIDesf6b3AanwZvxdOSbacHvvkeGD8GdxiQMocwt6SxvSnSEqlywqdx2+YjamD5RUqgxxm2wAyfIv1l/x8bgC/PVp5FHBspjURQpKWcntwqFLhshOE0sbfxTOA0TZQpzVHZqCruBwskuknIshaK/6KGoGmZLwkuLcMdsUaPRkugZ1pkGJPQONYUQaqBwGaTBFh43bAgnSHdMNLC8tTkcDLNO2KpKW5zKT2gub/N0j4LueKVjb4TIeBSMxwIIkL7/+qRQbOu++aP3xnF48g",4,1),a=s("MC0wDQYJYIZIAWUDBAIEBQAEHA"),i=s("MDEwDQYJYIZIAWUDBAIBBQAEIA"),{sha224:function(){return S("SHA-224",a,n,t,64,r,224)},sha256:function(){return S("SHA-256",i,o,t,64,r,256)}}}();void 0!==r&&(D.instance224=D.instance224||D.sha224(),D.instance256=D.instance256||D.sha256(),D.instances={},D.getInstance224=function(e){return D.instances[e]||(D.instances[e]=D.sha224())},D.getInstance256=function(e){return D.instances[e]||(D.instances[e]=D.sha256())},D.deleteInstance=function(e){D.instances[e]=null,delete D.instances[e]},D.hash256=function(e){if("process"===e.operationSubType)return D.getInstance256(e.workerid).process(e.buffer),null;if("finish"===e.operationSubType){var r=D.getInstance256(e.workerid).finish();return D.deleteInstance(e.workerid),r}if("abort"!==e.operationSubType)return D.instance256.computeHash(e.buffer);D.deleteInstance(e.workerid)},D.hash224=function(e){if("process"!==e.operationSubType){if("finish"===e.operationSubType&&D.getInstance224(e.workerid).finish(),"abort"!==e.operationSubType)return D.instance224.computeHash(e.buffer);msrcryptoSha224.deleteInstance(e.workerid)}else D.getInstance224(e.workerid).process(e.buffer)},r.register("digest","SHA-224",D.hash224),r.register("digest","SHA-256",D.hash256)),f["SHA-224"]=D.sha224,f["SHA-256"]=D.sha256;var T=function(){function e(e,r,t,n,o){var a=r+n|0,i=a>>>0>>0;o[0]=e+t+i|0,o[1]=a}function r(r,t,n,o,a){var i,s,u,l,c,f,y,h,g,p=[],d=[],m=[],v=n[0],w=n[1],k=n[2],E=n[3],b=n[4],x=n[5],S=n[6],A=n[7],D=n[8],T=n[9],I=n[10],M=n[11],C=n[12],K=n[13],H=n[14],P=n[15];for(i=0;i<32;i++)g=128*t+4*i,a[i]=r.slice(g,g+4),a[i]=a[i][0]<<24|a[i][1]<<16|a[i][2]<<8|a[i][3];for(i=32;i<160;i+=2)u=((y=a[i-30])>>>1|(h=a[i-29])<<31)^(y>>>8|h<<24)^y>>>7,l=(h>>>1|y<<31)^(h>>>8|y<<24)^(h>>>7|y<<25),e(c=((y=a[i-4])>>>19|(h=a[i-3])<<13)^(h>>>29|y<<3)^y>>>6,f=(h>>>19|y<<13)^(y>>>29|h<<3)^(h>>>6|y<<26),a[i-14],a[i-13],p),e(u,l,p[0],p[1],p),e(a[i-32],a[i-31],p[0],p[1],p),a[i]=p[0],a[i+1]=p[1];for(s=0;s<160;s+=2)c=D&I^C&~D,f=T&M^K&~T,e(H,P,u=(D>>>14|T<<18)^(D>>>18|T<<14)^(T>>>9|D<<23),l=(T>>>14|D<<18)^(T>>>18|D<<14)^(D>>>9|T<<23),p),e(c,f,o[s],o[s+1],d),e(p[0],p[1],a[s],a[s+1],m),e(d[0],d[1],m[0],m[1],m),e(m[0],m[1],S,A,p),S=p[0],A=p[1],f=w&(E^x)^E&x,c=v&(k^b)^k&b,e(m[0],m[1],u=(v>>>28|w<<4)^(w>>>2|v<<30)^(w>>>7|v<<25),l=(w>>>28|v<<4)^(v>>>2|w<<30)^(v>>>7|w<<25),p),e(c,f,u=p[0],l=p[1],p),H=C,P=K,C=I,K=M,I=D,M=T,D=S,T=A,S=b,A=x,b=k,x=E,k=v,E=w,v=u=p[0],w=l=p[1];return e(n[0],n[1],v,w,p),n[0]=p[0],n[1]=p[1],e(n[2],n[3],k,E,p),n[2]=p[0],n[3]=p[1],e(n[4],n[5],b,x,p),n[4]=p[0],n[5]=p[1],e(n[6],n[7],S,A,p),n[6]=p[0],n[7]=p[1],e(n[8],n[9],D,T,p),n[8]=p[0],n[9]=p[1],e(n[10],n[11],I,M,p),n[10]=p[0],n[11]=p[1],e(n[12],n[13],C,K,p),n[12]=p[0],n[13]=p[1],e(n[14],n[15],H,P,p),n[14]=p[0],n[15]=p[1],n}var t,n,o,a,i,s,u,l=y.unpackData;return t=l("y7udXcEFnthimikqNnzVB5FZAVowcN0XFS/s2PcOWTlnMyZn/8ALMY60SodoWBUR2wwuDWT5j6dHtUgdvvpPpA==",4,1),n=l("agnmZ/O8yQi7Z66FhMqnOzxu83L+lPgrpU/1Ol8dNvFRDlJ/reaC0ZsFaIwrPmwfH4PZq/tBvWtb4M0ZE34heQ",4,1),o=l("QoovmNcoriJxN0SRI+9lzbXA+8/sTTsv6bXbpYGJ27w5VsJb80i1OFnxEfG2BdAZkj+CpK8ZT5urHF7V2m2BGNgHqpijAwJCEoNbAUVwb74kMYW+TuSyjFUMfcPV/7Ticr5ddPJ7iW+A3rH+OxaWsZvcBqclxxI1wZvxdM9pJpTkm2nBnvFK0u++R4Y4TyXjD8GdxouM1bUkDKHMd6ycZS3pLG9ZKwJ1SnSEqm6m5INcsKncvUH71Hb5iNqDEVO1mD5RUu5m36uoMcZtLbQyELADJ8iY+yE/v1l/x77vDuTG4AvzPaiPwtWnkUeTCqclBspjUeADgm8UKSlnCg5ucCe3CoVG0i/8LhshOFwmySZNLG38WsQq7VM4DROdlbPfZQpzVIuvY952agq7PHeyqIHCyS5H7a7mknIshRSCNTuiv+ihTPEDZKgaZku8QjABwkuLcND4l5HHbFGjBlS+MNGS6BnW71IY1pkGJFVlqRD0DjWFV3EgKhBqoHAyu9G4GaTBFrjS0MgeN2wIUUGrUydId0zfjuuZNLC8teGbSKg5HAyzxclaY07YqkrjQYrLW5zKT3dj43NoLm/z1rK4o3SPgu5d77L8eKVjb0MXL2CEyHgUofCrcozHAggaZDnskL7/+iNjHiikUGzr3oK96b75o/eyxnkVxnF48uNyUyvKJz7O6iZhnNGGuMchwMIH6tp91s3g6x71fU9/7m7ReAbwZ6pyF2+6CmN9xaLImKYRP5gEvvkNrhtxCzUTHEcbKNt39SMEfYQyyqt7QMckkzyevgoVyb68Qx1nxJwQDUxMxdS+yz5Ctll/KZz8ZX4qX8tvqzrW+uxsRBmMSkdYFw==",4,1),a=l("MEEwDQYJYIZIAWUDBAICBQAEMA"),i=l("MFEwDQYJYIZIAWUDBAIDBQAEQA"),s=l("MC0wDQYJYIZIAWUDBAIFBQAEHA"),u=l("MDEwDQYJYIZIAWUDBAIGBQAEIA"),{sha384:function(){return S("SHA-384",a,t,o,128,r,384)},sha512:function(){return S("SHA-512",i,n,o,128,r,512)},sha512_224:function(){return S("SHA-512.224",s,n,o,128,r,224)},sha512_256:function(){return S("SHA-512.256",u,n,o,128,r,256)}}}();void 0!==r&&(T.instances={},T.getInstance384=function(e){return T.instances[e]||(T.instances[e]=T.sha384())},T.getInstance512=function(e){return T.instances[e]||(T.instances[e]=T.sha512())},T.deleteInstance=function(e){T.instances[e]=null,delete T.instances[e]},T.hash384=function(e){if("process"!==e.operationSubType)return"finish"===e.operationSubType?T.sha384.finish():T.sha384().computeHash(e.buffer);T.sha384.process(e.buffer)},T.hash512=function(e){if("process"!==e.operationSubType)return"finish"===e.operationSubType?T.sha512.finish():T.sha512().computeHash(e.buffer);T.sha512.process(e.buffer)},r.register("digest","SHA-384",T.hash384),r.register("digest","SHA-512",T.hash512)),f["SHA-384"]=T.sha384,f["SHA-512"]=T.sha512;var I=function(e,r){var t,n,o,a,i,s={384:128,512:128}[r.name.replace(/SHA-/,"")]||64,u=e.length===s?e:e.length>s?c(r.computeHash(e),s):c(e,s);function l(e,r){for(var t=new Array(e),n=0;n6&&h%t==4&&f(r);var d=l(g(y,h-t),r);a=d,s=0,(o=y)[4*(i=h)]=a[4*s],o[4*i+1]=a[4*s+1],o[4*i+2]=a[4*s+2],o[4*i+3]=a[4*s+3],h+=1}return y}(e),{encrypt:function(e){var r,t=e;for(c(t,o,0),r=1;r<=n-1;r+=1)f(t),a(t),s(t),c(t,o,4*r*4);return f(t),a(t),c(t,o,4*n*4),t},decrypt:function(e){var r,t=e;for(c(t,o,4*n*4),r=n-1;r>=1;r-=1)i(t),h(t),c(t,o,4*r*4),u(t);return i(t),h(t),c(t,o,0),t},clear:function(){},keyLength:r,blockSize:128}}},G=G||{};G.pkcsv7=function(e){return{pad:function(r){var t=r[r.length-1>=0?r.length-1:0],n=t.length;if(n===e){var o,a=[];for(o=0;o>7-i%8&1)),n=0;n<16;n++)l[n]=l[n]^c[n]&t;t=255&-(1&c[15]),v(c),c[0]^=225&t}return l}function v(e){for(var r=e.length-1;r>0;r--)e[r]=(1&e[r-1])<<7|e[r]>>>1;return e[0]=e[0]>>>1,e}function w(e){for(var r=256,t=1;t<=4;t++)r=(r>>>8)+e[e.length-t],e[e.length-t]=255&r;return e}function k(r,t){var n,o=Math.ceil(t.length/16),a=[];i!==r&&(i=r.slice());for(var u=0;u>>24&255,e>>>16&255,e>>>8&255,255&e]}function b(){g=0,u=[],h=[],c=s.getVector(16),f=[],i=r=t=null}return{init:function(e,i,u){if(t=i||[],(n=isNaN(u)?128:u)%8!=0)throw new Error("DataError");if(12===(r=e).length)o=r.concat([0,0,0,1]);else{var f=16*Math.ceil(r.length/16)-r.length;o=p(l,r.concat(s.getVector(f+8)).concat(E(8*r.length))),c=s.getVector(16)}var y,h;a=w(o.slice()),p(l,(y=t,h=16*Math.ceil(t.length/16)-t.length,y.concat(s.getVector(h))))},encrypt:function(e){g=e.length;var r=k(a,e);p(l,r);var t=d(),i=k(o,t).slice(0,n/8);return b(),r.slice().concat(i)},decrypt:function(e,r){g=e.length;var t=k(a,e);p(l,e);var i=d(),u=k(o,i).slice(0,n/8);return b(),s.arraysEqual(u,r)?t:null},processEncrypt:function(e){var r=(u=u.concat(e)).slice(0,16*Math.floor(u.length/16));g+=r.length,u=u.slice(r.length);var t=k(i||a,r);h=h.concat(t),p(l,t)},processDecrypt:function(e){var r=(u=u.concat(e)).slice(0,16*Math.floor((u.length-n/8)/16));g+=r.length,u=u.slice(r.length);var t=k(i||a,r);h=h.concat(t),p(l,r)},finishEncrypt:function(){var e=k(i,u);h=h.concat(e),g+=u.length;var r=d(),t=k(o,r).slice(0,n/8),a=h.slice().concat(t);return b(),a},finishDecrypt:function(){var e=Math.floor(n/8),r=u.slice(-e);u=u.slice(0,u.length-e);var t=k(i,u);h=h.concat(t),g+=u.length;var a=d(),l=k(o,a).slice(0,n/8),c=h.slice();return b(),s.arraysEqual(l,r)?c:null}}};if(void 0!==r){var j={};W.encrypt=function(e){var r,t=e.workerid;if(j[t]||(j[t]=W(z.aes(e.keyData)),j[t].init(e.algorithm.iv,e.algorithm.additionalData,e.algorithm.tagLength)),"process"!==e.operationSubType)return"finish"===e.operationSubType?(r=j[t].finishEncrypt(),j[t]=null,r):(r=j[t].encrypt(e.buffer),j[t]=null,r);j[t].processEncrypt(e.buffer)},W.decrypt=function(e){var r,t=e.workerid;if(j[t]||(j[t]=W(z.aes(e.keyData)),j[t].init(e.algorithm.iv,e.algorithm.additionalData,e.algorithm.tagLength)),"process"!==e.operationSubType){if("finish"===e.operationSubType){if(r=j[t].finishDecrypt(),j[t]=null,null===r)throw new Error("OperationError");return r}var n=e.algorithm.tagLength?Math.floor(e.algorithm.tagLength/8):16,o=e.buffer.slice(0,e.buffer.length-n),a=e.buffer.slice(-n);if(r=j[t].decrypt(o,a),j[t]=null,null===r)throw new Error("OperationError");return r}j[t].processDecrypt(e.buffer)},W.generateKey=function(e){if(e.algorithm.length%8!=0)throw new Error;return{type:"keyGeneration",keyData:Z.getBytes(Math.floor(e.algorithm.length/8)),keyHandle:{algorithm:e.algorithm,extractable:e.extractable,usages:e.usages,type:"secret"}}},W.importKey=function(e){var r,t=8*e.keyData.length;if("jwk"===e.format)r=p.jwkToKey(e.keyData,e.algorithm,["k"]);else{if("raw"!==e.format)throw new Error("unsupported import format");if(128!==t&&192!==t&&256!==t)throw new Error("invalid key length (should be 128, 192, or 256 bits)");r={k:y.toArray(e.keyData)}}return{type:"keyImport",keyData:r.k,keyHandle:{algorithm:e.algorithm,extractable:e.extractable||r.extractable,usages:e.usages,type:"secret"}}},W.exportKey=function(e){if("jwk"===e.format)return{type:"keyExport",keyHandle:p.keyToJwk(e.keyHandle,e.keyData)};if("raw"===e.format)return{type:"keyExport",keyHandle:e.keyData};throw new Error("unsupported export format")},r.register("importKey","AES-GCM",W.importKey),r.register("exportKey","AES-GCM",W.exportKey),r.register("generateKey","AES-GCM",W.generateKey),r.register("encrypt","AES-GCM",W.encrypt),r.register("decrypt","AES-GCM",W.decrypt)}var Q=function(e){return{encrypt:function(r){for(var t=[[0]],n=0;n0;c--,u>>>=8)o[c]^=255&u}var f=o;for(n=1;n<=a;n++)f=f.concat(i[n]);return f},decrypt:function(r){for(var t=[],n=0;n=0;u--)for(n=o;n>=1;n--){for(var l=o*u+n,c=7;l>0;c--,l>>>=8)s[c]^=255&l;var f=e.decrypt(s.concat(a[n]));s=f.slice(0,8),a[n]=f.slice(8)}if("166,166,166,166,166,166,166,166"!==s.join(","))throw y.error("OperationError","");for(n=1;n<=o;n++)i=i.concat(a[n]);return i}}};if(void 0!==r){var V={};Q.workerEncrypt=function(e){var r,t=e.workerid;if(e.buffer.length%8!=0)throw y.error("DataError","The AES-KW input data length is invalid: not a multiple of 8 bytes");return V[t]||(V[t]=Q(z.aes(e.keyData))),r=V[t].encrypt(e.buffer),V[t]=null,r},Q.workerDecrypt=function(e){var r,t=e.workerid;if(e.buffer.length%8!=0)throw y.error("DataError","The AES-KW input data length is invalid: not a multiple of 8 bytes");return V[t]||(V[t]=Q(z.aes(e.keyData))),r=V[t].decrypt(e.buffer),V[t]=null,r},Q.generateKey=function(e){if(e.algorithm.length%8!=0)throw y.error("OperationError","AES key length must be 128, 192, or 256 bits");return{type:"keyGeneration",keyData:Z.getBytes(Math.floor(e.algorithm.length/8)),keyHandle:{algorithm:e.algorithm,extractable:e.extractable,usages:e.usages,type:"secret"}}},Q.importKey=function(e){var r,t=8*e.keyData.length;if("jwk"===e.format)r=p.jwkToKey(e.keyData,e.algorithm,["k"]);else{if("raw"!==e.format)throw new TypeError("Invalid keyFormat argument");if(128!==t&&192!==t&&256!==t)throw y.error("OperationError","AES key length must be 128, 192, or 256 bits");r={k:y.toArray(e.keyData)}}return e.algorithm.length=8*r.k.length,{keyData:r.k,keyHandle:{algorithm:e.algorithm,extractable:e.extractable||r.extractable,usages:e.usages,type:"secret"},type:"keyImport"}},Q.exportKey=function(e){if("jwk"===e.format)return{type:"keyExport",keyHandle:p.keyToJwk(e.keyHandle,e.keyData)};if("raw"===e.format)return{type:"keyExport",keyHandle:e.keyData};throw new TypeError("Invalid keyFormat argument")},r.register("importKey","AES-KW",Q.importKey),r.register("exportKey","AES-KW",Q.exportKey),r.register("generateKey","AES-KW",Q.generateKey),r.register("encrypt","AES-KW",Q.workerEncrypt),r.register("decrypt","AES-KW",Q.workerDecrypt)}function J(){if(!(this instanceof J))throw new Error("create MsrcryptoPrng object with new keyword");var e,r,t,n,o=!1,a=1,i=Math.pow(2,48);function s(e){var r;for(r=e.length-1;r>=0&&(e[r]+=1,e[r]>=256&&(e[r]=0),!e[r]);r-=1);}function u(){e=y.getVector(32),r=y.getVector(16),t=32,n=48,a=1}function l(e,r){if((r=r||[0]).length>n)throw new Error("Incorrect entropy or additionalEntropy length");r=r.concat(y.getVector(n-r.length)),e=e.concat(y.getVector((n-e.length%n)%n));for(var t=0;t=65536)throw new Error("too much random requested");if(a>i)throw new Error("Reseeding is required");if(o&&o.length>0){for(;o.length=0;)i=(s=i*f+n[a--])-(s/u|0)*u;r[o]=i}}function a(e,r){var t=e,n=[];d.subtract(t,[1],n);var o=function(e){var r,t=0,n=0;if(d.isZero(e))return 0;for(t=0;0===e[t];t++);for(n=0,r=2;e[t]%r==0;r*=2,n++);return t*d.DIGIT_BITS+n}(n),a=[];d.shiftRight(n,a,o);for(var s,u=function(e){var r=0,t=0,n=0;if(d.isZero(e))return 0;for(r=e.length-1;0===e[r];r--);for(n=1<<(t=d.DIGIT_BITS-1);t>0&&0==(e[r]&n);n>>>=1,t--);return r*d.DIGIT_BITS+t}(t),l=d.MontgomeryMultiplier(t),c=1;c<=r;c++){var f=!1;do{s=i(u)}while(d.compareDigits(s,n)>=0);var y=[];if(l.modExp(s,a,y,!0),0!==d.compareDigits(y,[1])&&0!==d.compareDigits(y,n)){for(var h=1;h>>24&255,a>>>16&255,a>>>8&255,255&a],o=t.computeHash(e.concat(n)),i=i.concat(o);return i.slice(0,r)},checkMessageVsMaxHash:function(e,r){if(e.length>(r.maxMessageSize||4294967295))throw new Error("message too long")}};(Y=Y||{}).oaep=function(e,r){var t=y,n=Z,o=e.n.length;if(null===r)throw new Error("must supply hashFunction");return{pad:function(e,a){return function(e,a){var i,s,u,l,c,f,y,h,g;if(e.length>o-r.hashLen/8*2-2)throw new Error("Message too long.");return null==a&&(a=[]),i=r.computeHash(a),s=o-e.length-2*i.length-2,u=t.getVector(s),l=i.concat(u,[1],e),c=n.getBytes(i.length),f=$.mgf1(c,o-i.length-1,r),y=t.xorVectors(l,f),h=$.mgf1(y,i.length,r),g=t.xorVectors(c,h),e=[0].concat(g).concat(y).slice()}(e,a)},unpad:function(e,n){return function(e,n){var a,i,s,u,l,c,f,y,h=0,g=0===e[0];for(n||(n=[]),a=r.computeHash(n),i=e.slice(1,a.length+1),s=e.slice(a.length+1),u=$.mgf1(s,a.length,r),l=t.xorVectors(i,u),c=$.mgf1(l,o-a.length-1,r),y=(f=t.xorVectors(s,c)).slice(0,a.length),g=g&&t.arraysEqual(a,y),f=f.slice(a.length);!f[h++];);return{valid:g,data:f.slice(h)}}(e,n)}}},(Y=Y||{}).pkcs1Encrypt=function(e){var r=Z,t=e.n.length;return{pad:function(e){return function(e){var n;if(e.length>t-11)throw new Error("message too long");return n=r.getNonZeroBytes(t-e.length-3),[0,2].concat(n,[0],e)}(e)},unpad:function(e){return function(e){var r,t=function(e){for(var r=0===e[0]&&2===e[1],t=2;t<10;t++)r=r&&!!e[t];return r}(e),n=0;for(r=1;r>>8-(8*s-i);for(var g=0;g0){var a=n;n=o,o=a}var i=[];d.multiply(n,o,i);var s=[];d.subtract(n,[1],s);var u=[];d.subtract(o,[1],u);var l=[];d.multiply(s,u,l);var c=[];d.gcd(t,l,c);var f=0===d.compareDigits(c,d.One)}while(!f);var y=[];d.modInv(t,l,y);var h=[];d.reduce(y,s,h);var g=[];d.reduce(y,u,g);var p=[];d.modInv(o,n,p);var m=d.digitsToBytes;return{privateKey:{n:m(i),e:m(t),d:m(y),p:m(n),q:m(o),dp:m(h),dq:m(g),qi:m(p)},publicKey:{n:m(i),e:m(t)}}},ee.generateKeyPair=function(e){if(void 0===e.algorithm.modulusLength)throw new Error("missing modulusLength");var r,t=d.bytesToDigits;switch(e.algorithm.modulusLength){case 1024:case 2048:case 4096:r=ee.genRsaKeyFromRandom(e.algorithm.modulusLength,e.algorithm.publicExponent);break;default:throw new Error("invalid modulusLength")}var n=r.privateKey;n.ctxp=new d.MontgomeryMultiplier(t(n.p)).ctx,n.ctxq=new d.MontgomeryMultiplier(t(n.q)).ctx;var o,a,i=e.algorithm.name;return i.slice(i.indexOf("-")+1).toUpperCase(),"RSASSA-PKCS1-V1_5"===i||"RSA-PSS"===i?(o=["verify"],a=["sign"]):(o=["encrypt"],a=["decrypt"]),{type:"keyGeneration",keyPair:{publicKey:{keyData:r.publicKey,keyHandle:{algorithm:e.algorithm,extractable:e.extractable,usages:o,type:"public"}},privateKey:{keyData:r.privateKey,keyHandle:{algorithm:e.algorithm,extractable:e.extractable,usages:a,type:"private"}}}}},r.register("sign","RSASSA-PKCS1-V1_5",ee.sign),r.register("sign","RSA-PSS",ee.sign),r.register("verify","RSASSA-PKCS1-V1_5",ee.verify),r.register("verify","RSA-PSS",ee.verify),r.register("encrypt","RSAES-PKCS1-V1_5",ee.workerEncrypt),r.register("decrypt","RSAES-PKCS1-V1_5",ee.workerDecrypt),r.register("encrypt","RSA-OAEP",ee.workerEncrypt),r.register("decrypt","RSA-OAEP",ee.workerDecrypt),r.register("importKey","RSA-OAEP",ee.importKey),r.register("importKey","RSAES-PKCS1-V1_5",ee.importKey),r.register("importKey","RSASSA-PKCS1-V1_5",ee.importKey),r.register("importKey","RSA-PSS",ee.importKey),r.register("exportKey","RSA-OAEP",ee.exportKey),r.register("exportKey","RSAES-PKCS1-V1_5",ee.exportKey),r.register("exportKey","RSASSA-PKCS1-V1_5",ee.exportKey),r.register("exportKey","RSA-PSS",ee.exportKey),r.register("generateKey","RSA-OAEP",ee.generateKeyPair),r.register("generateKey","RSAES-PKCS1-V1_5",ee.generateKeyPair),r.register("generateKey","RSASSA-PKCS1-V1_5",ee.generateKeyPair),r.register("generateKey","RSA-PSS",ee.generateKeyPair));var re={deriveBits:function(e){for(var r=e.algorithm.hash.name,t=f[r.toUpperCase()](),n=e.algorithm,o=ue.toArray(n.algorithmId).concat(ue.toArray(n.partyUInfo),ue.toArray(n.partyVInfo),ue.toArray(n.publicInfo)||[],ue.toArray(n.privateInfo)||[]),a=Math.ceil(e.length/t.hashLen),i=1,s=e.keyData.concat(o),u=[],l=0;l>>24&255,n>>>16&255,n>>>8&255,255&n]),i=0;i255*r)throw new Error("The length provided for HKDF is too large.");for(0===s.length&&(s=y.getVector(r)),(n={workerid:0,keyHandle:{algorithm:o},keyData:s,buffer:a}).keyData=I.signHmac(n),t=0;t255*r)throw new Error("The length provided for HKDF-CTR is too large.");n={workerid:0,keyHandle:{algorithm:o},keyData:a,buffer:a};var f=s.concat([0],u,ue.int32ToBytes(i));for(t=1;t<=Math.ceil(l/r);t++)n.buffer=ue.int32ToBytes(t).concat(f),c=c.concat(I.signHmac(n));return c.slice(0,l)}};void 0!==r&&(oe.importKey=function(e){var r;if("raw"!==e.format)throw new Error("unsupported import format");if(r=y.toArray(e.keyData),!1!==e.extractable)throw new Error("only extractable=false is supported.");return{type:"keyImport",keyData:r,keyHandle:{algorithm:{name:"HKDF-CTR"},extractable:!1,usages:e.usages,type:"secret"}}},r.register("deriveBits","HKDF-CTR",oe.deriveBits),r.register("importKey","HKDF-CTR",oe.importKey));var ae=function(e){var r=d.bytesToDigits,t=d.digitsToBytes,n=e,o=new m.EllipticCurveOperatorFp(e);return{generateKey:function(r){var a=[],i=Z.getBytes(e.order.length*d.DIGIT_NUM_BYTES);d.reduce(d.bytesToDigits(i),n.order,a);var s=n.allocatePointStorage();return o.scalarMultiply(a,n.generator,s),{privateKey:{x:t(s.x),y:t(s.y),d:t(a)},publicKey:{x:t(s.x),y:t(s.y)}}},deriveBits:function(e,t,a){var i=new m.EllipticCurvePointFp(n,!1,r(t.x),r(t.y),null,!1),s=n.allocatePointStorage();o.convertToJacobianForm(s),o.convertToMontgomeryForm(s),o.scalarMultiply(r(e.d),i,s),o.convertToAffineForm(s),o.convertToStandardForm(s);var u=d.digitsToBytes(s.x,!0,t.x.length);if(a&&8*u.length>>l;return(u=a?u.slice(0,Math.ceil(a/8)):u)[u.length-1]=u[u.length-1]&c,u},computePublicKey:function(e){n.generator.isInMontgomeryForm||o.convertToMontgomeryForm(n.generator);var a=n.allocatePointStorage();return o.convertToJacobianForm(a),o.convertToMontgomeryForm(a),o.scalarMultiply(r(e),n.generator,a),{x:t(a.x),y:t(a.y)}}}};void 0!==r&&(ae.deriveBits=function(e){var r=m.createCurve(e.algorithm.namedCurve.toUpperCase()),t=e.keyData,n=e.additionalKeyData;return ae(r).deriveBits(t,n,e.length)},ae.deriveKey=function(e){throw new Error("not supported")},ae.generateKey=function(e){var r=m.createCurve(e.algorithm.namedCurve.toUpperCase()),t=ae(r).generateKey();return{type:"keyPairGeneration",keyPair:{publicKey:{keyData:t.publicKey,keyHandle:{algorithm:e.algorithm,extractable:e.extractable,usages:[],type:"public"}},privateKey:{keyData:t.privateKey,keyHandle:{algorithm:e.algorithm,extractable:e.extractable,usages:e.usages,type:"private"}}}}},ae.importKey=function(e){try{if("raw"===e.format){var r=e.keyData;if(4!==r[0])throw new Error("DataError");var t=~~((r.length-1)/2),n=e.algorithm.namedCurve.toUpperCase(),o=r.slice(1,t+1),a=r.slice(t+1);if(!1===m.validatePoint(n,o,a))throw new Error("DataError");return{type:"keyImport",keyData:{x:o,y:a},keyHandle:{algorithm:e.algorithm,extractable:e.extractable||!1,usages:e.usages,type:"public"}}}if("jwk"===e.format){if((l=p.jwkToKey(e.keyData,e.algorithm,["x","y","d","crv"])).d&&(!l.x||!l.y)){var i=m.createCurve(e.algorithm.namedCurve.toUpperCase()),s=ae(i).computePublicKey(l.d);l.x=s.x,l.y=s.y}if(!1===m.validatePoint(e.algorithm.namedCurve.toUpperCase(),l.x,l.y))throw new Error("DataError");return{type:"keyImport",keyData:l,keyHandle:{algorithm:e.algorithm,extractable:e.extractable||l.extractable,usages:e.usages,type:l.d?"private":"public"}}}if("spki"===e.format){var u={"P-256":32,"P-384":48,"P-521":66}[e.algorithm.namedCurve];if(null==(c=h.parse(e.keyData)))throw new Error("invalid key data.");if(null==(d=(g=c[1]).data.slice(g.header+1))||4!==d.shift()||d.length!==2*u)throw new Error("invalid key data.");if(o=d.slice(0,u),a=d.slice(u),!y.isBytes(o)||!y.isBytes(a))throw new Error("invalid key data.");var l={x:o,y:a};if(!1===m.validatePoint(e.algorithm.namedCurve.toUpperCase(),l.x,l.y))throw new Error("DataError");return{type:"keyImport",keyData:l,keyHandle:{algorithm:e.algorithm,extractable:e.extractable,usages:e.usages,type:"public"}}}if("pkcs8"===e.format){var c;if(u={"P-256":32,"P-384":48,"P-521":66}[e.algorithm.namedCurve],null==(c=h.parse(e.keyData)))throw new Error("invalid key data.");var f=c[2];if(null==(d=h.parse(f.data.slice(f.header))))throw new Error("invalid key data.");var g,d,v=d[1].data.slice(d[1].header);if(null==(d=(g=h.parse(d[2][0].data)).data.slice(g.header+1))||4!==d.shift()||d.length!==2*u)throw new Error("invalid key data.");if(o=d.slice(0,u),a=d.slice(u),!y.isBytes(o)||!y.isBytes(a))throw new Error("invalid key data.");if(l={x:o,y:a,d:v},!1===m.validatePoint(e.algorithm.namedCurve.toUpperCase(),l.x,l.y))throw new Error("DataError");return{type:"keyImport",keyData:l,keyHandle:{algorithm:e.algorithm,extractable:e.extractable,usages:e.usages,type:"private"}}}}catch(e){throw new y.error("DataError","")}},ae.exportKey=function(e){var r={"P-256":"1.2.840.10045.3.1.7 ","P-384":"1.3.132.0.34","P-521":"1.3.132.0.35"};if("raw"===e.format&&"public"===e.keyHandle.type)return{type:"keyExport",keyHandle:[4].concat(e.keyData.x,e.keyData.y)};if("jwk"===e.format)return{type:"keyExport",keyHandle:p.keyToJwk(e.keyHandle,e.keyData)};if("spki"===e.format)return{type:"keyExport",keyHandle:h.encode({SEQUENCE:[{SEQUENCE:[{"OBJECT IDENTIFIER":"1.2.840.10045.2.1"},{"OBJECT IDENTIFIER":r[e.algorithm.namedCurve]}]},{"BIT STRING":[4].concat(e.keyData.x,e.keyData.y)}]})};if("pkcs8"===e.format)return{type:"keyExport",keyHandle:h.encode({SEQUENCE:[{INTEGER:0},{SEQUENCE:[{"OBJECT IDENTIFIER":"1.2.840.10045.2.1"},{"OBJECT IDENTIFIER":r[e.algorithm.namedCurve]}]},{"OCTET STRING":{SEQUENCE:[{INTEGER:1},{"OCTET STRING":e.keyData.d},{APPLICATION:[{"BIT STRING":[4].concat(e.keyData.x,e.keyData.y)}],tag:1}]}}]})};throw new Error("unsupported export format.")},r.register("importKey","ECDH",ae.importKey),r.register("exportKey","ECDH",ae.exportKey),r.register("generateKey","ECDH",ae.generateKey),r.register("deriveBits","ECDH",ae.deriveBits),r.register("deriveKey","ECDH",ae.deriveKey));var ie,se=function(e){var r=d.bytesToDigits,t=d.digitsToBytes,n=new m.EllipticCurveOperatorFp(e),o=t(e.order).length,a=1===e.type;function i(r){var t=e.allocatePointStorage();return n.scalarMultiply(r,e.generator,t),{publicKey:t,privateKey:r}}function s(r){var t=[];return r||(r=Z.getBytes(e.order.length*d.DIGIT_NUM_BYTES)),d.reduce(d.bytesToDigits(r),e.order,t),i(t)}function u(t){t.length>o&&(t.length=o);var n=r(t);if(a){var i=8-e.rbits%8;d.shiftRight(n,n,i)}return d.reduce(n,e.order,n),n}return{createKey:function(e){return i(r(e))},generateKey:s,sign:function(n,a,i){i||(i=s());var l=i.publicKey.x,c=i.privateKey,f=r(n.d),h=u(a.slice()),g=[],p=[];d.reduce(l,e.order,l),d.modMul(l,f,e.order,g),d.add(g,h,g),d.reduce(g,e.order,g),d.modInvCT(c,e.order,p),d.modMul(g,p,e.order,g);var m=y.padFront(t(l,!0,o),0,o),v=y.padFront(t(g,!0,o),0,o);return m.concat(v)},verify:function(t,o,i){var s=Math.floor(o.length/2),l=r(o.slice(0,s)),c=r(o.slice(s)),f=u(i.slice()),y=[],h=[],g=new m.EllipticCurvePointFp(e,!1,r(t.x),r(t.y),null,!1);d.modInv(c,e.order,c),d.modMul(f,c,e.order,y),d.modMul(l,c,e.order,h);var p=e.allocatePointStorage(),v=e.allocatePointStorage();return a?(d.add(y,y,y),d.add(y,y,y),d.reduce(y,e.order,y),n.scalarMultiply(y,e.generator,p,!1),n.scalarMultiply(h,g,v,!1),n.convertToExtendedProjective(p),n.convertToExtendedProjective(v),n.add(v,p,p),n.normalize(p)):(n.scalarMultiply(y,e.generator,p),n.scalarMultiply(h,g,v),n.convertToJacobianForm(p),n.convertToMontgomeryForm(p),n.convertToMontgomeryForm(v),n.mixedAdd(p,v,p),n.convertToAffineForm(p),n.convertToStandardForm(p)),!p.isInfinity&&(d.reduce(p.x,e.order,p.x),0===d.compareDigits(p.x,l))}}};void 0!==r&&(se.sign=function(e){y.checkParam(e.algorithm.hash,"Object","algorithm.hash"),y.checkParam(e.algorithm.hash.name,"String","algorithm.hash.name"),y.checkParam(e.keyHandle.algorithm.namedCurve,"String","p.keyHandle.algorithm.namedCurve");var r=e.algorithm.hash.name,t=m.createCurve(e.keyHandle.algorithm.namedCurve.toUpperCase()),n=f[r.toUpperCase()]().computeHash(e.buffer);return se(t).sign(e.keyData,n)},se.verify=function(e){var r=e.algorithm.hash.name,t=m.createCurve(e.keyHandle.algorithm.namedCurve.toUpperCase()),n=f[r.toUpperCase()]().computeHash(e.buffer);return se(t).verify(e.keyData,e.signature,n)},se.generateKey=function(e){var r=m.createCurve(e.algorithm.namedCurve.toUpperCase()),t=se(r).generateKey(),n=d.digitsToBytes;function o(e){return e}var a=o(n(t.publicKey.x)),i=o(n(t.publicKey.y)),s=o(n(t.privateKey));return{type:"keyPairGeneration",keyPair:{publicKey:{keyData:{x:a,y:i},keyHandle:{algorithm:e.algorithm,extractable:e.extractable,usages:["verify"],type:"public"}},privateKey:{keyData:{x:a,y:i,d:s},keyHandle:{algorithm:e.algorithm,extractable:e.extractable,usages:["sign"],type:"private"}}}}},se.importKey=function(e){if("raw"===e.format){var r=e.keyData;if(4!==r[0])throw new Error("DataError");var t=~~((r.length-1)/2),n=e.algorithm.namedCurve.toUpperCase(),o=r.slice(1,t+1),a=r.slice(t+1);if(!1===m.validatePoint(n,o,a))throw new Error("DataError");return{type:"keyImport",keyData:{x:o,y:a},keyHandle:{algorithm:e.algorithm,extractable:e.extractable,usages:e.usages,type:"public"}}}if("jwk"===e.format){if((l=p.jwkToKey(e.keyData,e.algorithm,["x","y","d","crv"])).d&&(!l.x||!l.y)){var i=se.curves[e.algorithm.namedCurve](),s=se(i).computePublicKey(l.d);l.x=s.x,l.y=s.y}if(!1===m.validatePoint(e.algorithm.namedCurve.toUpperCase(),l.x,l.y))throw new Error("DataError");return{type:"keyImport",keyData:l,keyHandle:{algorithm:e.algorithm,extractable:e.extractable||l.extractable,usages:e.usages,type:l.d?"private":"public"}}}if("spki"===e.format){var u={"P-256":32,"P-384":48,"P-521":66}[e.algorithm.namedCurve];if(null==(c=h.parse(e.keyData)))throw new Error("invalid key data.");if(null==(d=(g=c[1]).data.slice(g.header+1))||4!==d.shift()||d.length!==2*u)throw new Error("invalid key data.");if(o=d.slice(0,u),a=d.slice(u),!y.isBytes(o)||!y.isBytes(a))throw new Error("invalid key data.");var l={x:o,y:a};if(!1===m.validatePoint(e.algorithm.namedCurve.toUpperCase(),l.x,l.y))throw new Error("DataError");return{type:"keyImport",keyData:l,keyHandle:{algorithm:e.algorithm,extractable:e.extractable,usages:e.usages,type:"public"}}}if("pkcs8"===e.format){var c;if(u={"P-256":32,"P-384":48,"P-521":66}[e.algorithm.namedCurve],null==(c=h.parse(e.keyData)))throw new Error("invalid key data.");var f=c[2];if(null==(d=h.parse(f.data.slice(f.header))))throw new Error("invalid key data.");var g,d,v=d[1].data.slice(d[1].header);if(null==(d=(g=h.parse(d[2][0].data)).data.slice(g.header+1))||4!==d.shift()||d.length!==2*u)throw new Error("invalid key data.");if(o=d.slice(0,u),a=d.slice(u),!y.isBytes(o)||!y.isBytes(a))throw new Error("invalid key data.");if(l={x:o,y:a,d:v},!1===m.validatePoint(e.algorithm.namedCurve.toUpperCase(),l.x,l.y))throw new Error("DataError");return{type:"keyImport",keyData:l,keyHandle:{algorithm:e.algorithm,extractable:e.extractable,usages:e.usages,type:"private"}}}},se.exportKey=function(e){var r={"P-256":"1.2.840.10045.3.1.7 ","P-384":"1.3.132.0.34","P-521":"1.3.132.0.35"};if("raw"===e.format&&"public"===e.keyHandle.type)return{type:"keyExport",keyHandle:[4].concat(e.keyData.x,e.keyData.y)};if("jwk"===e.format)return{type:"keyExport",keyHandle:p.keyToJwk(e.keyHandle,e.keyData)};if("spki"===e.format)return{type:"keyExport",keyHandle:h.encode({SEQUENCE:[{SEQUENCE:[{"OBJECT IDENTIFIER":"1.2.840.10045.2.1"},{"OBJECT IDENTIFIER":r[e.algorithm.namedCurve]}]},{"BIT STRING":[4].concat(e.keyData.x,e.keyData.y)}]})};if("pkcs8"===e.format)return{type:"keyExport",keyHandle:h.encode({SEQUENCE:[{INTEGER:0},{SEQUENCE:[{"OBJECT IDENTIFIER":"1.2.840.10045.2.1"},{"OBJECT IDENTIFIER":r[e.algorithm.namedCurve]}]},{"OCTET STRING":{SEQUENCE:[{INTEGER:1},{"OCTET STRING":e.keyData.d},{APPLICATION:[{"BIT STRING":[4].concat(e.keyData.x,e.keyData.y)}],tag:1}]}}]})};throw new Error("unsupported export format.")},r.register("sign","ECDSA",se.sign),r.register("verify","ECDSA",se.verify),r.register("generateKey","ECDSA",se.generateKey),r.register("importKey","ECDSA",se.importKey),r.register("exportKey","ECDSA",se.exportKey));var ue=y;ie=function(){function e(){var e;return{postMessage:function(r){try{r.workerid=this.id,e=g.jsCryptoRunner({data:r})}catch(e){return void this.onerror({data:e,type:"error"})}this.onmessage({data:e})},onmessage:null,onerror:null,terminate:function(){}}}var o=function(e){return{process:function(r){return e.process(r)},finish:function(){return e.finish()},abort:function(){return e.abort()}}};function a(e){var r,t,n;return{dispatchEvent:function(o){"error"!==o.type?"process"!==o.data.type&&"finish"!==o.data.type?(this.result=e(o.data),t.apply(r,[this.result])):e(o.data.result,!0):n&&(o.data&&(o.data.stack="Error")&&(o.data.code=0),n.apply(r,[o.data||o]))},promise:r=new Promise(function(e,r){t=e,n=r}),result:null}}function i(e){var r=[],t=a(function(e,t){var n;if(e=e&&(n=e,s&&n.pop?new Uint8Array(n).buffer:n),!t)return e;r.resolve(e)});return t.stream=e.algorithm.stream,r.add=function(e){var t,n,o=new Promise(function(e,r){t=e,n=r});return o.label=e,r.push({resolve:t,reject:n,promise:o}),o},r.resolve=function(e){var t=r.shift();t.resolve.apply(t.promise,[e])},t.process=function(t){return e.operationSubType="process",e.buffer=ue.toArray(t),c.continueJob(this,ue.clone(e)),r.add("process")},t.finish=function(){return e.operationSubType="finish",e.buffer=[],c.continueJob(this,ue.clone(e)),r.add("finish")},t.abort=function(){c.abortJob(this)},t.algorithm=e.algorithm||null,t.key=e.keyHandle||null,t}var u=[];u.add=function(e,r){u.push({keyHandle:e,keyData:r})},u.remove=function(e){for(var r=0;r=0;r-=1)a[r].isWebWorker===e&&(a[r].terminate(),a.splice(r,1))}(!l);for(var e=0;e0){var r,t=i.shift();if(E(t.operation,t.data),"process"===t.data.operationSubType){for(r=0;r=0;r--)t.operation===i[r].operation&&i.splice(r,1)}}else(function(){for(var e=0,r=0;ro&&p(e)}function w(r){var n;if("pending"===h)throw new Error("Creating new worker while workerstatus=pending");if("ready"===h)try{(n=new Worker(t)).postMessage({prngSeed:Z.getBytes(48)}),n.isWebWorker=!0}catch(r){l=!1,h="failed",n.terminate(),(n=e()).isWebWorker=!1}else(n=e()).isWebWorker=!1;return n.operation=r,n.id=u++,n.busy=!1,n.onmessage=function(e){if(!0!==e.data.initialized){var r=n.operation;e.target||(e.target={data:n.data});for(var t=0;t=r)m(e,t);else{if(null===n&&(n=w(e)),null===n)throw m(e,t),new Error("could not create new worker");n.operation=e,n.busy=!0,t.workerid=n.id,b(n,t)}else m(e,t)}function E(e,r){var t=d(e);t?b(t,r):k(e,r)}function b(e,r){if(r.workerid=e.id,l)e.postMessage(r);else{var t=(o=r,function(){return e.postMessage(o)});n=t,c.push(n),f(y,0)}var n,o}return{runJob:k,continueJob:E,abortJob:function(e){var r=d(e);r&&p(r)},useWebWorkers:function(e){if("unavailable"!==h){if(!(!0===e&&"ready"===h||!1===e&&"available"===h)){if(!1===e&&"ready"===h)return l=!1,h="available",void ue.consoleLog("web workers disabled.");if("pending"!==h){h="pending";var r=new Worker(t);r.addEventListener("message",n,!1),r.addEventListener("error",n,!1),r.postMessage({prngSeed:Z.getBytes(48)})}}}else ue.consoleLog("web workers not available in this browser.");function n(e){var t=!(!e.data||!0!==e.data.initialized);if(r.removeEventListener("message",n,!1),r.removeEventListener("error",n,!1),r.terminate(),h=t?"ready":"failed",l=t,ue.consoleLog("web worker initialization "+(t?"succeeded. Now using web workers.":"failed. running synchronously."+(e.message||""))),i.length>0){var o=i.shift();k(o.operation,o.data)}}}}}(),f=[{name:"algorithm",type:"Object",required:!0},{name:"keyHandle",type:"Object",required:!0},{name:"buffer",type:"Array",required:!1},{name:"signature",type:"Array",required:!0},{name:"format",type:"String",required:!0},{name:"keyData",type:"Object",required:!0},{name:"extractable",type:"Boolean",required:!1},{name:"usages",type:"Array",required:!1},{name:"derivedKeyType",type:"Object",required:!0},{name:"length",type:"Number",required:!1},{name:"extractable",type:"Boolean",required:!0},{name:"usages",type:"Array",required:!0},{name:"keyData",type:"Array",required:!0}],h={encrypt:[0,1,2],decrypt:[0,1,2],sign:[0,1,2],verify:[0,1,3,2],digest:[0,2],generateKey:[0,6,7],importKeyRaw:[4,12,0,10,11],importKeyJwk:[4,5,0,10,11],exportKey:[0,4,1,6,7],deriveKey:[0,1,8,6,7],deriveBits:[0,1,9],wrapKey:[1,1,0],unwrapKey:[2,0,1,6,7]};function p(e){var r=u.lookup(e);if(!r)throw new Error("key not found");return r}function d(e,t,n){var s=function(e,r){var t,n,o,a,i={operationType:e};for("importKey"!==e||"raw"!==r[0]&&"spki"!==r[0]&&"pkcs8"!==r[0]||(e="importKeyRaw"),"importKey"===e&&"jwk"===r[0]&&(e="importKeyJwk"),t=h[e],a=0;a=n&&f.stopCollectors()}var c=e&&e.addEventListener||"undefined"!=typeof document&&document.attachEvent,f={startCollectors:function(){if(!this.collectorsRegistered){if(e.addEventListener)e.addEventListener("mousemove",this.MouseEventCallBack,!0),e.addEventListener("load",this.LoadTimeCallBack,!0);else{if(!document.attachEvent)throw new Error("Can't attach events for entropy collection");document.attachEvent("onmousemove",this.MouseEventCallBack),document.attachEvent("onload",this.LoadTimeCallBack)}this.collectorsRegistered=1}},stopCollectors:function(){this.collectorsRegistered&&(e.removeEventListener?(e.removeEventListener("mousemove",this.MouseEventCallBack,1),e.removeEventListener("load",this.LoadTimeCallBack,1)):e.detachEvent&&(e.detachEvent("onmousemove",this.MouseEventCallBack),e.detachEvent("onload",this.LoadTimeCallBack)),this.collectorsRegistered=0)},MouseEventCallBack:function(e){var r=(new Date).valueOf(),t=e.x||e.clientX||e.offsetX||0,n=e.y||e.clientY||e.offsetY||0;l([255&r,r>>8&255,r>>16&255,r>>24&255,255&t,t>>8&255,255&n,n>>8&255])},LoadTimeCallBack:function(){var e=(new Date).valueOf();l([255&e,e>>8&255,e>>16&255,e>>24&255])}};return{init:function(){if(u(),!i&&c)try{f.startCollectors()}catch(e){}},reseed:function(e){o.reseed(e)},read:function(e){if(!a)throw new Error("Entropy pool is not initialized.");var r=o.getBytes(e);return u(),r}}}(e)).init();var ye=ce.read(48);return Z.init(ye),fe}()}),function(e,r){"undefined"==typeof Promise&&(e.Promise=function(){var e=function(r,t){if(!(this instanceof e))throw new Error("use 'new' keyword with Promise constructor");var n=null,o=null,a=[],i=[],s=[],u=[];this.then=function(r,t){var l;return n?(l=r(n.result))&&l.then?l:e.resolve(l):o?(l=t?t(o.result):o.result)&&l.then?l:e.resolve(l):(a.push(r),t&&i.push(t),new e(function(e,r){u.push(e),s.push(r)}))},this["catch"]=function(r){var t;return o?(t=r(o.result))&&t.then?t:e.resolve(t):(i.push(r),new e(function(e,r){u.push(e),s.push(r)}))},r(function(e){var r,t;for(t=0;t=0.10.0" - } - }, - "node_modules/ansi-cyan": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/ansi-cyan/-/ansi-cyan-0.1.1.tgz", - "integrity": "sha1-U4rlKK+JgvKK4w2G8vF0VtJgmHM=", - "dev": true, - "dependencies": { - "ansi-wrap": "0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/ansi-gray": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/ansi-gray/-/ansi-gray-0.1.1.tgz", - "integrity": "sha1-KWLPVOyXksSFEKPetSRDaGHvclE=", - "dev": true, - "dependencies": { - "ansi-wrap": "0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/ansi-red": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/ansi-red/-/ansi-red-0.1.1.tgz", - "integrity": "sha1-jGOPnRCAgAo1PJwoyKgcpHBdlGw=", - "dev": true, - "dependencies": { - "ansi-wrap": "0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/ansi-regex": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", - "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/ansi-wrap": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/ansi-wrap/-/ansi-wrap-0.1.0.tgz", - "integrity": "sha1-qCJQ3bABXponyoLoLqYDu/pF768=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/anymatch": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz", - "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==", - "dev": true, - "dependencies": { - "normalize-path": "^3.0.0", - "picomatch": "^2.0.4" - }, - "engines": { - "node": ">= 8" - } - }, - "node_modules/append-buffer": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/append-buffer/-/append-buffer-1.0.2.tgz", - "integrity": "sha1-2CIM9GYIFSXv6lBhTz3mUU36WPE=", - "dev": true, - "dependencies": { - "buffer-equal": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/archy": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/archy/-/archy-1.0.0.tgz", - "integrity": "sha1-+cjBN1fMHde8N5rHeyxipcKGjEA=", - "dev": true - }, - "node_modules/arr-diff": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz", - "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/arr-filter": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/arr-filter/-/arr-filter-1.1.2.tgz", - "integrity": "sha1-Q/3d0JHo7xGqTEXZzcGOLf8XEe4=", - "dev": true, - "dependencies": { - "make-iterator": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/arr-flatten": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz", - "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/arr-map": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/arr-map/-/arr-map-2.0.2.tgz", - "integrity": "sha1-Onc0X/wc814qkYJWAfnljy4kysQ=", - "dev": true, - "dependencies": { - "make-iterator": "^1.0.0" + "esbuild": "^0.28.0" }, "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/arr-union": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-2.1.0.tgz", - "integrity": "sha1-IPnqtexw9cfSFbEHexw5Fh0pLH0=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/array-each": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/array-each/-/array-each-1.0.1.tgz", - "integrity": "sha1-p5SvDAWrF1KEbudTofIRoFugxE8=", - "dev": true, - "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/array-initial": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/array-initial/-/array-initial-1.1.0.tgz", - "integrity": "sha1-L6dLJnOTccOUe9enrcc74zSz15U=", + "node_modules/@esbuild/aix-ppc64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz", + "integrity": "sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==", + "cpu": [ + "ppc64" + ], "dev": true, - "dependencies": { - "array-slice": "^1.0.0", - "is-number": "^4.0.0" - }, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/array-initial/node_modules/is-number": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz", - "integrity": "sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==", + "node_modules/@esbuild/android-arm": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.1.tgz", + "integrity": "sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==", + "cpu": [ + "arm" + ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/array-last": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/array-last/-/array-last-1.3.0.tgz", - "integrity": "sha512-eOCut5rXlI6aCOS7Z7kCplKRKyiFQ6dHFBem4PwlwKeNFk2/XxTrhRh5T9PyaEWGy/NHTZWbY+nsZlNFJu9rYg==", + "node_modules/@esbuild/android-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.1.tgz", + "integrity": "sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==", + "cpu": [ + "arm64" + ], "dev": true, - "dependencies": { - "is-number": "^4.0.0" - }, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/array-last/node_modules/is-number": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz", - "integrity": "sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==", + "node_modules/@esbuild/android-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.1.tgz", + "integrity": "sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==", + "cpu": [ + "x64" + ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/array-slice": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/array-slice/-/array-slice-1.1.0.tgz", - "integrity": "sha512-B1qMD3RBP7O8o0H2KbrXDyB0IccejMF15+87Lvlor12ONPRHP6gTjXMNkt/d3ZuOGbAe66hFmaCfECI24Ufp6w==", + "node_modules/@esbuild/darwin-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.1.tgz", + "integrity": "sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==", + "cpu": [ + "arm64" + ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/array-sort": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/array-sort/-/array-sort-1.0.0.tgz", - "integrity": "sha512-ihLeJkonmdiAsD7vpgN3CRcx2J2S0TiYW+IS/5zHBI7mKUq3ySvBdzzBfD236ubDBQFiiyG3SWCPc+msQ9KoYg==", + "node_modules/@esbuild/darwin-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.1.tgz", + "integrity": "sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==", + "cpu": [ + "x64" + ], "dev": true, - "dependencies": { - "default-compare": "^1.0.0", - "get-value": "^2.0.6", - "kind-of": "^5.0.2" - }, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/array-unique": { - "version": "0.3.2", - "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz", - "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=", + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.1.tgz", + "integrity": "sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==", + "cpu": [ + "arm64" + ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/assign-symbols": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz", - "integrity": "sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=", + "node_modules/@esbuild/freebsd-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.1.tgz", + "integrity": "sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==", + "cpu": [ + "x64" + ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/async-done": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/async-done/-/async-done-1.3.2.tgz", - "integrity": "sha512-uYkTP8dw2og1tu1nmza1n1CMW0qb8gWWlwqMmLb7MhBVs4BXrFziT6HXUd+/RlRA/i4H9AkofYloUbs1fwMqlw==", + "node_modules/@esbuild/linux-arm": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.1.tgz", + "integrity": "sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==", + "cpu": [ + "arm" + ], "dev": true, - "dependencies": { - "end-of-stream": "^1.1.0", - "once": "^1.3.2", - "process-nextick-args": "^2.0.0", - "stream-exhaust": "^1.0.1" - }, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], "engines": { - "node": ">= 0.10" + "node": ">=18" } }, - "node_modules/async-each": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/async-each/-/async-each-1.0.3.tgz", - "integrity": "sha512-z/WhQ5FPySLdvREByI2vZiTWwCnF0moMJ1hK9YQwDTHKh6I7/uSckMetoRGb5UBZPC1z0jlw+n/XCgjeH7y1AQ==", - "dev": true - }, - "node_modules/async-settle": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/async-settle/-/async-settle-1.0.0.tgz", - "integrity": "sha1-HQqRS7Aldb7IqPOnTlCA9yssDGs=", + "node_modules/@esbuild/linux-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.1.tgz", + "integrity": "sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==", + "cpu": [ + "arm64" + ], "dev": true, - "dependencies": { - "async-done": "^1.2.2" - }, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], "engines": { - "node": ">= 0.10" + "node": ">=18" } }, - "node_modules/atob": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz", - "integrity": "sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==", + "node_modules/@esbuild/linux-ia32": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.1.tgz", + "integrity": "sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==", + "cpu": [ + "ia32" + ], "dev": true, - "bin": { - "atob": "bin/atob.js" - }, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], "engines": { - "node": ">= 4.5.0" + "node": ">=18" } }, - "node_modules/bach": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/bach/-/bach-1.2.0.tgz", - "integrity": "sha1-Szzpa/JxNPeaG0FKUcFONMO9mIA=", + "node_modules/@esbuild/linux-loong64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.1.tgz", + "integrity": "sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==", + "cpu": [ + "loong64" + ], "dev": true, - "dependencies": { - "arr-filter": "^1.1.1", - "arr-flatten": "^1.0.1", - "arr-map": "^2.0.0", - "array-each": "^1.0.0", - "array-initial": "^1.0.0", - "array-last": "^1.1.1", - "async-done": "^1.2.2", - "async-settle": "^1.0.0", - "now-and-later": "^2.0.0" - }, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], "engines": { - "node": ">= 0.10" + "node": ">=18" } }, - "node_modules/balanced-match": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", - "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", - "dev": true - }, - "node_modules/base": { - "version": "0.11.2", - "resolved": "https://registry.npmjs.org/base/-/base-0.11.2.tgz", - "integrity": "sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==", + "node_modules/@esbuild/linux-mips64el": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.1.tgz", + "integrity": "sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==", + "cpu": [ + "mips64el" + ], "dev": true, - "dependencies": { - "cache-base": "^1.0.1", - "class-utils": "^0.3.5", - "component-emitter": "^1.2.1", - "define-property": "^1.0.0", - "isobject": "^3.0.1", - "mixin-deep": "^1.2.0", - "pascalcase": "^0.1.1" - }, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/base/node_modules/define-property": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", - "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", + "node_modules/@esbuild/linux-ppc64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.1.tgz", + "integrity": "sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==", + "cpu": [ + "ppc64" + ], "dev": true, - "dependencies": { - "is-descriptor": "^1.0.0" - }, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/binary-extensions": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", - "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", + "node_modules/@esbuild/linux-riscv64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.1.tgz", + "integrity": "sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==", + "cpu": [ + "riscv64" + ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], "engines": { - "node": ">=8" + "node": ">=18" } }, - "node_modules/bindings": { - "version": "1.5.0", - "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz", - "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==", + "node_modules/@esbuild/linux-s390x": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.1.tgz", + "integrity": "sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==", + "cpu": [ + "s390x" + ], "dev": true, + "license": "MIT", "optional": true, - "dependencies": { - "file-uri-to-path": "1.0.0" - } - }, - "node_modules/brace-expansion": { - "version": "1.1.11", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", - "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", - "dev": true, - "dependencies": { - "balanced-match": "^1.0.0", - "concat-map": "0.0.1" - } - }, - "node_modules/braces": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", - "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", - "dev": true, - "dependencies": { - "fill-range": "^7.0.1" - }, + "os": [ + "linux" + ], "engines": { - "node": ">=8" + "node": ">=18" } }, - "node_modules/buffer-equal": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/buffer-equal/-/buffer-equal-1.0.0.tgz", - "integrity": "sha1-WWFrSYME1Var1GaWayLu2j7KX74=", + "node_modules/@esbuild/linux-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz", + "integrity": "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==", + "cpu": [ + "x64" + ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], "engines": { - "node": ">=0.4.0" + "node": ">=18" } }, - "node_modules/buffer-from": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", - "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", - "dev": true - }, - "node_modules/cache-base": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz", - "integrity": "sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==", + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.1.tgz", + "integrity": "sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==", + "cpu": [ + "arm64" + ], "dev": true, - "dependencies": { - "collection-visit": "^1.0.0", - "component-emitter": "^1.2.1", - "get-value": "^2.0.6", - "has-value": "^1.0.0", - "isobject": "^3.0.1", - "set-value": "^2.0.0", - "to-object-path": "^0.3.0", - "union-value": "^1.0.0", - "unset-value": "^1.0.0" - }, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/cache-base/node_modules/extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==", + "node_modules/@esbuild/netbsd-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.1.tgz", + "integrity": "sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==", + "cpu": [ + "x64" + ], "dev": true, - "dependencies": { - "is-extendable": "^0.1.0" - }, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/cache-base/node_modules/is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==", + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.1.tgz", + "integrity": "sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==", + "cpu": [ + "arm64" + ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/cache-base/node_modules/is-plain-object": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", - "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", + "node_modules/@esbuild/openbsd-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.1.tgz", + "integrity": "sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==", + "cpu": [ + "x64" + ], "dev": true, - "dependencies": { - "isobject": "^3.0.1" - }, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/cache-base/node_modules/set-value": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz", - "integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==", + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.1.tgz", + "integrity": "sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==", + "cpu": [ + "arm64" + ], "dev": true, - "dependencies": { - "extend-shallow": "^2.0.1", - "is-extendable": "^0.1.1", - "is-plain-object": "^2.0.3", - "split-string": "^3.0.1" - }, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/call-bind": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", - "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", - "dev": true, - "dependencies": { - "function-bind": "^1.1.1", - "get-intrinsic": "^1.0.2" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/camelcase": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-3.0.0.tgz", - "integrity": "sha1-MvxLn82vhF/N9+c7uXysImHwqwo=", + "node_modules/@esbuild/sunos-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.1.tgz", + "integrity": "sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==", + "cpu": [ + "x64" + ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/chokidar": { - "version": "3.5.3", - "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", - "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", + "node_modules/@esbuild/win32-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.1.tgz", + "integrity": "sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==", + "cpu": [ + "arm64" + ], "dev": true, - "funding": [ - { - "type": "individual", - "url": "https://paulmillr.com/funding/" - } + "license": "MIT", + "optional": true, + "os": [ + "win32" ], - "dependencies": { - "anymatch": "~3.1.2", - "braces": "~3.0.2", - "glob-parent": "~5.1.2", - "is-binary-path": "~2.1.0", - "is-glob": "~4.0.1", - "normalize-path": "~3.0.0", - "readdirp": "~3.6.0" - }, "engines": { - "node": ">= 8.10.0" - }, - "optionalDependencies": { - "fsevents": "~2.3.2" + "node": ">=18" } }, - "node_modules/class-utils": { - "version": "0.3.6", - "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz", - "integrity": "sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==", + "node_modules/@esbuild/win32-ia32": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.1.tgz", + "integrity": "sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==", + "cpu": [ + "ia32" + ], "dev": true, - "dependencies": { - "arr-union": "^3.1.0", - "define-property": "^0.2.5", - "isobject": "^3.0.0", - "static-extend": "^0.1.1" - }, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/class-utils/node_modules/arr-union": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz", - "integrity": "sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=", + "node_modules/@esbuild/win32-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.1.tgz", + "integrity": "sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==", + "cpu": [ + "x64" + ], "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], "engines": { - "node": ">=0.10.0" + "node": ">=18" } }, - "node_modules/class-utils/node_modules/define-property": { - "version": "0.2.5", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", + "node_modules/esbuild": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz", + "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==", "dev": true, - "dependencies": { - "is-descriptor": "^0.1.0" + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" }, "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/cliui": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/cliui/-/cliui-3.2.0.tgz", - "integrity": "sha1-EgYBU3qRbSmUD5NNo7SNWFo5IT0=", - "dev": true, - "dependencies": { - "string-width": "^1.0.1", - "strip-ansi": "^3.0.1", - "wrap-ansi": "^2.0.0" - } - }, - "node_modules/clone": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/clone/-/clone-2.1.2.tgz", - "integrity": "sha1-G39Ln1kfHo+DZwQBYANFoCiHQ18=", - "dev": true, - "engines": { - "node": ">=0.8" - } - }, - "node_modules/clone-buffer": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/clone-buffer/-/clone-buffer-1.0.0.tgz", - "integrity": "sha1-4+JbIHrE5wGvch4staFnksrD3Fg=", - "dev": true, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/clone-stats": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/clone-stats/-/clone-stats-1.0.0.tgz", - "integrity": "sha1-s3gt/4u1R04Yuba/D9/ngvh3doA=", - "dev": true - }, - "node_modules/cloneable-readable": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/cloneable-readable/-/cloneable-readable-1.1.3.tgz", - "integrity": "sha512-2EF8zTQOxYq70Y4XKtorQupqF0m49MBz2/yf5Bj+MHjvpG3Hy7sImifnqD6UA+TKYxeSV+u6qqQPawN5UvnpKQ==", - "dev": true, - "dependencies": { - "inherits": "^2.0.1", - "process-nextick-args": "^2.0.0", - "readable-stream": "^2.3.5" - } - }, - "node_modules/code-point-at": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz", - "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/collection-map": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/collection-map/-/collection-map-1.0.0.tgz", - "integrity": "sha1-rqDwb40mx4DCt1SUOFVEsiVa8Yw=", - "dev": true, - "dependencies": { - "arr-map": "^2.0.2", - "for-own": "^1.0.0", - "make-iterator": "^1.0.0" + "node": ">=18" }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/collection-visit": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz", - "integrity": "sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=", - "dev": true, - "dependencies": { - "map-visit": "^1.0.0", - "object-visit": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/color-support": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz", - "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==", - "dev": true, - "bin": { - "color-support": "bin.js" - } - }, - "node_modules/commander": { - "version": "2.20.3", - "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", - "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", - "dev": true - }, - "node_modules/component-emitter": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz", - "integrity": "sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==", - "dev": true - }, - "node_modules/concat-map": { - "version": "0.0.1", - "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", - "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=", - "dev": true - }, - "node_modules/concat-stream": { - "version": "1.6.2", - "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", - "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", - "dev": true, - "engines": [ - "node >= 0.8" - ], - "dependencies": { - "buffer-from": "^1.0.0", - "inherits": "^2.0.3", - "readable-stream": "^2.2.2", - "typedarray": "^0.0.6" - } - }, - "node_modules/concat-with-sourcemaps": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/concat-with-sourcemaps/-/concat-with-sourcemaps-1.1.0.tgz", - "integrity": "sha512-4gEjHJFT9e+2W/77h/DS5SGUgwDaOwprX8L/gl5+3ixnzkVJJsZWDSelmN3Oilw3LNDZjZV0yqH1hLG3k6nghg==", - "dev": true, - "dependencies": { - "source-map": "^0.6.1" - } - }, - "node_modules/config-chain": { - "version": "1.1.13", - "resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.13.tgz", - "integrity": "sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==", - "dev": true, - "dependencies": { - "ini": "^1.3.4", - "proto-list": "~1.2.1" - } - }, - "node_modules/convert-source-map": { - "version": "1.8.0", - "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.8.0.tgz", - "integrity": "sha512-+OQdjP49zViI/6i7nIJpA8rAl4sV/JdPfU9nZs3VqOwGIgizICvuN2ru6fMd+4llL0tar18UYJXfZ/TWtmhUjA==", - "dev": true, - "dependencies": { - "safe-buffer": "~5.1.1" - } - }, - "node_modules/copy-descriptor": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz", - "integrity": "sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/copy-props": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/copy-props/-/copy-props-2.0.5.tgz", - "integrity": "sha512-XBlx8HSqrT0ObQwmSzM7WE5k8FxTV75h1DX1Z3n6NhQ/UYYAvInWYmG06vFt7hQZArE2fuO62aihiWIVQwh1sw==", - "dev": true, - "dependencies": { - "each-props": "^1.3.2", - "is-plain-object": "^5.0.0" - } - }, - "node_modules/core-util-is": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz", - "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==", - "dev": true - }, - "node_modules/d": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/d/-/d-1.0.1.tgz", - "integrity": "sha512-m62ShEObQ39CfralilEQRjH6oAMtNCV1xJyEx5LpRYUVN+EviphDgUc/F3hnYbADmkiNs67Y+3ylmlG7Lnu+FA==", - "dev": true, - "dependencies": { - "es5-ext": "^0.10.50", - "type": "^1.0.1" - } - }, - "node_modules/debug": { - "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", - "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", - "dev": true, - "dependencies": { - "ms": "2.0.0" - } - }, - "node_modules/decamelize": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", - "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/decode-uri-component": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.2.tgz", - "integrity": "sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==", - "dev": true, - "engines": { - "node": ">=0.10" - } - }, - "node_modules/decomment": { - "version": "0.9.5", - "resolved": "https://registry.npmjs.org/decomment/-/decomment-0.9.5.tgz", - "integrity": "sha512-h0TZ8t6Dp49duwyDHo3iw67mnh9/UpFiSSiOb5gDK1sqoXzrfX/SQxIUQd2R2QEiSnqib0KF2fnKnGfAhAs6lg==", - "dev": true, - "dependencies": { - "esprima": "4.0.1" - }, - "engines": { - "node": ">=6.4", - "npm": ">=2.15" - } - }, - "node_modules/default-compare": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/default-compare/-/default-compare-1.0.0.tgz", - "integrity": "sha512-QWfXlM0EkAbqOCbD/6HjdwT19j7WCkMyiRhWilc4H9/5h/RzTF9gv5LYh1+CmDV5d1rki6KAWLtQale0xt20eQ==", - "dev": true, - "dependencies": { - "kind-of": "^5.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/default-resolution": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/default-resolution/-/default-resolution-2.0.0.tgz", - "integrity": "sha1-vLgrqnKtebQmp2cy8aga1t8m1oQ=", - "dev": true, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/define-properties": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.4.tgz", - "integrity": "sha512-uckOqKcfaVvtBdsVkdPv3XjveQJsNQqmhXgRi8uhvWWuPYZCNlzT8qAyblUgNoXdHdjMTzAqeGjAoli8f+bzPA==", - "dev": true, - "dependencies": { - "has-property-descriptors": "^1.0.0", - "object-keys": "^1.1.1" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/define-property": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz", - "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", - "dev": true, - "dependencies": { - "is-descriptor": "^1.0.2", - "isobject": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/detect-file": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/detect-file/-/detect-file-1.0.0.tgz", - "integrity": "sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/duplexer": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz", - "integrity": "sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==", - "dev": true - }, - "node_modules/duplexify": { - "version": "3.7.1", - "resolved": "https://registry.npmjs.org/duplexify/-/duplexify-3.7.1.tgz", - "integrity": "sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==", - "dev": true, - "dependencies": { - "end-of-stream": "^1.0.0", - "inherits": "^2.0.1", - "readable-stream": "^2.0.0", - "stream-shift": "^1.0.0" - } - }, - "node_modules/each-props": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/each-props/-/each-props-1.3.2.tgz", - "integrity": "sha512-vV0Hem3zAGkJAyU7JSjixeU66rwdynTAa1vofCrSA5fEln+m67Az9CcnkVD776/fsN/UjIWmBDoNRS6t6G9RfA==", - "dev": true, - "dependencies": { - "is-plain-object": "^2.0.1", - "object.defaults": "^1.1.0" - } - }, - "node_modules/each-props/node_modules/is-plain-object": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", - "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", - "dev": true, - "dependencies": { - "isobject": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/editorconfig": { - "version": "0.15.3", - "resolved": "https://registry.npmjs.org/editorconfig/-/editorconfig-0.15.3.tgz", - "integrity": "sha512-M9wIMFx96vq0R4F+gRpY3o2exzb8hEj/n9S8unZtHSvYjibBp/iMufSzvmOcV/laG0ZtuTVGtiJggPOSW2r93g==", - "dev": true, - "dependencies": { - "commander": "^2.19.0", - "lru-cache": "^4.1.5", - "semver": "^5.6.0", - "sigmund": "^1.0.1" - }, - "bin": { - "editorconfig": "bin/editorconfig" - } - }, - "node_modules/end-of-stream": { - "version": "1.4.4", - "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz", - "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==", - "dev": true, - "dependencies": { - "once": "^1.4.0" - } - }, - "node_modules/error-ex": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", - "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", - "dev": true, - "dependencies": { - "is-arrayish": "^0.2.1" - } - }, - "node_modules/es5-ext": { - "version": "0.10.61", - "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.61.tgz", - "integrity": "sha512-yFhIqQAzu2Ca2I4SE2Au3rxVfmohU9Y7wqGR+s7+H7krk26NXhIRAZDgqd6xqjCEFUomDEA3/Bo/7fKmIkW1kA==", - "dev": true, - "hasInstallScript": true, - "dependencies": { - "es6-iterator": "^2.0.3", - "es6-symbol": "^3.1.3", - "next-tick": "^1.1.0" - }, - "engines": { - "node": ">=0.10" - } - }, - "node_modules/es6-iterator": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz", - "integrity": "sha1-p96IkUGgWpSwhUQDstCg+/qY87c=", - "dev": true, - "dependencies": { - "d": "1", - "es5-ext": "^0.10.35", - "es6-symbol": "^3.1.1" - } - }, - "node_modules/es6-symbol": { - "version": "3.1.3", - "resolved": "https://registry.npmjs.org/es6-symbol/-/es6-symbol-3.1.3.tgz", - "integrity": "sha512-NJ6Yn3FuDinBaBRWl/q5X/s4koRHBrgKAu+yGI6JCBeiu3qrcbJhwT2GeR/EXVfylRk8dpQVJoLEFhK+Mu31NA==", - "dev": true, - "dependencies": { - "d": "^1.0.1", - "ext": "^1.1.2" - } - }, - "node_modules/es6-weak-map": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/es6-weak-map/-/es6-weak-map-2.0.3.tgz", - "integrity": "sha512-p5um32HOTO1kP+w7PRnB+5lQ43Z6muuMuIMffvDN8ZB4GcnjLBV6zGStpbASIMk4DCAvEaamhe2zhyCb/QXXsA==", - "dev": true, - "dependencies": { - "d": "1", - "es5-ext": "^0.10.46", - "es6-iterator": "^2.0.3", - "es6-symbol": "^3.1.1" - } - }, - "node_modules/esprima": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", - "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", - "dev": true, - "bin": { - "esparse": "bin/esparse.js", - "esvalidate": "bin/esvalidate.js" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/event-stream": { - "version": "3.3.5", - "resolved": "https://registry.npmjs.org/event-stream/-/event-stream-3.3.5.tgz", - "integrity": "sha512-vyibDcu5JL20Me1fP734QBH/kenBGLZap2n0+XXM7mvuUPzJ20Ydqj1aKcIeMdri1p+PU+4yAKugjN8KCVst+g==", - "dev": true, - "dependencies": { - "duplexer": "^0.1.1", - "from": "^0.1.7", - "map-stream": "0.0.7", - "pause-stream": "^0.0.11", - "split": "^1.0.1", - "stream-combiner": "^0.2.2", - "through": "^2.3.8" - } - }, - "node_modules/expand-brackets": { - "version": "2.1.4", - "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz", - "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=", - "dev": true, - "dependencies": { - "debug": "^2.3.3", - "define-property": "^0.2.5", - "extend-shallow": "^2.0.1", - "posix-character-classes": "^0.1.0", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/expand-brackets/node_modules/define-property": { - "version": "0.2.5", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "dependencies": { - "is-descriptor": "^0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/expand-brackets/node_modules/extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "dependencies": { - "is-extendable": "^0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/expand-brackets/node_modules/is-accessor-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", - "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", - "dev": true, - "dependencies": { - "kind-of": "^3.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/expand-brackets/node_modules/is-accessor-descriptor/node_modules/kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "dependencies": { - "is-buffer": "^1.1.5" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/expand-brackets/node_modules/is-data-descriptor": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", - "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", - "dev": true, - "dependencies": { - "kind-of": "^3.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/expand-brackets/node_modules/is-data-descriptor/node_modules/kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "dependencies": { - "is-buffer": "^1.1.5" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/expand-brackets/node_modules/is-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", - "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", - "dev": true, - "dependencies": { - "is-accessor-descriptor": "^0.1.6", - "is-data-descriptor": "^0.1.4", - "kind-of": "^5.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/expand-brackets/node_modules/is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/expand-tilde": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/expand-tilde/-/expand-tilde-2.0.2.tgz", - "integrity": "sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=", - "dev": true, - "dependencies": { - "homedir-polyfill": "^1.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/ext": { - "version": "1.6.0", - "resolved": "https://registry.npmjs.org/ext/-/ext-1.6.0.tgz", - "integrity": "sha512-sdBImtzkq2HpkdRLtlLWDa6w4DX22ijZLKx8BMPUuKe1c5lbN6xwQDQCxSfxBQnHZ13ls/FH0MQZx/q/gr6FQg==", - "dev": true, - "dependencies": { - "type": "^2.5.0" - } - }, - "node_modules/ext/node_modules/type": { - "version": "2.6.0", - "resolved": "https://registry.npmjs.org/type/-/type-2.6.0.tgz", - "integrity": "sha512-eiDBDOmkih5pMbo9OqsqPRGMljLodLcwd5XD5JbtNB0o89xZAwynY9EdCDsJU7LtcVCClu9DvM7/0Ep1hYX3EQ==", - "dev": true - }, - "node_modules/extend": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", - "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", - "dev": true - }, - "node_modules/extend-shallow": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", - "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=", - "dev": true, - "dependencies": { - "assign-symbols": "^1.0.0", - "is-extendable": "^1.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/extglob": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz", - "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==", - "dev": true, - "dependencies": { - "array-unique": "^0.3.2", - "define-property": "^1.0.0", - "expand-brackets": "^2.1.4", - "extend-shallow": "^2.0.1", - "fragment-cache": "^0.2.1", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/extglob/node_modules/define-property": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", - "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", - "dev": true, - "dependencies": { - "is-descriptor": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/extglob/node_modules/extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "dependencies": { - "is-extendable": "^0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/extglob/node_modules/is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/fancy-log": { - "version": "1.3.3", - "resolved": "https://registry.npmjs.org/fancy-log/-/fancy-log-1.3.3.tgz", - "integrity": "sha512-k9oEhlyc0FrVh25qYuSELjr8oxsCoc4/LEZfg2iJJrfEk/tZL9bCoJE47gqAvI2m/AUjluCS4+3I0eTx8n3AEw==", - "dev": true, - "dependencies": { - "ansi-gray": "^0.1.1", - "color-support": "^1.1.3", - "parse-node-version": "^1.0.0", - "time-stamp": "^1.0.0" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/fast-levenshtein": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-1.1.4.tgz", - "integrity": "sha1-5qdUzI8V5YmHqpy9J69m/W9OWvk=", - "dev": true - }, - "node_modules/file-uri-to-path": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz", - "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==", - "dev": true, - "optional": true - }, - "node_modules/fill-range": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", - "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", - "dev": true, - "dependencies": { - "to-regex-range": "^5.0.1" - }, - "engines": { - "node": ">=8" - } - }, - "node_modules/find-up": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz", - "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", - "dev": true, - "dependencies": { - "path-exists": "^2.0.0", - "pinkie-promise": "^2.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/findup-sync": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-3.0.0.tgz", - "integrity": "sha512-YbffarhcicEhOrm4CtrwdKBdCuz576RLdhJDsIfvNtxUuhdRet1qZcsMjqbePtAseKdAnDyM/IyXbu7PRPRLYg==", - "dev": true, - "dependencies": { - "detect-file": "^1.0.0", - "is-glob": "^4.0.0", - "micromatch": "^3.0.4", - "resolve-dir": "^1.0.1" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/fined": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/fined/-/fined-1.2.0.tgz", - "integrity": "sha512-ZYDqPLGxDkDhDZBjZBb+oD1+j0rA4E0pXY50eplAAOPg2N/gUBSSk5IM1/QhPfyVo19lJ+CvXpqfvk+b2p/8Ng==", - "dev": true, - "dependencies": { - "expand-tilde": "^2.0.2", - "is-plain-object": "^2.0.3", - "object.defaults": "^1.1.0", - "object.pick": "^1.2.0", - "parse-filepath": "^1.0.1" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/fined/node_modules/is-plain-object": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", - "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", - "dev": true, - "dependencies": { - "isobject": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/flagged-respawn": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/flagged-respawn/-/flagged-respawn-1.0.1.tgz", - "integrity": "sha512-lNaHNVymajmk0OJMBn8fVUAU1BtDeKIqKoVhk4xAALB57aALg6b4W0MfJ/cUE0g9YBXy5XhSlPIpYIJ7HaY/3Q==", - "dev": true, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/flush-write-stream": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/flush-write-stream/-/flush-write-stream-1.1.1.tgz", - "integrity": "sha512-3Z4XhFZ3992uIq0XOqb9AreonueSYphE6oYbpt5+3u06JWklbsPkNv3ZKkP9Bz/r+1MWCaMoSQ28P85+1Yc77w==", - "dev": true, - "dependencies": { - "inherits": "^2.0.3", - "readable-stream": "^2.3.6" - } - }, - "node_modules/for-in": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz", - "integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/for-own": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/for-own/-/for-own-1.0.0.tgz", - "integrity": "sha1-xjMy9BXO3EsE2/5wz4NklMU8tEs=", - "dev": true, - "dependencies": { - "for-in": "^1.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/fragment-cache": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz", - "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=", - "dev": true, - "dependencies": { - "map-cache": "^0.2.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/from": { - "version": "0.1.7", - "resolved": "https://registry.npmjs.org/from/-/from-0.1.7.tgz", - "integrity": "sha1-g8YK/Fi5xWmXAH7Rp2izqzA6RP4=", - "dev": true - }, - "node_modules/fs-mkdirp-stream": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/fs-mkdirp-stream/-/fs-mkdirp-stream-1.0.0.tgz", - "integrity": "sha1-C3gV/DIBxqaeFNuYzgmMFpNSWes=", - "dev": true, - "dependencies": { - "graceful-fs": "^4.1.11", - "through2": "^2.0.3" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/fs.realpath": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", - "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=", - "dev": true - }, - "node_modules/fsevents": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", - "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", - "dev": true, - "hasInstallScript": true, - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" - } - }, - "node_modules/function-bind": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", - "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", - "dev": true - }, - "node_modules/get-caller-file": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-1.0.3.tgz", - "integrity": "sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==", - "dev": true - }, - "node_modules/get-intrinsic": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz", - "integrity": "sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==", - "dev": true, - "dependencies": { - "function-bind": "^1.1.1", - "has": "^1.0.3", - "has-symbols": "^1.0.1" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/get-value": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz", - "integrity": "sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/glob": { - "version": "7.2.0", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz", - "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==", - "dev": true, - "dependencies": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" - }, - "engines": { - "node": "*" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "node_modules/glob-parent": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", - "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", - "dev": true, - "dependencies": { - "is-glob": "^4.0.1" - }, - "engines": { - "node": ">= 6" - } - }, - "node_modules/glob-stream": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/glob-stream/-/glob-stream-6.1.0.tgz", - "integrity": "sha1-cEXJlBOz65SIjYOrRtC0BMx73eQ=", - "dev": true, - "dependencies": { - "extend": "^3.0.0", - "glob": "^7.1.1", - "glob-parent": "^3.1.0", - "is-negated-glob": "^1.0.0", - "ordered-read-streams": "^1.0.0", - "pumpify": "^1.3.5", - "readable-stream": "^2.1.5", - "remove-trailing-separator": "^1.0.1", - "to-absolute-glob": "^2.0.0", - "unique-stream": "^2.0.2" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/glob-stream/node_modules/glob-parent": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-3.1.0.tgz", - "integrity": "sha512-E8Ak/2+dZY6fnzlR7+ueWvhsH1SjHr4jjss4YS/h4py44jY9MhK/VFdaZJAWDz6BbL21KeteKxFSFpq8OS5gVA==", - "dev": true, - "dependencies": { - "is-glob": "^3.1.0", - "path-dirname": "^1.0.0" - } - }, - "node_modules/glob-stream/node_modules/is-glob": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz", - "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=", - "dev": true, - "dependencies": { - "is-extglob": "^2.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/glob-watcher": { - "version": "5.0.5", - "resolved": "https://registry.npmjs.org/glob-watcher/-/glob-watcher-5.0.5.tgz", - "integrity": "sha512-zOZgGGEHPklZNjZQaZ9f41i7F2YwE+tS5ZHrDhbBCk3stwahn5vQxnFmBJZHoYdusR6R1bLSXeGUy/BhctwKzw==", - "dev": true, - "dependencies": { - "anymatch": "^2.0.0", - "async-done": "^1.2.0", - "chokidar": "^2.0.0", - "is-negated-glob": "^1.0.0", - "just-debounce": "^1.0.0", - "normalize-path": "^3.0.0", - "object.defaults": "^1.1.0" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/glob-watcher/node_modules/anymatch": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz", - "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==", - "dev": true, - "dependencies": { - "micromatch": "^3.1.4", - "normalize-path": "^2.1.1" - } - }, - "node_modules/glob-watcher/node_modules/anymatch/node_modules/normalize-path": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", - "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", - "dev": true, - "dependencies": { - "remove-trailing-separator": "^1.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/glob-watcher/node_modules/binary-extensions": { - "version": "1.13.1", - "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.13.1.tgz", - "integrity": "sha512-Un7MIEDdUC5gNpcGDV97op1Ywk748MpHcFTHoYs6qnj1Z3j7I53VG3nwZhKzoBZmbdRNnb6WRdFlwl7tSDuZGw==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/glob-watcher/node_modules/braces": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz", - "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", - "dev": true, - "dependencies": { - "arr-flatten": "^1.1.0", - "array-unique": "^0.3.2", - "extend-shallow": "^2.0.1", - "fill-range": "^4.0.0", - "isobject": "^3.0.1", - "repeat-element": "^1.1.2", - "snapdragon": "^0.8.1", - "snapdragon-node": "^2.0.1", - "split-string": "^3.0.2", - "to-regex": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/glob-watcher/node_modules/chokidar": { - "version": "2.1.8", - "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-2.1.8.tgz", - "integrity": "sha512-ZmZUazfOzf0Nve7duiCKD23PFSCs4JPoYyccjUFF3aQkQadqBhfzhjkwBH2mNOG9cTBwhamM37EIsIkZw3nRgg==", - "deprecated": "Chokidar 2 does not receive security updates since 2019. Upgrade to chokidar 3 with 15x fewer dependencies", - "dev": true, - "dependencies": { - "anymatch": "^2.0.0", - "async-each": "^1.0.1", - "braces": "^2.3.2", - "glob-parent": "^3.1.0", - "inherits": "^2.0.3", - "is-binary-path": "^1.0.0", - "is-glob": "^4.0.0", - "normalize-path": "^3.0.0", - "path-is-absolute": "^1.0.0", - "readdirp": "^2.2.1", - "upath": "^1.1.1" - }, - "optionalDependencies": { - "fsevents": "^1.2.7" - } - }, - "node_modules/glob-watcher/node_modules/chokidar/node_modules/glob-parent": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-3.1.0.tgz", - "integrity": "sha512-E8Ak/2+dZY6fnzlR7+ueWvhsH1SjHr4jjss4YS/h4py44jY9MhK/VFdaZJAWDz6BbL21KeteKxFSFpq8OS5gVA==", - "dev": true, - "dependencies": { - "is-glob": "^3.1.0", - "path-dirname": "^1.0.0" - } - }, - "node_modules/glob-watcher/node_modules/chokidar/node_modules/glob-parent/node_modules/is-glob": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz", - "integrity": "sha512-UFpDDrPgM6qpnFNI+rh/p3bUaq9hKLZN8bMUWzxmcnZVS3omf4IPK+BrewlnWjO1WmUsMYuSjKh4UJuV4+Lqmw==", - "dev": true, - "dependencies": { - "is-extglob": "^2.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/glob-watcher/node_modules/extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "dependencies": { - "is-extendable": "^0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/glob-watcher/node_modules/fill-range": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz", - "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", - "dev": true, - "dependencies": { - "extend-shallow": "^2.0.1", - "is-number": "^3.0.0", - "repeat-string": "^1.6.1", - "to-regex-range": "^2.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/glob-watcher/node_modules/fsevents": { - "version": "1.2.13", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.2.13.tgz", - "integrity": "sha512-oWb1Z6mkHIskLzEJ/XWX0srkpkTQ7vaopMQkyaEIoq0fmtFVxOthb8cCxeT+p3ynTdkk/RZwbgG4brR5BeWECw==", - "deprecated": "fsevents 1 will break on node v14+ and could be using insecure binaries. Upgrade to fsevents 2.", - "dev": true, - "hasInstallScript": true, - "optional": true, - "os": [ - "darwin" - ], - "dependencies": { - "bindings": "^1.5.0", - "nan": "^2.12.1" - }, - "engines": { - "node": ">= 4.0" - } - }, - "node_modules/glob-watcher/node_modules/is-binary-path": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz", - "integrity": "sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=", - "dev": true, - "dependencies": { - "binary-extensions": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/glob-watcher/node_modules/is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/glob-watcher/node_modules/readdirp": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-2.2.1.tgz", - "integrity": "sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ==", - "dev": true, - "dependencies": { - "graceful-fs": "^4.1.11", - "micromatch": "^3.1.10", - "readable-stream": "^2.0.2" - }, - "engines": { - "node": ">=0.10" - } - }, - "node_modules/glob-watcher/node_modules/to-regex-range": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz", - "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", - "dev": true, - "dependencies": { - "is-number": "^3.0.0", - "repeat-string": "^1.6.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/global-modules": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-1.0.0.tgz", - "integrity": "sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==", - "dev": true, - "dependencies": { - "global-prefix": "^1.0.1", - "is-windows": "^1.0.1", - "resolve-dir": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/global-prefix": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-1.0.2.tgz", - "integrity": "sha1-2/dDxsFJklk8ZVVoy2btMsASLr4=", - "dev": true, - "dependencies": { - "expand-tilde": "^2.0.2", - "homedir-polyfill": "^1.0.1", - "ini": "^1.3.4", - "is-windows": "^1.0.1", - "which": "^1.2.14" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/glogg": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/glogg/-/glogg-1.0.2.tgz", - "integrity": "sha512-5mwUoSuBk44Y4EshyiqcH95ZntbDdTQqA3QYSrxmzj28Ai0vXBGMH1ApSANH14j2sIRtqCEyg6PfsuP7ElOEDA==", - "dev": true, - "dependencies": { - "sparkles": "^1.0.0" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/graceful-fs": { - "version": "4.2.10", - "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", - "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==", - "dev": true - }, - "node_modules/gulp": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/gulp/-/gulp-4.0.2.tgz", - "integrity": "sha512-dvEs27SCZt2ibF29xYgmnwwCYZxdxhQ/+LFWlbAW8y7jt68L/65402Lz3+CKy0Ov4rOs+NERmDq7YlZaDqUIfA==", - "dev": true, - "dependencies": { - "glob-watcher": "^5.0.3", - "gulp-cli": "^2.2.0", - "undertaker": "^1.2.1", - "vinyl-fs": "^3.0.0" - }, - "bin": { - "gulp": "bin/gulp.js" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/gulp-beautify": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/gulp-beautify/-/gulp-beautify-3.0.0.tgz", - "integrity": "sha512-Srxzb7+AQjNm+NkEVpLBfnFtN93jofVc4d4qI+N4MTPRF/vZ14jC4QA6WUZsZZZxc/oYk4bjcqQOUhmopFWlXg==", - "dev": true, - "dependencies": { - "js-beautify": "^1.8.8", - "through2": "^2.0.0" - }, - "engines": { - "node": ">= 0.10.0" - } - }, - "node_modules/gulp-clean": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/gulp-clean/-/gulp-clean-0.4.0.tgz", - "integrity": "sha512-DARK8rNMo4lHOFLGTiHEJdf19GuoBDHqGUaypz+fOhrvOs3iFO7ntdYtdpNxv+AzSJBx/JfypF0yEj9ks1IStQ==", - "dev": true, - "dependencies": { - "fancy-log": "^1.3.2", - "plugin-error": "^0.1.2", - "rimraf": "^2.6.2", - "through2": "^2.0.3", - "vinyl": "^2.1.0" - }, - "engines": { - "node": ">=0.9" - } - }, - "node_modules/gulp-cli": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/gulp-cli/-/gulp-cli-2.3.0.tgz", - "integrity": "sha512-zzGBl5fHo0EKSXsHzjspp3y5CONegCm8ErO5Qh0UzFzk2y4tMvzLWhoDokADbarfZRL2pGpRp7yt6gfJX4ph7A==", - "dev": true, - "dependencies": { - "ansi-colors": "^1.0.1", - "archy": "^1.0.0", - "array-sort": "^1.0.0", - "color-support": "^1.1.3", - "concat-stream": "^1.6.0", - "copy-props": "^2.0.1", - "fancy-log": "^1.3.2", - "gulplog": "^1.0.0", - "interpret": "^1.4.0", - "isobject": "^3.0.1", - "liftoff": "^3.1.0", - "matchdep": "^2.0.0", - "mute-stdout": "^1.0.0", - "pretty-hrtime": "^1.0.0", - "replace-homedir": "^1.0.0", - "semver-greatest-satisfied-range": "^1.1.0", - "v8flags": "^3.2.0", - "yargs": "^7.1.0" - }, - "bin": { - "gulp": "bin/gulp.js" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/gulp-concat": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/gulp-concat/-/gulp-concat-2.6.1.tgz", - "integrity": "sha1-Yz0WyV2IUEYorQJmVmPO5aR5M1M=", - "dev": true, - "dependencies": { - "concat-with-sourcemaps": "^1.0.0", - "through2": "^2.0.0", - "vinyl": "^2.0.0" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/gulp-header": { - "version": "2.0.9", - "resolved": "https://registry.npmjs.org/gulp-header/-/gulp-header-2.0.9.tgz", - "integrity": "sha512-LMGiBx+qH8giwrOuuZXSGvswcIUh0OiioNkUpLhNyvaC6/Ga8X6cfAeme2L5PqsbXMhL8o8b/OmVqIQdxprhcQ==", - "dev": true, - "dependencies": { - "concat-with-sourcemaps": "^1.1.0", - "lodash.template": "^4.5.0", - "map-stream": "0.0.7", - "through2": "^2.0.0" - } - }, - "node_modules/gulp-minify": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/gulp-minify/-/gulp-minify-3.1.0.tgz", - "integrity": "sha512-ixF41aYg+NQikI8hpoHdEclYcQkbGdXQu1CBdHaU7Epg8H6e8d2jWXw1+rBPgYwl/XpKgjHj7NI6gkhoSNSSAg==", - "dev": true, - "dependencies": { - "ansi-colors": "^1.0.1", - "minimatch": "^3.0.2", - "plugin-error": "^0.1.2", - "terser": "^3.7.6", - "through2": "^2.0.3", - "vinyl": "^2.1.0" - } - }, - "node_modules/gulp-strip-code": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/gulp-strip-code/-/gulp-strip-code-0.1.4.tgz", - "integrity": "sha1-75kmfyp1dFjcGmGduHJdSxcl/Ws=", - "dev": true, - "dependencies": { - "event-stream": "^3.1.5" - } - }, - "node_modules/gulp-strip-comments": { - "version": "2.5.2", - "resolved": "https://registry.npmjs.org/gulp-strip-comments/-/gulp-strip-comments-2.5.2.tgz", - "integrity": "sha512-lb1bW7rsPWDD8f4ZPSguDvmCdjKmjr5HR4yZb9ros3sLl5AfW7oUj8KzY9/VRisT7dG8dL7hVHzNpQEVxfwZGQ==", - "dev": true, - "dependencies": { - "decomment": "^0.9.0", - "plugin-error": "^0.1.2", - "through2": "^2.0.3" - } - }, - "node_modules/gulplog": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/gulplog/-/gulplog-1.0.0.tgz", - "integrity": "sha1-4oxNRdBey77YGDY86PnFkmIp/+U=", - "dev": true, - "dependencies": { - "glogg": "^1.0.0" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/has": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", - "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", - "dev": true, - "dependencies": { - "function-bind": "^1.1.1" - }, - "engines": { - "node": ">= 0.4.0" - } - }, - "node_modules/has-property-descriptors": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", - "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", - "dev": true, - "dependencies": { - "get-intrinsic": "^1.1.1" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/has-symbols": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", - "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", - "dev": true, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/has-value": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz", - "integrity": "sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=", - "dev": true, - "dependencies": { - "get-value": "^2.0.6", - "has-values": "^1.0.0", - "isobject": "^3.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/has-values": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz", - "integrity": "sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=", - "dev": true, - "dependencies": { - "is-number": "^3.0.0", - "kind-of": "^4.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/has-values/node_modules/kind-of": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz", - "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=", - "dev": true, - "dependencies": { - "is-buffer": "^1.1.5" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/homedir-polyfill": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz", - "integrity": "sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==", - "dev": true, - "dependencies": { - "parse-passwd": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/hosted-git-info": { - "version": "2.8.9", - "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz", - "integrity": "sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==", - "dev": true - }, - "node_modules/inflight": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", - "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", - "dev": true, - "dependencies": { - "once": "^1.3.0", - "wrappy": "1" - } - }, - "node_modules/inherits": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", - "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", - "dev": true - }, - "node_modules/ini": { - "version": "1.3.8", - "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", - "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==", - "dev": true - }, - "node_modules/interpret": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz", - "integrity": "sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==", - "dev": true, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/invert-kv": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/invert-kv/-/invert-kv-1.0.0.tgz", - "integrity": "sha1-EEqOSqym09jNFXqO+L+rLXo//bY=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-absolute": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-absolute/-/is-absolute-1.0.0.tgz", - "integrity": "sha512-dOWoqflvcydARa360Gvv18DZ/gRuHKi2NU/wU5X1ZFzdYfH29nkiNZsF3mp4OJ3H4yo9Mx8A/uAGNzpzPN3yBA==", - "dev": true, - "dependencies": { - "is-relative": "^1.0.0", - "is-windows": "^1.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-accessor-descriptor": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", - "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", - "dev": true, - "dependencies": { - "kind-of": "^6.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-accessor-descriptor/node_modules/kind-of": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", - "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-arrayish": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", - "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=", - "dev": true - }, - "node_modules/is-binary-path": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", - "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", - "dev": true, - "dependencies": { - "binary-extensions": "^2.0.0" - }, - "engines": { - "node": ">=8" - } - }, - "node_modules/is-buffer": { - "version": "1.1.6", - "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz", - "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==", - "dev": true - }, - "node_modules/is-core-module": { - "version": "2.9.0", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.9.0.tgz", - "integrity": "sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==", - "dev": true, - "dependencies": { - "has": "^1.0.3" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/is-data-descriptor": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", - "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", - "dev": true, - "dependencies": { - "kind-of": "^6.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-data-descriptor/node_modules/kind-of": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", - "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-descriptor": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", - "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", - "dev": true, - "dependencies": { - "is-accessor-descriptor": "^1.0.0", - "is-data-descriptor": "^1.0.0", - "kind-of": "^6.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-descriptor/node_modules/kind-of": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", - "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-extendable": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", - "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", - "dev": true, - "dependencies": { - "is-plain-object": "^2.0.4" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-extendable/node_modules/is-plain-object": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", - "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", - "dev": true, - "dependencies": { - "isobject": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-extglob": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", - "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-fullwidth-code-point": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", - "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", - "dev": true, - "dependencies": { - "number-is-nan": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-glob": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", - "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", - "dev": true, - "dependencies": { - "is-extglob": "^2.1.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-negated-glob": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-negated-glob/-/is-negated-glob-1.0.0.tgz", - "integrity": "sha1-aRC8pdqMleeEtXUbl2z1oQ/uNtI=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-number": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", - "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", - "dev": true, - "dependencies": { - "kind-of": "^3.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-number/node_modules/kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "dependencies": { - "is-buffer": "^1.1.5" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-plain-object": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz", - "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-relative": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-relative/-/is-relative-1.0.0.tgz", - "integrity": "sha512-Kw/ReK0iqwKeu0MITLFuj0jbPAmEiOsIwyIXvvbfa6QfmN9pkD1M+8pdk7Rl/dTKbH34/XBFMbgD4iMJhLQbGA==", - "dev": true, - "dependencies": { - "is-unc-path": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-unc-path": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-unc-path/-/is-unc-path-1.0.0.tgz", - "integrity": "sha512-mrGpVd0fs7WWLfVsStvgF6iEJnbjDFZh9/emhRDcGWTduTfNHd9CHeUwH3gYIjdbwo4On6hunkztwOaAw0yllQ==", - "dev": true, - "dependencies": { - "unc-path-regex": "^0.1.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-utf8": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz", - "integrity": "sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=", - "dev": true - }, - "node_modules/is-valid-glob": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-valid-glob/-/is-valid-glob-1.0.0.tgz", - "integrity": "sha1-Kb8+/3Ab4tTTFdusw5vDn+j2Aao=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/is-windows": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz", - "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/isarray": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", - "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", - "dev": true - }, - "node_modules/isexe": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", - "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=", - "dev": true - }, - "node_modules/isobject": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", - "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/js-beautify": { - "version": "1.14.3", - "resolved": "https://registry.npmjs.org/js-beautify/-/js-beautify-1.14.3.tgz", - "integrity": "sha512-f1ra8PHtOEu/70EBnmiUlV8nJePS58y9qKjl4JHfYWlFH6bo7ogZBz//FAZp7jDuXtYnGYKymZPlrg2I/9Zo4g==", - "dev": true, - "dependencies": { - "config-chain": "^1.1.13", - "editorconfig": "^0.15.3", - "glob": "^7.1.3", - "nopt": "^5.0.0" - }, - "bin": { - "css-beautify": "js/bin/css-beautify.js", - "html-beautify": "js/bin/html-beautify.js", - "js-beautify": "js/bin/js-beautify.js" - }, - "engines": { - "node": ">=10" - } - }, - "node_modules/json-stable-stringify-without-jsonify": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", - "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=", - "dev": true - }, - "node_modules/just-debounce": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/just-debounce/-/just-debounce-1.1.0.tgz", - "integrity": "sha512-qpcRocdkUmf+UTNBYx5w6dexX5J31AKK1OmPwH630a83DdVVUIngk55RSAiIGpQyoH0dlr872VHfPjnQnK1qDQ==", - "dev": true - }, - "node_modules/kind-of": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz", - "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/last-run": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/last-run/-/last-run-1.1.1.tgz", - "integrity": "sha1-RblpQsF7HHnHchmCWbqUO+v4yls=", - "dev": true, - "dependencies": { - "default-resolution": "^2.0.0", - "es6-weak-map": "^2.0.1" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/lazystream": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/lazystream/-/lazystream-1.0.1.tgz", - "integrity": "sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==", - "dev": true, - "dependencies": { - "readable-stream": "^2.0.5" - }, - "engines": { - "node": ">= 0.6.3" - } - }, - "node_modules/lcid": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/lcid/-/lcid-1.0.0.tgz", - "integrity": "sha1-MIrMr6C8SDo4Z7S28rlQYlHRuDU=", - "dev": true, - "dependencies": { - "invert-kv": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/lead": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/lead/-/lead-1.0.0.tgz", - "integrity": "sha1-bxT5mje+Op3XhPVJVpDlkDRm7kI=", - "dev": true, - "dependencies": { - "flush-write-stream": "^1.0.2" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/liftoff": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/liftoff/-/liftoff-3.1.0.tgz", - "integrity": "sha512-DlIPlJUkCV0Ips2zf2pJP0unEoT1kwYhiiPUGF3s/jtxTCjziNLoiVVh+jqWOWeFi6mmwQ5fNxvAUyPad4Dfog==", - "dev": true, - "dependencies": { - "extend": "^3.0.0", - "findup-sync": "^3.0.0", - "fined": "^1.0.1", - "flagged-respawn": "^1.0.0", - "is-plain-object": "^2.0.4", - "object.map": "^1.0.0", - "rechoir": "^0.6.2", - "resolve": "^1.1.7" - }, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/liftoff/node_modules/is-plain-object": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", - "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", - "dev": true, - "dependencies": { - "isobject": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/load-json-file": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", - "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", - "dev": true, - "dependencies": { - "graceful-fs": "^4.1.2", - "parse-json": "^2.2.0", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0", - "strip-bom": "^2.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/lodash._reinterpolate": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz", - "integrity": "sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=", - "dev": true - }, - "node_modules/lodash.template": { - "version": "4.5.0", - "resolved": "https://registry.npmjs.org/lodash.template/-/lodash.template-4.5.0.tgz", - "integrity": "sha512-84vYFxIkmidUiFxidA/KjjH9pAycqW+h980j7Fuz5qxRtO9pgB7MDFTdys1N7A5mcucRiDyEq4fusljItR1T/A==", - "dev": true, - "dependencies": { - "lodash._reinterpolate": "^3.0.0", - "lodash.templatesettings": "^4.0.0" - } - }, - "node_modules/lodash.templatesettings": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/lodash.templatesettings/-/lodash.templatesettings-4.2.0.tgz", - "integrity": "sha512-stgLz+i3Aa9mZgnjr/O+v9ruKZsPsndy7qPZOchbqk2cnTU1ZaldKK+v7m54WoKIyxiuMZTKT2H81F8BeAc3ZQ==", - "dev": true, - "dependencies": { - "lodash._reinterpolate": "^3.0.0" - } - }, - "node_modules/lru-cache": { - "version": "4.1.5", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz", - "integrity": "sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==", - "dev": true, - "dependencies": { - "pseudomap": "^1.0.2", - "yallist": "^2.1.2" - } - }, - "node_modules/make-iterator": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/make-iterator/-/make-iterator-1.0.1.tgz", - "integrity": "sha512-pxiuXh0iVEq7VM7KMIhs5gxsfxCux2URptUQaXo4iZZJxBAzTPOLE2BumO5dbfVYq/hBJFBR/a1mFDmOx5AGmw==", - "dev": true, - "dependencies": { - "kind-of": "^6.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/make-iterator/node_modules/kind-of": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", - "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/map-cache": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz", - "integrity": "sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/map-stream": { - "version": "0.0.7", - "resolved": "https://registry.npmjs.org/map-stream/-/map-stream-0.0.7.tgz", - "integrity": "sha1-ih8HiW2CsQkmvTdEokIACfiJdKg=", - "dev": true - }, - "node_modules/map-visit": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz", - "integrity": "sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=", - "dev": true, - "dependencies": { - "object-visit": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/matchdep": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/matchdep/-/matchdep-2.0.0.tgz", - "integrity": "sha1-xvNINKDY28OzfCfui7yyfHd1WC4=", - "dev": true, - "dependencies": { - "findup-sync": "^2.0.0", - "micromatch": "^3.0.4", - "resolve": "^1.4.0", - "stack-trace": "0.0.10" - }, - "engines": { - "node": ">= 0.10.0" - } - }, - "node_modules/matchdep/node_modules/findup-sync": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-2.0.0.tgz", - "integrity": "sha1-kyaxSIwi0aYIhlCoaQGy2akKLLw=", - "dev": true, - "dependencies": { - "detect-file": "^1.0.0", - "is-glob": "^3.1.0", - "micromatch": "^3.0.4", - "resolve-dir": "^1.0.1" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/matchdep/node_modules/is-glob": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz", - "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=", - "dev": true, - "dependencies": { - "is-extglob": "^2.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/micromatch": { - "version": "3.1.10", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz", - "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", - "dev": true, - "dependencies": { - "arr-diff": "^4.0.0", - "array-unique": "^0.3.2", - "braces": "^2.3.1", - "define-property": "^2.0.2", - "extend-shallow": "^3.0.2", - "extglob": "^2.0.4", - "fragment-cache": "^0.2.1", - "kind-of": "^6.0.2", - "nanomatch": "^1.2.9", - "object.pick": "^1.3.0", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/micromatch/node_modules/braces": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz", - "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", - "dev": true, - "dependencies": { - "arr-flatten": "^1.1.0", - "array-unique": "^0.3.2", - "extend-shallow": "^2.0.1", - "fill-range": "^4.0.0", - "isobject": "^3.0.1", - "repeat-element": "^1.1.2", - "snapdragon": "^0.8.1", - "snapdragon-node": "^2.0.1", - "split-string": "^3.0.2", - "to-regex": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/micromatch/node_modules/braces/node_modules/extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "dependencies": { - "is-extendable": "^0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/micromatch/node_modules/fill-range": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz", - "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", - "dev": true, - "dependencies": { - "extend-shallow": "^2.0.1", - "is-number": "^3.0.0", - "repeat-string": "^1.6.1", - "to-regex-range": "^2.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/micromatch/node_modules/fill-range/node_modules/extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "dependencies": { - "is-extendable": "^0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/micromatch/node_modules/is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/micromatch/node_modules/kind-of": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", - "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/micromatch/node_modules/to-regex-range": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz", - "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", - "dev": true, - "dependencies": { - "is-number": "^3.0.0", - "repeat-string": "^1.6.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/minimatch": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", - "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", - "dev": true, - "dependencies": { - "brace-expansion": "^1.1.7" - }, - "engines": { - "node": "*" - } - }, - "node_modules/mixin-deep": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz", - "integrity": "sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==", - "dev": true, - "dependencies": { - "for-in": "^1.0.2", - "is-extendable": "^1.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/ms": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", - "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", - "dev": true - }, - "node_modules/mute-stdout": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/mute-stdout/-/mute-stdout-1.0.1.tgz", - "integrity": "sha512-kDcwXR4PS7caBpuRYYBUz9iVixUk3anO3f5OYFiIPwK/20vCzKCHyKoulbiDY1S53zD2bxUpxN/IJ+TnXjfvxg==", - "dev": true, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/nan": { - "version": "2.15.0", - "resolved": "https://registry.npmjs.org/nan/-/nan-2.15.0.tgz", - "integrity": "sha512-8ZtvEnA2c5aYCZYd1cvgdnU6cqwixRoYg70xPLWUws5ORTa/lnw+u4amixRS/Ac5U5mQVgp9pnlSUnbNWFaWZQ==", - "dev": true, - "optional": true - }, - "node_modules/nanomatch": { - "version": "1.2.13", - "resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz", - "integrity": "sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==", - "dev": true, - "dependencies": { - "arr-diff": "^4.0.0", - "array-unique": "^0.3.2", - "define-property": "^2.0.2", - "extend-shallow": "^3.0.2", - "fragment-cache": "^0.2.1", - "is-windows": "^1.0.2", - "kind-of": "^6.0.2", - "object.pick": "^1.3.0", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/nanomatch/node_modules/kind-of": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", - "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/next-tick": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/next-tick/-/next-tick-1.1.0.tgz", - "integrity": "sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==", - "dev": true - }, - "node_modules/nopt": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz", - "integrity": "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==", - "dev": true, - "dependencies": { - "abbrev": "1" - }, - "bin": { - "nopt": "bin/nopt.js" - }, - "engines": { - "node": ">=6" - } - }, - "node_modules/normalize-package-data": { - "version": "2.5.0", - "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz", - "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==", - "dev": true, - "dependencies": { - "hosted-git-info": "^2.1.4", - "resolve": "^1.10.0", - "semver": "2 || 3 || 4 || 5", - "validate-npm-package-license": "^3.0.1" - } - }, - "node_modules/normalize-path": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", - "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/now-and-later": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/now-and-later/-/now-and-later-2.0.1.tgz", - "integrity": "sha512-KGvQ0cB70AQfg107Xvs/Fbu+dGmZoTRJp2TaPwcwQm3/7PteUyN2BCgk8KBMPGBUXZdVwyWS8fDCGFygBm19UQ==", - "dev": true, - "dependencies": { - "once": "^1.3.2" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/number-is-nan": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz", - "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/object-copy": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz", - "integrity": "sha1-fn2Fi3gb18mRpBupde04EnVOmYw=", - "dev": true, - "dependencies": { - "copy-descriptor": "^0.1.0", - "define-property": "^0.2.5", - "kind-of": "^3.0.3" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/object-copy/node_modules/define-property": { - "version": "0.2.5", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "dependencies": { - "is-descriptor": "^0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/object-copy/node_modules/is-accessor-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", - "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", - "dev": true, - "dependencies": { - "kind-of": "^3.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/object-copy/node_modules/is-data-descriptor": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", - "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", - "dev": true, - "dependencies": { - "kind-of": "^3.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/object-copy/node_modules/is-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", - "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", - "dev": true, - "dependencies": { - "is-accessor-descriptor": "^0.1.6", - "is-data-descriptor": "^0.1.4", - "kind-of": "^5.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/object-copy/node_modules/is-descriptor/node_modules/kind-of": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz", - "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/object-copy/node_modules/kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "dependencies": { - "is-buffer": "^1.1.5" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/object-keys": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", - "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", - "dev": true, - "engines": { - "node": ">= 0.4" - } - }, - "node_modules/object-visit": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz", - "integrity": "sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=", - "dev": true, - "dependencies": { - "isobject": "^3.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/object.assign": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.2.tgz", - "integrity": "sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==", - "dev": true, - "dependencies": { - "call-bind": "^1.0.0", - "define-properties": "^1.1.3", - "has-symbols": "^1.0.1", - "object-keys": "^1.1.1" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/object.defaults": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/object.defaults/-/object.defaults-1.1.0.tgz", - "integrity": "sha1-On+GgzS0B96gbaFtiNXNKeQ1/s8=", - "dev": true, - "dependencies": { - "array-each": "^1.0.1", - "array-slice": "^1.0.0", - "for-own": "^1.0.0", - "isobject": "^3.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/object.map": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/object.map/-/object.map-1.0.1.tgz", - "integrity": "sha1-z4Plncj8wK1fQlDh94s7gb2AHTc=", - "dev": true, - "dependencies": { - "for-own": "^1.0.0", - "make-iterator": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/object.pick": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz", - "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=", - "dev": true, - "dependencies": { - "isobject": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/object.reduce": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/object.reduce/-/object.reduce-1.0.1.tgz", - "integrity": "sha1-b+NI8qx/oPlcpiEiZZkJaCW7A60=", - "dev": true, - "dependencies": { - "for-own": "^1.0.0", - "make-iterator": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/once": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", - "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", - "dev": true, - "dependencies": { - "wrappy": "1" - } - }, - "node_modules/ordered-read-streams": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/ordered-read-streams/-/ordered-read-streams-1.0.1.tgz", - "integrity": "sha1-d8DLN8QVJdZBZtmQ/61+xqDhNj4=", - "dev": true, - "dependencies": { - "readable-stream": "^2.0.1" - } - }, - "node_modules/os-locale": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/os-locale/-/os-locale-1.4.0.tgz", - "integrity": "sha1-IPnxeuKe00XoveWDsT0gCYA8FNk=", - "dev": true, - "dependencies": { - "lcid": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/parse-filepath": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/parse-filepath/-/parse-filepath-1.0.2.tgz", - "integrity": "sha1-pjISf1Oq89FYdvWHLz/6x2PWyJE=", - "dev": true, - "dependencies": { - "is-absolute": "^1.0.0", - "map-cache": "^0.2.0", - "path-root": "^0.1.1" - }, - "engines": { - "node": ">=0.8" - } - }, - "node_modules/parse-json": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", - "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", - "dev": true, - "dependencies": { - "error-ex": "^1.2.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/parse-node-version": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/parse-node-version/-/parse-node-version-1.0.1.tgz", - "integrity": "sha512-3YHlOa/JgH6Mnpr05jP9eDG254US9ek25LyIxZlDItp2iJtwyaXQb57lBYLdT3MowkUFYEV2XXNAYIPlESvJlA==", - "dev": true, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/parse-passwd": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/parse-passwd/-/parse-passwd-1.0.0.tgz", - "integrity": "sha1-bVuTSkVpk7I9N/QKOC1vFmao5cY=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/pascalcase": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz", - "integrity": "sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/path-dirname": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/path-dirname/-/path-dirname-1.0.2.tgz", - "integrity": "sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=", - "dev": true - }, - "node_modules/path-exists": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz", - "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", - "dev": true, - "dependencies": { - "pinkie-promise": "^2.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/path-is-absolute": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", - "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/path-parse": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", - "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", - "dev": true - }, - "node_modules/path-root": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/path-root/-/path-root-0.1.1.tgz", - "integrity": "sha1-mkpoFMrBwM1zNgqV8yCDyOpHRbc=", - "dev": true, - "dependencies": { - "path-root-regex": "^0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/path-root-regex": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/path-root-regex/-/path-root-regex-0.1.2.tgz", - "integrity": "sha1-v8zcjfWxLcUsi0PsONGNcsBLqW0=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/path-type": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz", - "integrity": "sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=", - "dev": true, - "dependencies": { - "graceful-fs": "^4.1.2", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/pause-stream": { - "version": "0.0.11", - "resolved": "https://registry.npmjs.org/pause-stream/-/pause-stream-0.0.11.tgz", - "integrity": "sha1-/lo0sMvOErWqaitAPuLnO2AvFEU=", - "dev": true, - "dependencies": { - "through": "~2.3" - } - }, - "node_modules/picomatch": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", - "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", - "dev": true, - "engines": { - "node": ">=8.6" - }, - "funding": { - "url": "https://github.com/sponsors/jonschlinkert" - } - }, - "node_modules/pify": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", - "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/pinkie": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz", - "integrity": "sha1-clVrgM+g1IqXToDnckjoDtT3+HA=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/pinkie-promise": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz", - "integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=", - "dev": true, - "dependencies": { - "pinkie": "^2.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/plugin-error": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/plugin-error/-/plugin-error-0.1.2.tgz", - "integrity": "sha1-O5uzM1zPAPQl4HQ34ZJ2ln2kes4=", - "dev": true, - "dependencies": { - "ansi-cyan": "^0.1.1", - "ansi-red": "^0.1.1", - "arr-diff": "^1.0.1", - "arr-union": "^2.0.1", - "extend-shallow": "^1.1.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/plugin-error/node_modules/arr-diff": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-1.1.0.tgz", - "integrity": "sha1-aHwydYFjWI/vfeezb6vklesaOZo=", - "dev": true, - "dependencies": { - "arr-flatten": "^1.0.1", - "array-slice": "^0.2.3" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/plugin-error/node_modules/array-slice": { - "version": "0.2.3", - "resolved": "https://registry.npmjs.org/array-slice/-/array-slice-0.2.3.tgz", - "integrity": "sha1-3Tz7gO15c6dRF82sabC5nshhhvU=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/plugin-error/node_modules/extend-shallow": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-1.1.4.tgz", - "integrity": "sha1-Gda/lN/AnXa6cR85uHLSH/TdkHE=", - "dev": true, - "dependencies": { - "kind-of": "^1.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/plugin-error/node_modules/kind-of": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-1.1.0.tgz", - "integrity": "sha1-FAo9LUGjbS78+pN3tiwk+ElaXEQ=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/posix-character-classes": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz", - "integrity": "sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/pretty-hrtime": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz", - "integrity": "sha1-t+PqQkNaTJsnWdmeDyAesZWALuE=", - "dev": true, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/process-nextick-args": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", - "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", - "dev": true - }, - "node_modules/proto-list": { - "version": "1.2.4", - "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz", - "integrity": "sha1-IS1b/hMYMGpCD2QCuOJv85ZHqEk=", - "dev": true - }, - "node_modules/pseudomap": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz", - "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=", - "dev": true - }, - "node_modules/pump": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/pump/-/pump-2.0.1.tgz", - "integrity": "sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==", - "dev": true, - "dependencies": { - "end-of-stream": "^1.1.0", - "once": "^1.3.1" - } - }, - "node_modules/pumpify": { - "version": "1.5.1", - "resolved": "https://registry.npmjs.org/pumpify/-/pumpify-1.5.1.tgz", - "integrity": "sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==", - "dev": true, - "dependencies": { - "duplexify": "^3.6.0", - "inherits": "^2.0.3", - "pump": "^2.0.0" - } - }, - "node_modules/read-pkg": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz", - "integrity": "sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=", - "dev": true, - "dependencies": { - "load-json-file": "^1.0.0", - "normalize-package-data": "^2.3.2", - "path-type": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/read-pkg-up": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz", - "integrity": "sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=", - "dev": true, - "dependencies": { - "find-up": "^1.0.0", - "read-pkg": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/readable-stream": { - "version": "2.3.7", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz", - "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==", - "dev": true, - "dependencies": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.3", - "isarray": "~1.0.0", - "process-nextick-args": "~2.0.0", - "safe-buffer": "~5.1.1", - "string_decoder": "~1.1.1", - "util-deprecate": "~1.0.1" - } - }, - "node_modules/readdirp": { - "version": "3.6.0", - "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", - "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", - "dev": true, - "dependencies": { - "picomatch": "^2.2.1" - }, - "engines": { - "node": ">=8.10.0" - } - }, - "node_modules/rechoir": { - "version": "0.6.2", - "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz", - "integrity": "sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=", - "dev": true, - "dependencies": { - "resolve": "^1.1.6" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/regex-not": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz", - "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==", - "dev": true, - "dependencies": { - "extend-shallow": "^3.0.2", - "safe-regex": "^1.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/remove-bom-buffer": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/remove-bom-buffer/-/remove-bom-buffer-3.0.0.tgz", - "integrity": "sha512-8v2rWhaakv18qcvNeli2mZ/TMTL2nEyAKRvzo1WtnZBl15SHyEhrCu2/xKlJyUFKHiHgfXIyuY6g2dObJJycXQ==", - "dev": true, - "dependencies": { - "is-buffer": "^1.1.5", - "is-utf8": "^0.2.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/remove-bom-stream": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/remove-bom-stream/-/remove-bom-stream-1.2.0.tgz", - "integrity": "sha1-BfGlk/FuQuH7kOv1nejlaVJflSM=", - "dev": true, - "dependencies": { - "remove-bom-buffer": "^3.0.0", - "safe-buffer": "^5.1.0", - "through2": "^2.0.3" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/remove-trailing-separator": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz", - "integrity": "sha1-wkvOKig62tW8P1jg1IJJuSN52O8=", - "dev": true - }, - "node_modules/repeat-element": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.4.tgz", - "integrity": "sha512-LFiNfRcSu7KK3evMyYOuCzv3L10TW7yC1G2/+StMjK8Y6Vqd2MG7r/Qjw4ghtuCOjFvlnms/iMmLqpvW/ES/WQ==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/repeat-string": { - "version": "1.6.1", - "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz", - "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=", - "dev": true, - "engines": { - "node": ">=0.10" - } - }, - "node_modules/replace-ext": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/replace-ext/-/replace-ext-1.0.1.tgz", - "integrity": "sha512-yD5BHCe7quCgBph4rMQ+0KkIRKwWCrHDOX1p1Gp6HwjPM5kVoCdKGNhN7ydqqsX6lJEnQDKZ/tFMiEdQ1dvPEw==", - "dev": true, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/replace-homedir": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/replace-homedir/-/replace-homedir-1.0.0.tgz", - "integrity": "sha1-6H9tUTuSjd6AgmDBK+f+xv9ueYw=", - "dev": true, - "dependencies": { - "homedir-polyfill": "^1.0.1", - "is-absolute": "^1.0.0", - "remove-trailing-separator": "^1.1.0" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/require-directory": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", - "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/require-main-filename": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-1.0.1.tgz", - "integrity": "sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE=", - "dev": true - }, - "node_modules/resolve": { - "version": "1.22.0", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.0.tgz", - "integrity": "sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==", - "dev": true, - "dependencies": { - "is-core-module": "^2.8.1", - "path-parse": "^1.0.7", - "supports-preserve-symlinks-flag": "^1.0.0" - }, - "bin": { - "resolve": "bin/resolve" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/resolve-dir": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/resolve-dir/-/resolve-dir-1.0.1.tgz", - "integrity": "sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=", - "dev": true, - "dependencies": { - "expand-tilde": "^2.0.0", - "global-modules": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/resolve-options": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/resolve-options/-/resolve-options-1.1.0.tgz", - "integrity": "sha1-MrueOcBtZzONyTeMDW1gdFZq0TE=", - "dev": true, - "dependencies": { - "value-or-function": "^3.0.0" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/resolve-url": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz", - "integrity": "sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=", - "deprecated": "https://github.com/lydell/resolve-url#deprecated", - "dev": true - }, - "node_modules/ret": { - "version": "0.1.15", - "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz", - "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==", - "dev": true, - "engines": { - "node": ">=0.12" - } - }, - "node_modules/rimraf": { - "version": "2.7.1", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz", - "integrity": "sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==", - "dev": true, - "dependencies": { - "glob": "^7.1.3" - }, - "bin": { - "rimraf": "bin.js" - } - }, - "node_modules/safe-buffer": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", - "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", - "dev": true - }, - "node_modules/safe-regex": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz", - "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=", - "dev": true, - "dependencies": { - "ret": "~0.1.10" - } - }, - "node_modules/semver": { - "version": "5.7.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", - "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", - "dev": true, - "bin": { - "semver": "bin/semver" - } - }, - "node_modules/semver-greatest-satisfied-range": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/semver-greatest-satisfied-range/-/semver-greatest-satisfied-range-1.1.0.tgz", - "integrity": "sha1-E+jCZYq5aRywzXEJMkAoDTb3els=", - "dev": true, - "dependencies": { - "sver-compat": "^1.5.0" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/set-blocking": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", - "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=", - "dev": true - }, - "node_modules/sigmund": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/sigmund/-/sigmund-1.0.1.tgz", - "integrity": "sha1-P/IfGYytIXX587eBhT/ZTQ0ZtZA=", - "dev": true - }, - "node_modules/snapdragon": { - "version": "0.8.2", - "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz", - "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==", - "dev": true, - "dependencies": { - "base": "^0.11.1", - "debug": "^2.2.0", - "define-property": "^0.2.5", - "extend-shallow": "^2.0.1", - "map-cache": "^0.2.2", - "source-map": "^0.5.6", - "source-map-resolve": "^0.5.0", - "use": "^3.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/snapdragon-node": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz", - "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==", - "dev": true, - "dependencies": { - "define-property": "^1.0.0", - "isobject": "^3.0.0", - "snapdragon-util": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/snapdragon-node/node_modules/define-property": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", - "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", - "dev": true, - "dependencies": { - "is-descriptor": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/snapdragon-util": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz", - "integrity": "sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==", - "dev": true, - "dependencies": { - "kind-of": "^3.2.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/snapdragon-util/node_modules/kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "dependencies": { - "is-buffer": "^1.1.5" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/snapdragon/node_modules/define-property": { - "version": "0.2.5", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "dependencies": { - "is-descriptor": "^0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/snapdragon/node_modules/extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "dependencies": { - "is-extendable": "^0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/snapdragon/node_modules/is-accessor-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", - "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", - "dev": true, - "dependencies": { - "kind-of": "^3.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/snapdragon/node_modules/is-accessor-descriptor/node_modules/kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "dependencies": { - "is-buffer": "^1.1.5" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/snapdragon/node_modules/is-data-descriptor": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", - "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", - "dev": true, - "dependencies": { - "kind-of": "^3.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/snapdragon/node_modules/is-data-descriptor/node_modules/kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "dependencies": { - "is-buffer": "^1.1.5" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/snapdragon/node_modules/is-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", - "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", - "dev": true, - "dependencies": { - "is-accessor-descriptor": "^0.1.6", - "is-data-descriptor": "^0.1.4", - "kind-of": "^5.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/snapdragon/node_modules/is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/snapdragon/node_modules/source-map": { - "version": "0.5.7", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", - "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/source-map": { - "version": "0.6.1", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", - "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/source-map-resolve": { - "version": "0.5.3", - "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.3.tgz", - "integrity": "sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==", - "deprecated": "See https://github.com/lydell/source-map-resolve#deprecated", - "dev": true, - "dependencies": { - "atob": "^2.1.2", - "decode-uri-component": "^0.2.0", - "resolve-url": "^0.2.1", - "source-map-url": "^0.4.0", - "urix": "^0.1.0" - } - }, - "node_modules/source-map-support": { - "version": "0.5.21", - "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", - "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", - "dev": true, - "dependencies": { - "buffer-from": "^1.0.0", - "source-map": "^0.6.0" - } - }, - "node_modules/source-map-url": { - "version": "0.4.1", - "resolved": "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.1.tgz", - "integrity": "sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw==", - "deprecated": "See https://github.com/lydell/source-map-url#deprecated", - "dev": true - }, - "node_modules/sparkles": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/sparkles/-/sparkles-1.0.1.tgz", - "integrity": "sha512-dSO0DDYUahUt/0/pD/Is3VIm5TGJjludZ0HVymmhYF6eNA53PVLhnUk0znSYbH8IYBuJdCE+1luR22jNLMaQdw==", - "dev": true, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/spdx-correct": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.1.tgz", - "integrity": "sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==", - "dev": true, - "dependencies": { - "spdx-expression-parse": "^3.0.0", - "spdx-license-ids": "^3.0.0" - } - }, - "node_modules/spdx-exceptions": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz", - "integrity": "sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==", - "dev": true - }, - "node_modules/spdx-expression-parse": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", - "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", - "dev": true, - "dependencies": { - "spdx-exceptions": "^2.1.0", - "spdx-license-ids": "^3.0.0" - } - }, - "node_modules/spdx-license-ids": { - "version": "3.0.11", - "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.11.tgz", - "integrity": "sha512-Ctl2BrFiM0X3MANYgj3CkygxhRmr9mi6xhejbdO960nF6EDJApTYpn0BQnDKlnNBULKiCN1n3w9EBkHK8ZWg+g==", - "dev": true - }, - "node_modules/split": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/split/-/split-1.0.1.tgz", - "integrity": "sha512-mTyOoPbrivtXnwnIxZRFYRrPNtEFKlpB2fvjSnCQUiAA6qAZzqwna5envK4uk6OIeP17CsdF3rSBGYVBsU0Tkg==", - "dev": true, - "dependencies": { - "through": "2" - }, - "engines": { - "node": "*" - } - }, - "node_modules/split-string": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz", - "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==", - "dev": true, - "dependencies": { - "extend-shallow": "^3.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/stack-trace": { - "version": "0.0.10", - "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.10.tgz", - "integrity": "sha1-VHxws0fo0ytOEI6hoqFZ5f3eGcA=", - "dev": true, - "engines": { - "node": "*" - } - }, - "node_modules/static-extend": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz", - "integrity": "sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=", - "dev": true, - "dependencies": { - "define-property": "^0.2.5", - "object-copy": "^0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/static-extend/node_modules/define-property": { - "version": "0.2.5", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "dependencies": { - "is-descriptor": "^0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/static-extend/node_modules/is-accessor-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", - "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", - "dev": true, - "dependencies": { - "kind-of": "^3.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/static-extend/node_modules/is-accessor-descriptor/node_modules/kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "dependencies": { - "is-buffer": "^1.1.5" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/static-extend/node_modules/is-data-descriptor": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", - "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", - "dev": true, - "dependencies": { - "kind-of": "^3.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/static-extend/node_modules/is-data-descriptor/node_modules/kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "dependencies": { - "is-buffer": "^1.1.5" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/static-extend/node_modules/is-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", - "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", - "dev": true, - "dependencies": { - "is-accessor-descriptor": "^0.1.6", - "is-data-descriptor": "^0.1.4", - "kind-of": "^5.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/stream-combiner": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/stream-combiner/-/stream-combiner-0.2.2.tgz", - "integrity": "sha1-rsjLrBd7Vrb0+kec7YwZEs7lKFg=", - "dev": true, - "dependencies": { - "duplexer": "~0.1.1", - "through": "~2.3.4" - } - }, - "node_modules/stream-exhaust": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/stream-exhaust/-/stream-exhaust-1.0.2.tgz", - "integrity": "sha512-b/qaq/GlBK5xaq1yrK9/zFcyRSTNxmcZwFLGSTG0mXgZl/4Z6GgiyYOXOvY7N3eEvFRAG1bkDRz5EPGSvPYQlw==", - "dev": true - }, - "node_modules/stream-shift": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.1.tgz", - "integrity": "sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==", - "dev": true - }, - "node_modules/string_decoder": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", - "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", - "dev": true, - "dependencies": { - "safe-buffer": "~5.1.0" - } - }, - "node_modules/string-width": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", - "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", - "dev": true, - "dependencies": { - "code-point-at": "^1.0.0", - "is-fullwidth-code-point": "^1.0.0", - "strip-ansi": "^3.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/strip-ansi": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", - "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", - "dev": true, - "dependencies": { - "ansi-regex": "^2.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/strip-bom": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz", - "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=", - "dev": true, - "dependencies": { - "is-utf8": "^0.2.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/supports-preserve-symlinks-flag": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", - "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", - "dev": true, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/sver-compat": { - "version": "1.5.0", - "resolved": "https://registry.npmjs.org/sver-compat/-/sver-compat-1.5.0.tgz", - "integrity": "sha1-PPh9/rTQe0o/FIJ7wYaz/QxkXNg=", - "dev": true, - "dependencies": { - "es6-iterator": "^2.0.1", - "es6-symbol": "^3.1.1" - } - }, - "node_modules/terser": { - "version": "3.17.0", - "resolved": "https://registry.npmjs.org/terser/-/terser-3.17.0.tgz", - "integrity": "sha512-/FQzzPJmCpjAH9Xvk2paiWrFq+5M6aVOf+2KRbwhByISDX/EujxsK+BAvrhb6H+2rtrLCHK9N01wO014vrIwVQ==", - "dev": true, - "dependencies": { - "commander": "^2.19.0", - "source-map": "~0.6.1", - "source-map-support": "~0.5.10" - }, - "bin": { - "terser": "bin/uglifyjs" - }, - "engines": { - "node": ">=6.0.0" - } - }, - "node_modules/through": { - "version": "2.3.8", - "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", - "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=", - "dev": true - }, - "node_modules/through2": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz", - "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==", - "dev": true, - "dependencies": { - "readable-stream": "~2.3.6", - "xtend": "~4.0.1" - } - }, - "node_modules/through2-filter": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/through2-filter/-/through2-filter-3.0.0.tgz", - "integrity": "sha512-jaRjI2WxN3W1V8/FMZ9HKIBXixtiqs3SQSX4/YGIiP3gL6djW48VoZq9tDqeCWs3MT8YY5wb/zli8VW8snY1CA==", - "dev": true, - "dependencies": { - "through2": "~2.0.0", - "xtend": "~4.0.0" - } - }, - "node_modules/time-stamp": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/time-stamp/-/time-stamp-1.1.0.tgz", - "integrity": "sha1-dkpaEa9QVhkhsTPztE5hhofg9cM=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/to-absolute-glob": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/to-absolute-glob/-/to-absolute-glob-2.0.2.tgz", - "integrity": "sha1-GGX0PZ50sIItufFFt4z/fQ98hJs=", - "dev": true, - "dependencies": { - "is-absolute": "^1.0.0", - "is-negated-glob": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/to-object-path": { - "version": "0.3.0", - "resolved": "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz", - "integrity": "sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=", - "dev": true, - "dependencies": { - "kind-of": "^3.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/to-object-path/node_modules/kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "dependencies": { - "is-buffer": "^1.1.5" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/to-regex": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz", - "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==", - "dev": true, - "dependencies": { - "define-property": "^2.0.2", - "extend-shallow": "^3.0.2", - "regex-not": "^1.0.2", - "safe-regex": "^1.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/to-regex-range": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", - "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", - "dev": true, - "dependencies": { - "is-number": "^7.0.0" - }, - "engines": { - "node": ">=8.0" - } - }, - "node_modules/to-regex-range/node_modules/is-number": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", - "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", - "dev": true, - "engines": { - "node": ">=0.12.0" - } - }, - "node_modules/to-through": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/to-through/-/to-through-2.0.0.tgz", - "integrity": "sha1-/JKtq6ByZHvAtn1rA2ZKoZUJOvY=", - "dev": true, - "dependencies": { - "through2": "^2.0.3" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/type": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/type/-/type-1.2.0.tgz", - "integrity": "sha512-+5nt5AAniqsCnu2cEQQdpzCAh33kVx8n0VoFidKpB1dVVLAN/F+bgVOqOJqOnEnrhp222clB5p3vUlD+1QAnfg==", - "dev": true - }, - "node_modules/typedarray": { - "version": "0.0.6", - "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", - "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=", - "dev": true - }, - "node_modules/unc-path-regex": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/unc-path-regex/-/unc-path-regex-0.1.2.tgz", - "integrity": "sha1-5z3T17DXxe2G+6xrCufYxqadUPo=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/undertaker": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/undertaker/-/undertaker-1.3.0.tgz", - "integrity": "sha512-/RXwi5m/Mu3H6IHQGww3GNt1PNXlbeCuclF2QYR14L/2CHPz3DFZkvB5hZ0N/QUkiXWCACML2jXViIQEQc2MLg==", - "dev": true, - "dependencies": { - "arr-flatten": "^1.0.1", - "arr-map": "^2.0.0", - "bach": "^1.0.0", - "collection-map": "^1.0.0", - "es6-weak-map": "^2.0.1", - "fast-levenshtein": "^1.0.0", - "last-run": "^1.1.0", - "object.defaults": "^1.0.0", - "object.reduce": "^1.0.0", - "undertaker-registry": "^1.0.0" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/undertaker-registry": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/undertaker-registry/-/undertaker-registry-1.0.1.tgz", - "integrity": "sha1-XkvaMI5KiirlhPm5pDWaSZglzFA=", - "dev": true, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/union-value": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz", - "integrity": "sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==", - "dev": true, - "dependencies": { - "arr-union": "^3.1.0", - "get-value": "^2.0.6", - "is-extendable": "^0.1.1", - "set-value": "^2.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/union-value/node_modules/arr-union": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz", - "integrity": "sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/union-value/node_modules/extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==", - "dev": true, - "dependencies": { - "is-extendable": "^0.1.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/union-value/node_modules/is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/union-value/node_modules/is-plain-object": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", - "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", - "dev": true, - "dependencies": { - "isobject": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/union-value/node_modules/set-value": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz", - "integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==", - "dev": true, - "dependencies": { - "extend-shallow": "^2.0.1", - "is-extendable": "^0.1.1", - "is-plain-object": "^2.0.3", - "split-string": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/unique-stream": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/unique-stream/-/unique-stream-2.3.1.tgz", - "integrity": "sha512-2nY4TnBE70yoxHkDli7DMazpWiP7xMdCYqU2nBRO0UB+ZpEkGsSija7MvmvnZFUeC+mrgiUfcHSr3LmRFIg4+A==", - "dev": true, - "dependencies": { - "json-stable-stringify-without-jsonify": "^1.0.1", - "through2-filter": "^3.0.0" - } - }, - "node_modules/unset-value": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz", - "integrity": "sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=", - "dev": true, - "dependencies": { - "has-value": "^0.3.1", - "isobject": "^3.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/unset-value/node_modules/has-value": { - "version": "0.3.1", - "resolved": "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz", - "integrity": "sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=", - "dev": true, - "dependencies": { - "get-value": "^2.0.3", - "has-values": "^0.1.4", - "isobject": "^2.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/unset-value/node_modules/has-value/node_modules/isobject": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz", - "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=", - "dev": true, - "dependencies": { - "isarray": "1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/unset-value/node_modules/has-values": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz", - "integrity": "sha1-bWHeldkd/Km5oCCJrThL/49it3E=", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/upath": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz", - "integrity": "sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==", - "dev": true, - "engines": { - "node": ">=4", - "yarn": "*" - } - }, - "node_modules/urix": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz", - "integrity": "sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=", - "deprecated": "Please see https://github.com/lydell/urix#deprecated", - "dev": true - }, - "node_modules/use": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/use/-/use-3.1.1.tgz", - "integrity": "sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/util-deprecate": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", - "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=", - "dev": true - }, - "node_modules/v8flags": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/v8flags/-/v8flags-3.2.0.tgz", - "integrity": "sha512-mH8etigqMfiGWdeXpaaqGfs6BndypxusHHcv2qSHyZkGEznCd/qAXCWWRzeowtL54147cktFOC4P5y+kl8d8Jg==", - "dev": true, - "dependencies": { - "homedir-polyfill": "^1.0.1" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/validate-npm-package-license": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", - "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", - "dev": true, - "dependencies": { - "spdx-correct": "^3.0.0", - "spdx-expression-parse": "^3.0.0" - } - }, - "node_modules/value-or-function": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/value-or-function/-/value-or-function-3.0.0.tgz", - "integrity": "sha1-HCQ6ULWVwb5Up1S/7OhWO5/42BM=", - "dev": true, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/vinyl": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/vinyl/-/vinyl-2.2.1.tgz", - "integrity": "sha512-LII3bXRFBZLlezoG5FfZVcXflZgWP/4dCwKtxd5ky9+LOtM4CS3bIRQsmR1KMnMW07jpE8fqR2lcxPZ+8sJIcw==", - "dev": true, - "dependencies": { - "clone": "^2.1.1", - "clone-buffer": "^1.0.0", - "clone-stats": "^1.0.0", - "cloneable-readable": "^1.0.0", - "remove-trailing-separator": "^1.0.1", - "replace-ext": "^1.0.0" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/vinyl-fs": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/vinyl-fs/-/vinyl-fs-3.0.3.tgz", - "integrity": "sha512-vIu34EkyNyJxmP0jscNzWBSygh7VWhqun6RmqVfXePrOwi9lhvRs//dOaGOTRUQr4tx7/zd26Tk5WeSVZitgng==", - "dev": true, - "dependencies": { - "fs-mkdirp-stream": "^1.0.0", - "glob-stream": "^6.1.0", - "graceful-fs": "^4.0.0", - "is-valid-glob": "^1.0.0", - "lazystream": "^1.0.0", - "lead": "^1.0.0", - "object.assign": "^4.0.4", - "pumpify": "^1.3.5", - "readable-stream": "^2.3.3", - "remove-bom-buffer": "^3.0.0", - "remove-bom-stream": "^1.2.0", - "resolve-options": "^1.1.0", - "through2": "^2.0.0", - "to-through": "^2.0.0", - "value-or-function": "^3.0.0", - "vinyl": "^2.0.0", - "vinyl-sourcemap": "^1.1.0" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/vinyl-sourcemap": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/vinyl-sourcemap/-/vinyl-sourcemap-1.1.0.tgz", - "integrity": "sha1-kqgAWTo4cDqM2xHYswCtS+Y7PhY=", - "dev": true, - "dependencies": { - "append-buffer": "^1.0.2", - "convert-source-map": "^1.5.0", - "graceful-fs": "^4.1.6", - "normalize-path": "^2.1.1", - "now-and-later": "^2.0.0", - "remove-bom-buffer": "^3.0.0", - "vinyl": "^2.0.0" - }, - "engines": { - "node": ">= 0.10" - } - }, - "node_modules/vinyl-sourcemap/node_modules/normalize-path": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", - "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", - "dev": true, - "dependencies": { - "remove-trailing-separator": "^1.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/which": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", - "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", - "dev": true, - "dependencies": { - "isexe": "^2.0.0" - }, - "bin": { - "which": "bin/which" - } - }, - "node_modules/which-module": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/which-module/-/which-module-1.0.0.tgz", - "integrity": "sha1-u6Y8qGGUiZT/MHc2CJ47lgJsKk8=", - "dev": true - }, - "node_modules/wrap-ansi": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz", - "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=", - "dev": true, - "dependencies": { - "string-width": "^1.0.1", - "strip-ansi": "^3.0.1" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/wrappy": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", - "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=", - "dev": true - }, - "node_modules/xtend": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", - "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", - "dev": true, - "engines": { - "node": ">=0.4" - } - }, - "node_modules/y18n": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/y18n/-/y18n-3.2.2.tgz", - "integrity": "sha512-uGZHXkHnhF0XeeAPgnKfPv1bgKAYyVvmNL1xlKsPYZPaIHxGti2hHqvOCQv71XMsLxu1QjergkqogUnms5D3YQ==", - "dev": true - }, - "node_modules/yallist": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz", - "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=", - "dev": true - }, - "node_modules/yargs": { - "version": "7.1.2", - "resolved": "https://registry.npmjs.org/yargs/-/yargs-7.1.2.tgz", - "integrity": "sha512-ZEjj/dQYQy0Zx0lgLMLR8QuaqTihnxirir7EwUHp1Axq4e3+k8jXU5K0VLbNvedv1f4EWtBonDIZm0NUr+jCcA==", - "dev": true, - "dependencies": { - "camelcase": "^3.0.0", - "cliui": "^3.2.0", - "decamelize": "^1.1.1", - "get-caller-file": "^1.0.1", - "os-locale": "^1.4.0", - "read-pkg-up": "^1.0.1", - "require-directory": "^2.1.1", - "require-main-filename": "^1.0.1", - "set-blocking": "^2.0.0", - "string-width": "^1.0.2", - "which-module": "^1.0.0", - "y18n": "^3.2.1", - "yargs-parser": "^5.0.1" - } - }, - "node_modules/yargs-parser": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-5.0.1.tgz", - "integrity": "sha512-wpav5XYiddjXxirPoCTUPbqM0PXvJ9hiBMvuJgInvo4/lAOTZzUprArw17q2O1P2+GHhbBr18/iQwjL5Z9BqfA==", - "dev": true, - "dependencies": { - "camelcase": "^3.0.0", - "object.assign": "^4.1.0" - } - } - }, - "dependencies": { - "@types/expect": { - "version": "1.20.4", - "resolved": "https://registry.npmjs.org/@types/expect/-/expect-1.20.4.tgz", - "integrity": "sha512-Q5Vn3yjTDyCMV50TB6VRIbQNxSE4OmZR86VSbGaNpfUolm0iePBB4KdEEHmxoY5sT2+2DIvXW0rvMDP2nHZ4Mg==", - "dev": true - }, - "@types/glob": { - "version": "7.2.0", - "resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.2.0.tgz", - "integrity": "sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==", - "dev": true, - "requires": { - "@types/minimatch": "*", - "@types/node": "*" - } - }, - "@types/glob-stream": { - "version": "6.1.1", - "resolved": "https://registry.npmjs.org/@types/glob-stream/-/glob-stream-6.1.1.tgz", - "integrity": "sha512-AGOUTsTdbPkRS0qDeyeS+6KypmfVpbT5j23SN8UPG63qjKXNKjXn6V9wZUr8Fin0m9l8oGYaPK8b2WUMF8xI1A==", - "dev": true, - "requires": { - "@types/glob": "*", - "@types/node": "*" - } - }, - "@types/gulp": { - "version": "4.0.9", - "resolved": "https://registry.npmjs.org/@types/gulp/-/gulp-4.0.9.tgz", - "integrity": "sha512-zzT+wfQ8uwoXjDhRK9Zkmmk09/fbLLmN/yDHFizJiEKIve85qutOnXcP/TM2sKPBTU+Jc16vfPbOMkORMUBN7Q==", - "dev": true, - "requires": { - "@types/undertaker": "*", - "@types/vinyl-fs": "*", - "chokidar": "^3.3.1" - } - }, - "@types/gulp-concat": { - "version": "0.0.32", - "resolved": "https://registry.npmjs.org/@types/gulp-concat/-/gulp-concat-0.0.32.tgz", - "integrity": "sha512-CUCFADlITzzBfBa2bdGzhKtvBr4eFh+evb+4igVbvPoO5RyPfHifmyQlZl6lM7q19+OKncRlFXDU7B4X9Ayo2g==", - "dev": true, - "requires": { - "@types/node": "*" - } - }, - "@types/gulp-header": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/@types/gulp-header/-/gulp-header-2.0.1.tgz", - "integrity": "sha512-5iQ/Lffm7h0BcdsLv9fAxaLsHOMb3ShOIyrzS90Rq4bThucy0FipK174Sqikw202zHYPNtdxlg3eCF/YUmTgVA==", - "dev": true, - "requires": { - "@types/node": "*" - } - }, - "@types/gulp-strip-comments": { - "version": "2.5.1", - "resolved": "https://registry.npmjs.org/@types/gulp-strip-comments/-/gulp-strip-comments-2.5.1.tgz", - "integrity": "sha512-N4WRbn8VX8N4L6cNy0bXqhnqJCdOadFQSYD+ncWgWWu1c7cDMD/vwV1UE31y4pmavlVf987cVPv+1EN8S1PQRA==", - "dev": true, - "requires": { - "@types/node": "*" - } - }, - "@types/minimatch": { - "version": "3.0.5", - "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.5.tgz", - "integrity": "sha512-Klz949h02Gz2uZCMGwDUSDS1YBlTdDDgbWHi+81l29tQALUtvz4rAYi5uoVhE5Lagoq6DeqAUlbrHvW/mXDgdQ==", - "dev": true - }, - "@types/node": { - "version": "17.0.32", - "resolved": "https://registry.npmjs.org/@types/node/-/node-17.0.32.tgz", - "integrity": "sha512-eAIcfAvhf/BkHcf4pkLJ7ECpBAhh9kcxRBpip9cTiO+hf+aJrsxYxBeS6OXvOd9WqNAJmavXVpZvY1rBjNsXmw==", - "dev": true - }, - "@types/undertaker": { - "version": "1.2.8", - "resolved": "https://registry.npmjs.org/@types/undertaker/-/undertaker-1.2.8.tgz", - "integrity": "sha512-gW3PRqCHYpo45XFQHJBhch7L6hytPsIe0QeLujlnFsjHPnXLhJcPdN6a9368d7aIQgH2I/dUTPFBlGeSNA3qOg==", - "dev": true, - "requires": { - "@types/node": "*", - "@types/undertaker-registry": "*", - "async-done": "~1.3.2" - } - }, - "@types/undertaker-registry": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/@types/undertaker-registry/-/undertaker-registry-1.0.1.tgz", - "integrity": "sha512-Z4TYuEKn9+RbNVk1Ll2SS4x1JeLHecolIbM/a8gveaHsW0Hr+RQMraZACwTO2VD7JvepgA6UO1A1VrbktQrIbQ==", - "dev": true - }, - "@types/vinyl": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/@types/vinyl/-/vinyl-2.0.6.tgz", - "integrity": "sha512-ayJ0iOCDNHnKpKTgBG6Q6JOnHTj9zFta+3j2b8Ejza0e4cvRyMn0ZoLEmbPrTHe5YYRlDYPvPWVdV4cTaRyH7g==", - "dev": true, - "requires": { - "@types/expect": "^1.20.4", - "@types/node": "*" - } - }, - "@types/vinyl-fs": { - "version": "2.4.12", - "resolved": "https://registry.npmjs.org/@types/vinyl-fs/-/vinyl-fs-2.4.12.tgz", - "integrity": "sha512-LgBpYIWuuGsihnlF+OOWWz4ovwCYlT03gd3DuLwex50cYZLmX3yrW+sFF9ndtmh7zcZpS6Ri47PrIu+fV+sbXw==", - "dev": true, - "requires": { - "@types/glob-stream": "*", - "@types/node": "*", - "@types/vinyl": "*" - } - }, - "abbrev": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", - "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==", - "dev": true - }, - "ansi-colors": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-1.1.0.tgz", - "integrity": "sha512-SFKX67auSNoVR38N3L+nvsPjOE0bybKTYbkf5tRvushrAPQ9V75huw0ZxBkKVeRU9kqH3d6HA4xTckbwZ4ixmA==", - "dev": true, - "requires": { - "ansi-wrap": "^0.1.0" - } - }, - "ansi-cyan": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/ansi-cyan/-/ansi-cyan-0.1.1.tgz", - "integrity": "sha1-U4rlKK+JgvKK4w2G8vF0VtJgmHM=", - "dev": true, - "requires": { - "ansi-wrap": "0.1.0" - } - }, - "ansi-gray": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/ansi-gray/-/ansi-gray-0.1.1.tgz", - "integrity": "sha1-KWLPVOyXksSFEKPetSRDaGHvclE=", - "dev": true, - "requires": { - "ansi-wrap": "0.1.0" - } - }, - "ansi-red": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/ansi-red/-/ansi-red-0.1.1.tgz", - "integrity": "sha1-jGOPnRCAgAo1PJwoyKgcpHBdlGw=", - "dev": true, - "requires": { - "ansi-wrap": "0.1.0" - } - }, - "ansi-regex": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", - "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=", - "dev": true - }, - "ansi-wrap": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/ansi-wrap/-/ansi-wrap-0.1.0.tgz", - "integrity": "sha1-qCJQ3bABXponyoLoLqYDu/pF768=", - "dev": true - }, - "anymatch": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz", - "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==", - "dev": true, - "requires": { - "normalize-path": "^3.0.0", - "picomatch": "^2.0.4" - } - }, - "append-buffer": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/append-buffer/-/append-buffer-1.0.2.tgz", - "integrity": "sha1-2CIM9GYIFSXv6lBhTz3mUU36WPE=", - "dev": true, - "requires": { - "buffer-equal": "^1.0.0" - } - }, - "archy": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/archy/-/archy-1.0.0.tgz", - "integrity": "sha1-+cjBN1fMHde8N5rHeyxipcKGjEA=", - "dev": true - }, - "arr-diff": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz", - "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=", - "dev": true - }, - "arr-filter": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/arr-filter/-/arr-filter-1.1.2.tgz", - "integrity": "sha1-Q/3d0JHo7xGqTEXZzcGOLf8XEe4=", - "dev": true, - "requires": { - "make-iterator": "^1.0.0" - } - }, - "arr-flatten": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz", - "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==", - "dev": true - }, - "arr-map": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/arr-map/-/arr-map-2.0.2.tgz", - "integrity": "sha1-Onc0X/wc814qkYJWAfnljy4kysQ=", - "dev": true, - "requires": { - "make-iterator": "^1.0.0" - } - }, - "arr-union": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-2.1.0.tgz", - "integrity": "sha1-IPnqtexw9cfSFbEHexw5Fh0pLH0=", - "dev": true - }, - "array-each": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/array-each/-/array-each-1.0.1.tgz", - "integrity": "sha1-p5SvDAWrF1KEbudTofIRoFugxE8=", - "dev": true - }, - "array-initial": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/array-initial/-/array-initial-1.1.0.tgz", - "integrity": "sha1-L6dLJnOTccOUe9enrcc74zSz15U=", - "dev": true, - "requires": { - "array-slice": "^1.0.0", - "is-number": "^4.0.0" - }, - "dependencies": { - "is-number": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz", - "integrity": "sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==", - "dev": true - } - } - }, - "array-last": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/array-last/-/array-last-1.3.0.tgz", - "integrity": "sha512-eOCut5rXlI6aCOS7Z7kCplKRKyiFQ6dHFBem4PwlwKeNFk2/XxTrhRh5T9PyaEWGy/NHTZWbY+nsZlNFJu9rYg==", - "dev": true, - "requires": { - "is-number": "^4.0.0" - }, - "dependencies": { - "is-number": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz", - "integrity": "sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==", - "dev": true - } - } - }, - "array-slice": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/array-slice/-/array-slice-1.1.0.tgz", - "integrity": "sha512-B1qMD3RBP7O8o0H2KbrXDyB0IccejMF15+87Lvlor12ONPRHP6gTjXMNkt/d3ZuOGbAe66hFmaCfECI24Ufp6w==", - "dev": true - }, - "array-sort": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/array-sort/-/array-sort-1.0.0.tgz", - "integrity": "sha512-ihLeJkonmdiAsD7vpgN3CRcx2J2S0TiYW+IS/5zHBI7mKUq3ySvBdzzBfD236ubDBQFiiyG3SWCPc+msQ9KoYg==", - "dev": true, - "requires": { - "default-compare": "^1.0.0", - "get-value": "^2.0.6", - "kind-of": "^5.0.2" - } - }, - "array-unique": { - "version": "0.3.2", - "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz", - "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=", - "dev": true - }, - "assign-symbols": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz", - "integrity": "sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=", - "dev": true - }, - "async-done": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/async-done/-/async-done-1.3.2.tgz", - "integrity": "sha512-uYkTP8dw2og1tu1nmza1n1CMW0qb8gWWlwqMmLb7MhBVs4BXrFziT6HXUd+/RlRA/i4H9AkofYloUbs1fwMqlw==", - "dev": true, - "requires": { - "end-of-stream": "^1.1.0", - "once": "^1.3.2", - "process-nextick-args": "^2.0.0", - "stream-exhaust": "^1.0.1" - } - }, - "async-each": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/async-each/-/async-each-1.0.3.tgz", - "integrity": "sha512-z/WhQ5FPySLdvREByI2vZiTWwCnF0moMJ1hK9YQwDTHKh6I7/uSckMetoRGb5UBZPC1z0jlw+n/XCgjeH7y1AQ==", - "dev": true - }, - "async-settle": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/async-settle/-/async-settle-1.0.0.tgz", - "integrity": "sha1-HQqRS7Aldb7IqPOnTlCA9yssDGs=", - "dev": true, - "requires": { - "async-done": "^1.2.2" - } - }, - "atob": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz", - "integrity": "sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==", - "dev": true - }, - "bach": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/bach/-/bach-1.2.0.tgz", - "integrity": "sha1-Szzpa/JxNPeaG0FKUcFONMO9mIA=", - "dev": true, - "requires": { - "arr-filter": "^1.1.1", - "arr-flatten": "^1.0.1", - "arr-map": "^2.0.0", - "array-each": "^1.0.0", - "array-initial": "^1.0.0", - "array-last": "^1.1.1", - "async-done": "^1.2.2", - "async-settle": "^1.0.0", - "now-and-later": "^2.0.0" - } - }, - "balanced-match": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", - "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", - "dev": true - }, - "base": { - "version": "0.11.2", - "resolved": "https://registry.npmjs.org/base/-/base-0.11.2.tgz", - "integrity": "sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==", - "dev": true, - "requires": { - "cache-base": "^1.0.1", - "class-utils": "^0.3.5", - "component-emitter": "^1.2.1", - "define-property": "^1.0.0", - "isobject": "^3.0.1", - "mixin-deep": "^1.2.0", - "pascalcase": "^0.1.1" - }, - "dependencies": { - "define-property": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", - "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", - "dev": true, - "requires": { - "is-descriptor": "^1.0.0" - } - } - } - }, - "binary-extensions": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", - "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", - "dev": true - }, - "bindings": { - "version": "1.5.0", - "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz", - "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==", - "dev": true, - "optional": true, - "requires": { - "file-uri-to-path": "1.0.0" - } - }, - "brace-expansion": { - "version": "1.1.11", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", - "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", - "dev": true, - "requires": { - "balanced-match": "^1.0.0", - "concat-map": "0.0.1" - } - }, - "braces": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", - "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", - "dev": true, - "requires": { - "fill-range": "^7.0.1" - } - }, - "buffer-equal": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/buffer-equal/-/buffer-equal-1.0.0.tgz", - "integrity": "sha1-WWFrSYME1Var1GaWayLu2j7KX74=", - "dev": true - }, - "buffer-from": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", - "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", - "dev": true - }, - "cache-base": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz", - "integrity": "sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==", - "dev": true, - "requires": { - "collection-visit": "^1.0.0", - "component-emitter": "^1.2.1", - "get-value": "^2.0.6", - "has-value": "^1.0.0", - "isobject": "^3.0.1", - "set-value": "^2.0.0", - "to-object-path": "^0.3.0", - "union-value": "^1.0.0", - "unset-value": "^1.0.0" - }, - "dependencies": { - "extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - }, - "is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==", - "dev": true - }, - "is-plain-object": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", - "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", - "dev": true, - "requires": { - "isobject": "^3.0.1" - } - }, - "set-value": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz", - "integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==", - "dev": true, - "requires": { - "extend-shallow": "^2.0.1", - "is-extendable": "^0.1.1", - "is-plain-object": "^2.0.3", - "split-string": "^3.0.1" - } - } - } - }, - "call-bind": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", - "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", - "dev": true, - "requires": { - "function-bind": "^1.1.1", - "get-intrinsic": "^1.0.2" - } - }, - "camelcase": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-3.0.0.tgz", - "integrity": "sha1-MvxLn82vhF/N9+c7uXysImHwqwo=", - "dev": true - }, - "chokidar": { - "version": "3.5.3", - "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", - "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", - "dev": true, - "requires": { - "anymatch": "~3.1.2", - "braces": "~3.0.2", - "fsevents": "~2.3.2", - "glob-parent": "~5.1.2", - "is-binary-path": "~2.1.0", - "is-glob": "~4.0.1", - "normalize-path": "~3.0.0", - "readdirp": "~3.6.0" - } - }, - "class-utils": { - "version": "0.3.6", - "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz", - "integrity": "sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==", - "dev": true, - "requires": { - "arr-union": "^3.1.0", - "define-property": "^0.2.5", - "isobject": "^3.0.0", - "static-extend": "^0.1.1" - }, - "dependencies": { - "arr-union": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz", - "integrity": "sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=", - "dev": true - }, - "define-property": { - "version": "0.2.5", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "requires": { - "is-descriptor": "^0.1.0" - } - } - } - }, - "cliui": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/cliui/-/cliui-3.2.0.tgz", - "integrity": "sha1-EgYBU3qRbSmUD5NNo7SNWFo5IT0=", - "dev": true, - "requires": { - "string-width": "^1.0.1", - "strip-ansi": "^3.0.1", - "wrap-ansi": "^2.0.0" - } - }, - "clone": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/clone/-/clone-2.1.2.tgz", - "integrity": "sha1-G39Ln1kfHo+DZwQBYANFoCiHQ18=", - "dev": true - }, - "clone-buffer": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/clone-buffer/-/clone-buffer-1.0.0.tgz", - "integrity": "sha1-4+JbIHrE5wGvch4staFnksrD3Fg=", - "dev": true - }, - "clone-stats": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/clone-stats/-/clone-stats-1.0.0.tgz", - "integrity": "sha1-s3gt/4u1R04Yuba/D9/ngvh3doA=", - "dev": true - }, - "cloneable-readable": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/cloneable-readable/-/cloneable-readable-1.1.3.tgz", - "integrity": "sha512-2EF8zTQOxYq70Y4XKtorQupqF0m49MBz2/yf5Bj+MHjvpG3Hy7sImifnqD6UA+TKYxeSV+u6qqQPawN5UvnpKQ==", - "dev": true, - "requires": { - "inherits": "^2.0.1", - "process-nextick-args": "^2.0.0", - "readable-stream": "^2.3.5" - } - }, - "code-point-at": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz", - "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=", - "dev": true - }, - "collection-map": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/collection-map/-/collection-map-1.0.0.tgz", - "integrity": "sha1-rqDwb40mx4DCt1SUOFVEsiVa8Yw=", - "dev": true, - "requires": { - "arr-map": "^2.0.2", - "for-own": "^1.0.0", - "make-iterator": "^1.0.0" - } - }, - "collection-visit": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz", - "integrity": "sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=", - "dev": true, - "requires": { - "map-visit": "^1.0.0", - "object-visit": "^1.0.0" - } - }, - "color-support": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz", - "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==", - "dev": true - }, - "commander": { - "version": "2.20.3", - "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", - "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", - "dev": true - }, - "component-emitter": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz", - "integrity": "sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==", - "dev": true - }, - "concat-map": { - "version": "0.0.1", - "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", - "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=", - "dev": true - }, - "concat-stream": { - "version": "1.6.2", - "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", - "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", - "dev": true, - "requires": { - "buffer-from": "^1.0.0", - "inherits": "^2.0.3", - "readable-stream": "^2.2.2", - "typedarray": "^0.0.6" - } - }, - "concat-with-sourcemaps": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/concat-with-sourcemaps/-/concat-with-sourcemaps-1.1.0.tgz", - "integrity": "sha512-4gEjHJFT9e+2W/77h/DS5SGUgwDaOwprX8L/gl5+3ixnzkVJJsZWDSelmN3Oilw3LNDZjZV0yqH1hLG3k6nghg==", - "dev": true, - "requires": { - "source-map": "^0.6.1" - } - }, - "config-chain": { - "version": "1.1.13", - "resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.13.tgz", - "integrity": "sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==", - "dev": true, - "requires": { - "ini": "^1.3.4", - "proto-list": "~1.2.1" - } - }, - "convert-source-map": { - "version": "1.8.0", - "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.8.0.tgz", - "integrity": "sha512-+OQdjP49zViI/6i7nIJpA8rAl4sV/JdPfU9nZs3VqOwGIgizICvuN2ru6fMd+4llL0tar18UYJXfZ/TWtmhUjA==", - "dev": true, - "requires": { - "safe-buffer": "~5.1.1" - } - }, - "copy-descriptor": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz", - "integrity": "sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=", - "dev": true - }, - "copy-props": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/copy-props/-/copy-props-2.0.5.tgz", - "integrity": "sha512-XBlx8HSqrT0ObQwmSzM7WE5k8FxTV75h1DX1Z3n6NhQ/UYYAvInWYmG06vFt7hQZArE2fuO62aihiWIVQwh1sw==", - "dev": true, - "requires": { - "each-props": "^1.3.2", - "is-plain-object": "^5.0.0" - } - }, - "core-util-is": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz", - "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==", - "dev": true - }, - "d": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/d/-/d-1.0.1.tgz", - "integrity": "sha512-m62ShEObQ39CfralilEQRjH6oAMtNCV1xJyEx5LpRYUVN+EviphDgUc/F3hnYbADmkiNs67Y+3ylmlG7Lnu+FA==", - "dev": true, - "requires": { - "es5-ext": "^0.10.50", - "type": "^1.0.1" - } - }, - "debug": { - "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", - "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", - "dev": true, - "requires": { - "ms": "2.0.0" - } - }, - "decamelize": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", - "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=", - "dev": true - }, - "decode-uri-component": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.2.tgz", - "integrity": "sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==", - "dev": true - }, - "decomment": { - "version": "0.9.5", - "resolved": "https://registry.npmjs.org/decomment/-/decomment-0.9.5.tgz", - "integrity": "sha512-h0TZ8t6Dp49duwyDHo3iw67mnh9/UpFiSSiOb5gDK1sqoXzrfX/SQxIUQd2R2QEiSnqib0KF2fnKnGfAhAs6lg==", - "dev": true, - "requires": { - "esprima": "4.0.1" - } - }, - "default-compare": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/default-compare/-/default-compare-1.0.0.tgz", - "integrity": "sha512-QWfXlM0EkAbqOCbD/6HjdwT19j7WCkMyiRhWilc4H9/5h/RzTF9gv5LYh1+CmDV5d1rki6KAWLtQale0xt20eQ==", - "dev": true, - "requires": { - "kind-of": "^5.0.2" - } - }, - "default-resolution": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/default-resolution/-/default-resolution-2.0.0.tgz", - "integrity": "sha1-vLgrqnKtebQmp2cy8aga1t8m1oQ=", - "dev": true - }, - "define-properties": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.4.tgz", - "integrity": "sha512-uckOqKcfaVvtBdsVkdPv3XjveQJsNQqmhXgRi8uhvWWuPYZCNlzT8qAyblUgNoXdHdjMTzAqeGjAoli8f+bzPA==", - "dev": true, - "requires": { - "has-property-descriptors": "^1.0.0", - "object-keys": "^1.1.1" - } - }, - "define-property": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz", - "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", - "dev": true, - "requires": { - "is-descriptor": "^1.0.2", - "isobject": "^3.0.1" - } - }, - "detect-file": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/detect-file/-/detect-file-1.0.0.tgz", - "integrity": "sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=", - "dev": true - }, - "duplexer": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz", - "integrity": "sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==", - "dev": true - }, - "duplexify": { - "version": "3.7.1", - "resolved": "https://registry.npmjs.org/duplexify/-/duplexify-3.7.1.tgz", - "integrity": "sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==", - "dev": true, - "requires": { - "end-of-stream": "^1.0.0", - "inherits": "^2.0.1", - "readable-stream": "^2.0.0", - "stream-shift": "^1.0.0" - } - }, - "each-props": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/each-props/-/each-props-1.3.2.tgz", - "integrity": "sha512-vV0Hem3zAGkJAyU7JSjixeU66rwdynTAa1vofCrSA5fEln+m67Az9CcnkVD776/fsN/UjIWmBDoNRS6t6G9RfA==", - "dev": true, - "requires": { - "is-plain-object": "^2.0.1", - "object.defaults": "^1.1.0" - }, - "dependencies": { - "is-plain-object": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", - "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", - "dev": true, - "requires": { - "isobject": "^3.0.1" - } - } - } - }, - "editorconfig": { - "version": "0.15.3", - "resolved": "https://registry.npmjs.org/editorconfig/-/editorconfig-0.15.3.tgz", - "integrity": "sha512-M9wIMFx96vq0R4F+gRpY3o2exzb8hEj/n9S8unZtHSvYjibBp/iMufSzvmOcV/laG0ZtuTVGtiJggPOSW2r93g==", - "dev": true, - "requires": { - "commander": "^2.19.0", - "lru-cache": "^4.1.5", - "semver": "^5.6.0", - "sigmund": "^1.0.1" - } - }, - "end-of-stream": { - "version": "1.4.4", - "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz", - "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==", - "dev": true, - "requires": { - "once": "^1.4.0" - } - }, - "error-ex": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", - "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", - "dev": true, - "requires": { - "is-arrayish": "^0.2.1" - } - }, - "es5-ext": { - "version": "0.10.61", - "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.61.tgz", - "integrity": "sha512-yFhIqQAzu2Ca2I4SE2Au3rxVfmohU9Y7wqGR+s7+H7krk26NXhIRAZDgqd6xqjCEFUomDEA3/Bo/7fKmIkW1kA==", - "dev": true, - "requires": { - "es6-iterator": "^2.0.3", - "es6-symbol": "^3.1.3", - "next-tick": "^1.1.0" - } - }, - "es6-iterator": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz", - "integrity": "sha1-p96IkUGgWpSwhUQDstCg+/qY87c=", - "dev": true, - "requires": { - "d": "1", - "es5-ext": "^0.10.35", - "es6-symbol": "^3.1.1" - } - }, - "es6-symbol": { - "version": "3.1.3", - "resolved": "https://registry.npmjs.org/es6-symbol/-/es6-symbol-3.1.3.tgz", - "integrity": "sha512-NJ6Yn3FuDinBaBRWl/q5X/s4koRHBrgKAu+yGI6JCBeiu3qrcbJhwT2GeR/EXVfylRk8dpQVJoLEFhK+Mu31NA==", - "dev": true, - "requires": { - "d": "^1.0.1", - "ext": "^1.1.2" - } - }, - "es6-weak-map": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/es6-weak-map/-/es6-weak-map-2.0.3.tgz", - "integrity": "sha512-p5um32HOTO1kP+w7PRnB+5lQ43Z6muuMuIMffvDN8ZB4GcnjLBV6zGStpbASIMk4DCAvEaamhe2zhyCb/QXXsA==", - "dev": true, - "requires": { - "d": "1", - "es5-ext": "^0.10.46", - "es6-iterator": "^2.0.3", - "es6-symbol": "^3.1.1" - } - }, - "esprima": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", - "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", - "dev": true - }, - "event-stream": { - "version": "3.3.5", - "resolved": "https://registry.npmjs.org/event-stream/-/event-stream-3.3.5.tgz", - "integrity": "sha512-vyibDcu5JL20Me1fP734QBH/kenBGLZap2n0+XXM7mvuUPzJ20Ydqj1aKcIeMdri1p+PU+4yAKugjN8KCVst+g==", - "dev": true, - "requires": { - "duplexer": "^0.1.1", - "from": "^0.1.7", - "map-stream": "0.0.7", - "pause-stream": "^0.0.11", - "split": "^1.0.1", - "stream-combiner": "^0.2.2", - "through": "^2.3.8" - } - }, - "expand-brackets": { - "version": "2.1.4", - "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz", - "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=", - "dev": true, - "requires": { - "debug": "^2.3.3", - "define-property": "^0.2.5", - "extend-shallow": "^2.0.1", - "posix-character-classes": "^0.1.0", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.1" - }, - "dependencies": { - "define-property": { - "version": "0.2.5", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "requires": { - "is-descriptor": "^0.1.0" - } - }, - "extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - }, - "is-accessor-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", - "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "is-data-descriptor": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", - "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "is-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", - "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", - "dev": true, - "requires": { - "is-accessor-descriptor": "^0.1.6", - "is-data-descriptor": "^0.1.4", - "kind-of": "^5.0.0" - } - }, - "is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", - "dev": true - } - } - }, - "expand-tilde": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/expand-tilde/-/expand-tilde-2.0.2.tgz", - "integrity": "sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=", - "dev": true, - "requires": { - "homedir-polyfill": "^1.0.1" - } - }, - "ext": { - "version": "1.6.0", - "resolved": "https://registry.npmjs.org/ext/-/ext-1.6.0.tgz", - "integrity": "sha512-sdBImtzkq2HpkdRLtlLWDa6w4DX22ijZLKx8BMPUuKe1c5lbN6xwQDQCxSfxBQnHZ13ls/FH0MQZx/q/gr6FQg==", - "dev": true, - "requires": { - "type": "^2.5.0" - }, - "dependencies": { - "type": { - "version": "2.6.0", - "resolved": "https://registry.npmjs.org/type/-/type-2.6.0.tgz", - "integrity": "sha512-eiDBDOmkih5pMbo9OqsqPRGMljLodLcwd5XD5JbtNB0o89xZAwynY9EdCDsJU7LtcVCClu9DvM7/0Ep1hYX3EQ==", - "dev": true - } - } - }, - "extend": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", - "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", - "dev": true - }, - "extend-shallow": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", - "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=", - "dev": true, - "requires": { - "assign-symbols": "^1.0.0", - "is-extendable": "^1.0.1" - } - }, - "extglob": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz", - "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==", - "dev": true, - "requires": { - "array-unique": "^0.3.2", - "define-property": "^1.0.0", - "expand-brackets": "^2.1.4", - "extend-shallow": "^2.0.1", - "fragment-cache": "^0.2.1", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.1" - }, - "dependencies": { - "define-property": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", - "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", - "dev": true, - "requires": { - "is-descriptor": "^1.0.0" - } - }, - "extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - }, - "is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", - "dev": true - } - } - }, - "fancy-log": { - "version": "1.3.3", - "resolved": "https://registry.npmjs.org/fancy-log/-/fancy-log-1.3.3.tgz", - "integrity": "sha512-k9oEhlyc0FrVh25qYuSELjr8oxsCoc4/LEZfg2iJJrfEk/tZL9bCoJE47gqAvI2m/AUjluCS4+3I0eTx8n3AEw==", - "dev": true, - "requires": { - "ansi-gray": "^0.1.1", - "color-support": "^1.1.3", - "parse-node-version": "^1.0.0", - "time-stamp": "^1.0.0" - } - }, - "fast-levenshtein": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-1.1.4.tgz", - "integrity": "sha1-5qdUzI8V5YmHqpy9J69m/W9OWvk=", - "dev": true - }, - "file-uri-to-path": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz", - "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==", - "dev": true, - "optional": true - }, - "fill-range": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", - "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", - "dev": true, - "requires": { - "to-regex-range": "^5.0.1" - } - }, - "find-up": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz", - "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", - "dev": true, - "requires": { - "path-exists": "^2.0.0", - "pinkie-promise": "^2.0.0" - } - }, - "findup-sync": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-3.0.0.tgz", - "integrity": "sha512-YbffarhcicEhOrm4CtrwdKBdCuz576RLdhJDsIfvNtxUuhdRet1qZcsMjqbePtAseKdAnDyM/IyXbu7PRPRLYg==", - "dev": true, - "requires": { - "detect-file": "^1.0.0", - "is-glob": "^4.0.0", - "micromatch": "^3.0.4", - "resolve-dir": "^1.0.1" - } - }, - "fined": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/fined/-/fined-1.2.0.tgz", - "integrity": "sha512-ZYDqPLGxDkDhDZBjZBb+oD1+j0rA4E0pXY50eplAAOPg2N/gUBSSk5IM1/QhPfyVo19lJ+CvXpqfvk+b2p/8Ng==", - "dev": true, - "requires": { - "expand-tilde": "^2.0.2", - "is-plain-object": "^2.0.3", - "object.defaults": "^1.1.0", - "object.pick": "^1.2.0", - "parse-filepath": "^1.0.1" - }, - "dependencies": { - "is-plain-object": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", - "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", - "dev": true, - "requires": { - "isobject": "^3.0.1" - } - } - } - }, - "flagged-respawn": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/flagged-respawn/-/flagged-respawn-1.0.1.tgz", - "integrity": "sha512-lNaHNVymajmk0OJMBn8fVUAU1BtDeKIqKoVhk4xAALB57aALg6b4W0MfJ/cUE0g9YBXy5XhSlPIpYIJ7HaY/3Q==", - "dev": true - }, - "flush-write-stream": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/flush-write-stream/-/flush-write-stream-1.1.1.tgz", - "integrity": "sha512-3Z4XhFZ3992uIq0XOqb9AreonueSYphE6oYbpt5+3u06JWklbsPkNv3ZKkP9Bz/r+1MWCaMoSQ28P85+1Yc77w==", - "dev": true, - "requires": { - "inherits": "^2.0.3", - "readable-stream": "^2.3.6" - } - }, - "for-in": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz", - "integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=", - "dev": true - }, - "for-own": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/for-own/-/for-own-1.0.0.tgz", - "integrity": "sha1-xjMy9BXO3EsE2/5wz4NklMU8tEs=", - "dev": true, - "requires": { - "for-in": "^1.0.1" - } - }, - "fragment-cache": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz", - "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=", - "dev": true, - "requires": { - "map-cache": "^0.2.2" - } - }, - "from": { - "version": "0.1.7", - "resolved": "https://registry.npmjs.org/from/-/from-0.1.7.tgz", - "integrity": "sha1-g8YK/Fi5xWmXAH7Rp2izqzA6RP4=", - "dev": true - }, - "fs-mkdirp-stream": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/fs-mkdirp-stream/-/fs-mkdirp-stream-1.0.0.tgz", - "integrity": "sha1-C3gV/DIBxqaeFNuYzgmMFpNSWes=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.11", - "through2": "^2.0.3" - } - }, - "fs.realpath": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", - "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=", - "dev": true - }, - "fsevents": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", - "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", - "dev": true, - "optional": true - }, - "function-bind": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", - "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", - "dev": true - }, - "get-caller-file": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-1.0.3.tgz", - "integrity": "sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==", - "dev": true - }, - "get-intrinsic": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz", - "integrity": "sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==", - "dev": true, - "requires": { - "function-bind": "^1.1.1", - "has": "^1.0.3", - "has-symbols": "^1.0.1" - } - }, - "get-value": { - "version": "2.0.6", - "resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz", - "integrity": "sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=", - "dev": true - }, - "glob": { - "version": "7.2.0", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz", - "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==", - "dev": true, - "requires": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" - } - }, - "glob-parent": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", - "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", - "dev": true, - "requires": { - "is-glob": "^4.0.1" - } - }, - "glob-stream": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/glob-stream/-/glob-stream-6.1.0.tgz", - "integrity": "sha1-cEXJlBOz65SIjYOrRtC0BMx73eQ=", - "dev": true, - "requires": { - "extend": "^3.0.0", - "glob": "^7.1.1", - "glob-parent": "^3.1.0", - "is-negated-glob": "^1.0.0", - "ordered-read-streams": "^1.0.0", - "pumpify": "^1.3.5", - "readable-stream": "^2.1.5", - "remove-trailing-separator": "^1.0.1", - "to-absolute-glob": "^2.0.0", - "unique-stream": "^2.0.2" - }, - "dependencies": { - "glob-parent": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-3.1.0.tgz", - "integrity": "sha512-E8Ak/2+dZY6fnzlR7+ueWvhsH1SjHr4jjss4YS/h4py44jY9MhK/VFdaZJAWDz6BbL21KeteKxFSFpq8OS5gVA==", - "dev": true, - "requires": { - "is-glob": "^3.1.0", - "path-dirname": "^1.0.0" - } - }, - "is-glob": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz", - "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=", - "dev": true, - "requires": { - "is-extglob": "^2.1.0" - } - } - } - }, - "glob-watcher": { - "version": "5.0.5", - "resolved": "https://registry.npmjs.org/glob-watcher/-/glob-watcher-5.0.5.tgz", - "integrity": "sha512-zOZgGGEHPklZNjZQaZ9f41i7F2YwE+tS5ZHrDhbBCk3stwahn5vQxnFmBJZHoYdusR6R1bLSXeGUy/BhctwKzw==", - "dev": true, - "requires": { - "anymatch": "^2.0.0", - "async-done": "^1.2.0", - "chokidar": "^2.0.0", - "is-negated-glob": "^1.0.0", - "just-debounce": "^1.0.0", - "normalize-path": "^3.0.0", - "object.defaults": "^1.1.0" - }, - "dependencies": { - "anymatch": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz", - "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==", - "dev": true, - "requires": { - "micromatch": "^3.1.4", - "normalize-path": "^2.1.1" - }, - "dependencies": { - "normalize-path": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", - "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", - "dev": true, - "requires": { - "remove-trailing-separator": "^1.0.1" - } - } - } - }, - "binary-extensions": { - "version": "1.13.1", - "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.13.1.tgz", - "integrity": "sha512-Un7MIEDdUC5gNpcGDV97op1Ywk748MpHcFTHoYs6qnj1Z3j7I53VG3nwZhKzoBZmbdRNnb6WRdFlwl7tSDuZGw==", - "dev": true - }, - "braces": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz", - "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", - "dev": true, - "requires": { - "arr-flatten": "^1.1.0", - "array-unique": "^0.3.2", - "extend-shallow": "^2.0.1", - "fill-range": "^4.0.0", - "isobject": "^3.0.1", - "repeat-element": "^1.1.2", - "snapdragon": "^0.8.1", - "snapdragon-node": "^2.0.1", - "split-string": "^3.0.2", - "to-regex": "^3.0.1" - } - }, - "chokidar": { - "version": "2.1.8", - "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-2.1.8.tgz", - "integrity": "sha512-ZmZUazfOzf0Nve7duiCKD23PFSCs4JPoYyccjUFF3aQkQadqBhfzhjkwBH2mNOG9cTBwhamM37EIsIkZw3nRgg==", - "dev": true, - "requires": { - "anymatch": "^2.0.0", - "async-each": "^1.0.1", - "braces": "^2.3.2", - "fsevents": "^1.2.7", - "glob-parent": "^3.1.0", - "inherits": "^2.0.3", - "is-binary-path": "^1.0.0", - "is-glob": "^4.0.0", - "normalize-path": "^3.0.0", - "path-is-absolute": "^1.0.0", - "readdirp": "^2.2.1", - "upath": "^1.1.1" - }, - "dependencies": { - "glob-parent": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-3.1.0.tgz", - "integrity": "sha512-E8Ak/2+dZY6fnzlR7+ueWvhsH1SjHr4jjss4YS/h4py44jY9MhK/VFdaZJAWDz6BbL21KeteKxFSFpq8OS5gVA==", - "dev": true, - "requires": { - "is-glob": "^3.1.0", - "path-dirname": "^1.0.0" - }, - "dependencies": { - "is-glob": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz", - "integrity": "sha512-UFpDDrPgM6qpnFNI+rh/p3bUaq9hKLZN8bMUWzxmcnZVS3omf4IPK+BrewlnWjO1WmUsMYuSjKh4UJuV4+Lqmw==", - "dev": true, - "requires": { - "is-extglob": "^2.1.0" - } - } - } - } - } - }, - "extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - }, - "fill-range": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz", - "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", - "dev": true, - "requires": { - "extend-shallow": "^2.0.1", - "is-number": "^3.0.0", - "repeat-string": "^1.6.1", - "to-regex-range": "^2.1.0" - } - }, - "fsevents": { - "version": "1.2.13", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.2.13.tgz", - "integrity": "sha512-oWb1Z6mkHIskLzEJ/XWX0srkpkTQ7vaopMQkyaEIoq0fmtFVxOthb8cCxeT+p3ynTdkk/RZwbgG4brR5BeWECw==", - "dev": true, - "optional": true, - "requires": { - "bindings": "^1.5.0", - "nan": "^2.12.1" - } - }, - "is-binary-path": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz", - "integrity": "sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=", - "dev": true, - "requires": { - "binary-extensions": "^1.0.0" - } - }, - "is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", - "dev": true - }, - "readdirp": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-2.2.1.tgz", - "integrity": "sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ==", - "dev": true, - "requires": { - "graceful-fs": "^4.1.11", - "micromatch": "^3.1.10", - "readable-stream": "^2.0.2" - } - }, - "to-regex-range": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz", - "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", - "dev": true, - "requires": { - "is-number": "^3.0.0", - "repeat-string": "^1.6.1" - } - } - } - }, - "global-modules": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-1.0.0.tgz", - "integrity": "sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==", - "dev": true, - "requires": { - "global-prefix": "^1.0.1", - "is-windows": "^1.0.1", - "resolve-dir": "^1.0.0" - } - }, - "global-prefix": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-1.0.2.tgz", - "integrity": "sha1-2/dDxsFJklk8ZVVoy2btMsASLr4=", - "dev": true, - "requires": { - "expand-tilde": "^2.0.2", - "homedir-polyfill": "^1.0.1", - "ini": "^1.3.4", - "is-windows": "^1.0.1", - "which": "^1.2.14" - } - }, - "glogg": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/glogg/-/glogg-1.0.2.tgz", - "integrity": "sha512-5mwUoSuBk44Y4EshyiqcH95ZntbDdTQqA3QYSrxmzj28Ai0vXBGMH1ApSANH14j2sIRtqCEyg6PfsuP7ElOEDA==", - "dev": true, - "requires": { - "sparkles": "^1.0.0" - } - }, - "graceful-fs": { - "version": "4.2.10", - "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", - "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==", - "dev": true - }, - "gulp": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/gulp/-/gulp-4.0.2.tgz", - "integrity": "sha512-dvEs27SCZt2ibF29xYgmnwwCYZxdxhQ/+LFWlbAW8y7jt68L/65402Lz3+CKy0Ov4rOs+NERmDq7YlZaDqUIfA==", - "dev": true, - "requires": { - "glob-watcher": "^5.0.3", - "gulp-cli": "^2.2.0", - "undertaker": "^1.2.1", - "vinyl-fs": "^3.0.0" - } - }, - "gulp-beautify": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/gulp-beautify/-/gulp-beautify-3.0.0.tgz", - "integrity": "sha512-Srxzb7+AQjNm+NkEVpLBfnFtN93jofVc4d4qI+N4MTPRF/vZ14jC4QA6WUZsZZZxc/oYk4bjcqQOUhmopFWlXg==", - "dev": true, - "requires": { - "js-beautify": "^1.8.8", - "through2": "^2.0.0" - } - }, - "gulp-clean": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/gulp-clean/-/gulp-clean-0.4.0.tgz", - "integrity": "sha512-DARK8rNMo4lHOFLGTiHEJdf19GuoBDHqGUaypz+fOhrvOs3iFO7ntdYtdpNxv+AzSJBx/JfypF0yEj9ks1IStQ==", - "dev": true, - "requires": { - "fancy-log": "^1.3.2", - "plugin-error": "^0.1.2", - "rimraf": "^2.6.2", - "through2": "^2.0.3", - "vinyl": "^2.1.0" - } - }, - "gulp-cli": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/gulp-cli/-/gulp-cli-2.3.0.tgz", - "integrity": "sha512-zzGBl5fHo0EKSXsHzjspp3y5CONegCm8ErO5Qh0UzFzk2y4tMvzLWhoDokADbarfZRL2pGpRp7yt6gfJX4ph7A==", - "dev": true, - "requires": { - "ansi-colors": "^1.0.1", - "archy": "^1.0.0", - "array-sort": "^1.0.0", - "color-support": "^1.1.3", - "concat-stream": "^1.6.0", - "copy-props": "^2.0.1", - "fancy-log": "^1.3.2", - "gulplog": "^1.0.0", - "interpret": "^1.4.0", - "isobject": "^3.0.1", - "liftoff": "^3.1.0", - "matchdep": "^2.0.0", - "mute-stdout": "^1.0.0", - "pretty-hrtime": "^1.0.0", - "replace-homedir": "^1.0.0", - "semver-greatest-satisfied-range": "^1.1.0", - "v8flags": "^3.2.0", - "yargs": "^7.1.0" - } - }, - "gulp-concat": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/gulp-concat/-/gulp-concat-2.6.1.tgz", - "integrity": "sha1-Yz0WyV2IUEYorQJmVmPO5aR5M1M=", - "dev": true, - "requires": { - "concat-with-sourcemaps": "^1.0.0", - "through2": "^2.0.0", - "vinyl": "^2.0.0" - } - }, - "gulp-header": { - "version": "2.0.9", - "resolved": "https://registry.npmjs.org/gulp-header/-/gulp-header-2.0.9.tgz", - "integrity": "sha512-LMGiBx+qH8giwrOuuZXSGvswcIUh0OiioNkUpLhNyvaC6/Ga8X6cfAeme2L5PqsbXMhL8o8b/OmVqIQdxprhcQ==", - "dev": true, - "requires": { - "concat-with-sourcemaps": "^1.1.0", - "lodash.template": "^4.5.0", - "map-stream": "0.0.7", - "through2": "^2.0.0" - } - }, - "gulp-minify": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/gulp-minify/-/gulp-minify-3.1.0.tgz", - "integrity": "sha512-ixF41aYg+NQikI8hpoHdEclYcQkbGdXQu1CBdHaU7Epg8H6e8d2jWXw1+rBPgYwl/XpKgjHj7NI6gkhoSNSSAg==", - "dev": true, - "requires": { - "ansi-colors": "^1.0.1", - "minimatch": "^3.0.2", - "plugin-error": "^0.1.2", - "terser": "^3.7.6", - "through2": "^2.0.3", - "vinyl": "^2.1.0" - } - }, - "gulp-strip-code": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/gulp-strip-code/-/gulp-strip-code-0.1.4.tgz", - "integrity": "sha1-75kmfyp1dFjcGmGduHJdSxcl/Ws=", - "dev": true, - "requires": { - "event-stream": "^3.1.5" - } - }, - "gulp-strip-comments": { - "version": "2.5.2", - "resolved": "https://registry.npmjs.org/gulp-strip-comments/-/gulp-strip-comments-2.5.2.tgz", - "integrity": "sha512-lb1bW7rsPWDD8f4ZPSguDvmCdjKmjr5HR4yZb9ros3sLl5AfW7oUj8KzY9/VRisT7dG8dL7hVHzNpQEVxfwZGQ==", - "dev": true, - "requires": { - "decomment": "^0.9.0", - "plugin-error": "^0.1.2", - "through2": "^2.0.3" - } - }, - "gulplog": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/gulplog/-/gulplog-1.0.0.tgz", - "integrity": "sha1-4oxNRdBey77YGDY86PnFkmIp/+U=", - "dev": true, - "requires": { - "glogg": "^1.0.0" - } - }, - "has": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", - "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", - "dev": true, - "requires": { - "function-bind": "^1.1.1" - } - }, - "has-property-descriptors": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", - "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", - "dev": true, - "requires": { - "get-intrinsic": "^1.1.1" - } - }, - "has-symbols": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", - "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", - "dev": true - }, - "has-value": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz", - "integrity": "sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=", - "dev": true, - "requires": { - "get-value": "^2.0.6", - "has-values": "^1.0.0", - "isobject": "^3.0.0" - } - }, - "has-values": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz", - "integrity": "sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=", - "dev": true, - "requires": { - "is-number": "^3.0.0", - "kind-of": "^4.0.0" - }, - "dependencies": { - "kind-of": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz", - "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "homedir-polyfill": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz", - "integrity": "sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==", - "dev": true, - "requires": { - "parse-passwd": "^1.0.0" - } - }, - "hosted-git-info": { - "version": "2.8.9", - "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz", - "integrity": "sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==", - "dev": true - }, - "inflight": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", - "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", - "dev": true, - "requires": { - "once": "^1.3.0", - "wrappy": "1" - } - }, - "inherits": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", - "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", - "dev": true - }, - "ini": { - "version": "1.3.8", - "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", - "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==", - "dev": true - }, - "interpret": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz", - "integrity": "sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==", - "dev": true - }, - "invert-kv": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/invert-kv/-/invert-kv-1.0.0.tgz", - "integrity": "sha1-EEqOSqym09jNFXqO+L+rLXo//bY=", - "dev": true - }, - "is-absolute": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-absolute/-/is-absolute-1.0.0.tgz", - "integrity": "sha512-dOWoqflvcydARa360Gvv18DZ/gRuHKi2NU/wU5X1ZFzdYfH29nkiNZsF3mp4OJ3H4yo9Mx8A/uAGNzpzPN3yBA==", - "dev": true, - "requires": { - "is-relative": "^1.0.0", - "is-windows": "^1.0.1" - } - }, - "is-accessor-descriptor": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", - "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", - "dev": true, - "requires": { - "kind-of": "^6.0.0" - }, - "dependencies": { - "kind-of": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", - "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", - "dev": true - } - } - }, - "is-arrayish": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", - "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=", - "dev": true - }, - "is-binary-path": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", - "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", - "dev": true, - "requires": { - "binary-extensions": "^2.0.0" - } - }, - "is-buffer": { - "version": "1.1.6", - "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz", - "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==", - "dev": true - }, - "is-core-module": { - "version": "2.9.0", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.9.0.tgz", - "integrity": "sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==", - "dev": true, - "requires": { - "has": "^1.0.3" - } - }, - "is-data-descriptor": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", - "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", - "dev": true, - "requires": { - "kind-of": "^6.0.0" - }, - "dependencies": { - "kind-of": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", - "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", - "dev": true - } - } - }, - "is-descriptor": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", - "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", - "dev": true, - "requires": { - "is-accessor-descriptor": "^1.0.0", - "is-data-descriptor": "^1.0.0", - "kind-of": "^6.0.2" - }, - "dependencies": { - "kind-of": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", - "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", - "dev": true - } - } - }, - "is-extendable": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", - "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", - "dev": true, - "requires": { - "is-plain-object": "^2.0.4" - }, - "dependencies": { - "is-plain-object": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", - "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", - "dev": true, - "requires": { - "isobject": "^3.0.1" - } - } - } - }, - "is-extglob": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", - "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=", - "dev": true - }, - "is-fullwidth-code-point": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", - "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", - "dev": true, - "requires": { - "number-is-nan": "^1.0.0" - } - }, - "is-glob": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", - "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", - "dev": true, - "requires": { - "is-extglob": "^2.1.1" - } - }, - "is-negated-glob": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-negated-glob/-/is-negated-glob-1.0.0.tgz", - "integrity": "sha1-aRC8pdqMleeEtXUbl2z1oQ/uNtI=", - "dev": true - }, - "is-number": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", - "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "is-plain-object": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz", - "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==", - "dev": true - }, - "is-relative": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-relative/-/is-relative-1.0.0.tgz", - "integrity": "sha512-Kw/ReK0iqwKeu0MITLFuj0jbPAmEiOsIwyIXvvbfa6QfmN9pkD1M+8pdk7Rl/dTKbH34/XBFMbgD4iMJhLQbGA==", - "dev": true, - "requires": { - "is-unc-path": "^1.0.0" - } - }, - "is-unc-path": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-unc-path/-/is-unc-path-1.0.0.tgz", - "integrity": "sha512-mrGpVd0fs7WWLfVsStvgF6iEJnbjDFZh9/emhRDcGWTduTfNHd9CHeUwH3gYIjdbwo4On6hunkztwOaAw0yllQ==", - "dev": true, - "requires": { - "unc-path-regex": "^0.1.2" - } - }, - "is-utf8": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz", - "integrity": "sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=", - "dev": true - }, - "is-valid-glob": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-valid-glob/-/is-valid-glob-1.0.0.tgz", - "integrity": "sha1-Kb8+/3Ab4tTTFdusw5vDn+j2Aao=", - "dev": true - }, - "is-windows": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz", - "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==", - "dev": true - }, - "isarray": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", - "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", - "dev": true - }, - "isexe": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", - "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=", - "dev": true - }, - "isobject": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", - "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", - "dev": true - }, - "js-beautify": { - "version": "1.14.3", - "resolved": "https://registry.npmjs.org/js-beautify/-/js-beautify-1.14.3.tgz", - "integrity": "sha512-f1ra8PHtOEu/70EBnmiUlV8nJePS58y9qKjl4JHfYWlFH6bo7ogZBz//FAZp7jDuXtYnGYKymZPlrg2I/9Zo4g==", - "dev": true, - "requires": { - "config-chain": "^1.1.13", - "editorconfig": "^0.15.3", - "glob": "^7.1.3", - "nopt": "^5.0.0" - } - }, - "json-stable-stringify-without-jsonify": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", - "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=", - "dev": true - }, - "just-debounce": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/just-debounce/-/just-debounce-1.1.0.tgz", - "integrity": "sha512-qpcRocdkUmf+UTNBYx5w6dexX5J31AKK1OmPwH630a83DdVVUIngk55RSAiIGpQyoH0dlr872VHfPjnQnK1qDQ==", - "dev": true - }, - "kind-of": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz", - "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", - "dev": true - }, - "last-run": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/last-run/-/last-run-1.1.1.tgz", - "integrity": "sha1-RblpQsF7HHnHchmCWbqUO+v4yls=", - "dev": true, - "requires": { - "default-resolution": "^2.0.0", - "es6-weak-map": "^2.0.1" - } - }, - "lazystream": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/lazystream/-/lazystream-1.0.1.tgz", - "integrity": "sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==", - "dev": true, - "requires": { - "readable-stream": "^2.0.5" - } - }, - "lcid": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/lcid/-/lcid-1.0.0.tgz", - "integrity": "sha1-MIrMr6C8SDo4Z7S28rlQYlHRuDU=", - "dev": true, - "requires": { - "invert-kv": "^1.0.0" - } - }, - "lead": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/lead/-/lead-1.0.0.tgz", - "integrity": "sha1-bxT5mje+Op3XhPVJVpDlkDRm7kI=", - "dev": true, - "requires": { - "flush-write-stream": "^1.0.2" - } - }, - "liftoff": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/liftoff/-/liftoff-3.1.0.tgz", - "integrity": "sha512-DlIPlJUkCV0Ips2zf2pJP0unEoT1kwYhiiPUGF3s/jtxTCjziNLoiVVh+jqWOWeFi6mmwQ5fNxvAUyPad4Dfog==", - "dev": true, - "requires": { - "extend": "^3.0.0", - "findup-sync": "^3.0.0", - "fined": "^1.0.1", - "flagged-respawn": "^1.0.0", - "is-plain-object": "^2.0.4", - "object.map": "^1.0.0", - "rechoir": "^0.6.2", - "resolve": "^1.1.7" - }, - "dependencies": { - "is-plain-object": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", - "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", - "dev": true, - "requires": { - "isobject": "^3.0.1" - } - } - } - }, - "load-json-file": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", - "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.2", - "parse-json": "^2.2.0", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0", - "strip-bom": "^2.0.0" - } - }, - "lodash._reinterpolate": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz", - "integrity": "sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=", - "dev": true - }, - "lodash.template": { - "version": "4.5.0", - "resolved": "https://registry.npmjs.org/lodash.template/-/lodash.template-4.5.0.tgz", - "integrity": "sha512-84vYFxIkmidUiFxidA/KjjH9pAycqW+h980j7Fuz5qxRtO9pgB7MDFTdys1N7A5mcucRiDyEq4fusljItR1T/A==", - "dev": true, - "requires": { - "lodash._reinterpolate": "^3.0.0", - "lodash.templatesettings": "^4.0.0" - } - }, - "lodash.templatesettings": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/lodash.templatesettings/-/lodash.templatesettings-4.2.0.tgz", - "integrity": "sha512-stgLz+i3Aa9mZgnjr/O+v9ruKZsPsndy7qPZOchbqk2cnTU1ZaldKK+v7m54WoKIyxiuMZTKT2H81F8BeAc3ZQ==", - "dev": true, - "requires": { - "lodash._reinterpolate": "^3.0.0" - } - }, - "lru-cache": { - "version": "4.1.5", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz", - "integrity": "sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==", - "dev": true, - "requires": { - "pseudomap": "^1.0.2", - "yallist": "^2.1.2" - } - }, - "make-iterator": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/make-iterator/-/make-iterator-1.0.1.tgz", - "integrity": "sha512-pxiuXh0iVEq7VM7KMIhs5gxsfxCux2URptUQaXo4iZZJxBAzTPOLE2BumO5dbfVYq/hBJFBR/a1mFDmOx5AGmw==", - "dev": true, - "requires": { - "kind-of": "^6.0.2" - }, - "dependencies": { - "kind-of": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", - "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", - "dev": true - } - } - }, - "map-cache": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz", - "integrity": "sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=", - "dev": true - }, - "map-stream": { - "version": "0.0.7", - "resolved": "https://registry.npmjs.org/map-stream/-/map-stream-0.0.7.tgz", - "integrity": "sha1-ih8HiW2CsQkmvTdEokIACfiJdKg=", - "dev": true - }, - "map-visit": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz", - "integrity": "sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=", - "dev": true, - "requires": { - "object-visit": "^1.0.0" - } - }, - "matchdep": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/matchdep/-/matchdep-2.0.0.tgz", - "integrity": "sha1-xvNINKDY28OzfCfui7yyfHd1WC4=", - "dev": true, - "requires": { - "findup-sync": "^2.0.0", - "micromatch": "^3.0.4", - "resolve": "^1.4.0", - "stack-trace": "0.0.10" - }, - "dependencies": { - "findup-sync": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-2.0.0.tgz", - "integrity": "sha1-kyaxSIwi0aYIhlCoaQGy2akKLLw=", - "dev": true, - "requires": { - "detect-file": "^1.0.0", - "is-glob": "^3.1.0", - "micromatch": "^3.0.4", - "resolve-dir": "^1.0.1" - } - }, - "is-glob": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz", - "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=", - "dev": true, - "requires": { - "is-extglob": "^2.1.0" - } - } - } - }, - "micromatch": { - "version": "3.1.10", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz", - "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", - "dev": true, - "requires": { - "arr-diff": "^4.0.0", - "array-unique": "^0.3.2", - "braces": "^2.3.1", - "define-property": "^2.0.2", - "extend-shallow": "^3.0.2", - "extglob": "^2.0.4", - "fragment-cache": "^0.2.1", - "kind-of": "^6.0.2", - "nanomatch": "^1.2.9", - "object.pick": "^1.3.0", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.2" - }, - "dependencies": { - "braces": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz", - "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", - "dev": true, - "requires": { - "arr-flatten": "^1.1.0", - "array-unique": "^0.3.2", - "extend-shallow": "^2.0.1", - "fill-range": "^4.0.0", - "isobject": "^3.0.1", - "repeat-element": "^1.1.2", - "snapdragon": "^0.8.1", - "snapdragon-node": "^2.0.1", - "split-string": "^3.0.2", - "to-regex": "^3.0.1" - }, - "dependencies": { - "extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - } - } - }, - "fill-range": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz", - "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", - "dev": true, - "requires": { - "extend-shallow": "^2.0.1", - "is-number": "^3.0.0", - "repeat-string": "^1.6.1", - "to-regex-range": "^2.1.0" - }, - "dependencies": { - "extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - } - } - }, - "is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==", - "dev": true - }, - "kind-of": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", - "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", - "dev": true - }, - "to-regex-range": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz", - "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", - "dev": true, - "requires": { - "is-number": "^3.0.0", - "repeat-string": "^1.6.1" - } - } - } - }, - "minimatch": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", - "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", - "dev": true, - "requires": { - "brace-expansion": "^1.1.7" - } - }, - "mixin-deep": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz", - "integrity": "sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==", - "dev": true, - "requires": { - "for-in": "^1.0.2", - "is-extendable": "^1.0.1" - } - }, - "ms": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", - "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", - "dev": true - }, - "mute-stdout": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/mute-stdout/-/mute-stdout-1.0.1.tgz", - "integrity": "sha512-kDcwXR4PS7caBpuRYYBUz9iVixUk3anO3f5OYFiIPwK/20vCzKCHyKoulbiDY1S53zD2bxUpxN/IJ+TnXjfvxg==", - "dev": true - }, - "nan": { - "version": "2.15.0", - "resolved": "https://registry.npmjs.org/nan/-/nan-2.15.0.tgz", - "integrity": "sha512-8ZtvEnA2c5aYCZYd1cvgdnU6cqwixRoYg70xPLWUws5ORTa/lnw+u4amixRS/Ac5U5mQVgp9pnlSUnbNWFaWZQ==", - "dev": true, - "optional": true - }, - "nanomatch": { - "version": "1.2.13", - "resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz", - "integrity": "sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==", - "dev": true, - "requires": { - "arr-diff": "^4.0.0", - "array-unique": "^0.3.2", - "define-property": "^2.0.2", - "extend-shallow": "^3.0.2", - "fragment-cache": "^0.2.1", - "is-windows": "^1.0.2", - "kind-of": "^6.0.2", - "object.pick": "^1.3.0", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.1" - }, - "dependencies": { - "kind-of": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", - "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", - "dev": true - } - } - }, - "next-tick": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/next-tick/-/next-tick-1.1.0.tgz", - "integrity": "sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==", - "dev": true - }, - "nopt": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz", - "integrity": "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==", - "dev": true, - "requires": { - "abbrev": "1" - } - }, - "normalize-package-data": { - "version": "2.5.0", - "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz", - "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==", - "dev": true, - "requires": { - "hosted-git-info": "^2.1.4", - "resolve": "^1.10.0", - "semver": "2 || 3 || 4 || 5", - "validate-npm-package-license": "^3.0.1" - } - }, - "normalize-path": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", - "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", - "dev": true - }, - "now-and-later": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/now-and-later/-/now-and-later-2.0.1.tgz", - "integrity": "sha512-KGvQ0cB70AQfg107Xvs/Fbu+dGmZoTRJp2TaPwcwQm3/7PteUyN2BCgk8KBMPGBUXZdVwyWS8fDCGFygBm19UQ==", - "dev": true, - "requires": { - "once": "^1.3.2" - } - }, - "number-is-nan": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz", - "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=", - "dev": true - }, - "object-copy": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz", - "integrity": "sha1-fn2Fi3gb18mRpBupde04EnVOmYw=", - "dev": true, - "requires": { - "copy-descriptor": "^0.1.0", - "define-property": "^0.2.5", - "kind-of": "^3.0.3" - }, - "dependencies": { - "define-property": { - "version": "0.2.5", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "requires": { - "is-descriptor": "^0.1.0" - } - }, - "is-accessor-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", - "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - } - }, - "is-data-descriptor": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", - "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - } - }, - "is-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", - "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", - "dev": true, - "requires": { - "is-accessor-descriptor": "^0.1.6", - "is-data-descriptor": "^0.1.4", - "kind-of": "^5.0.0" - }, - "dependencies": { - "kind-of": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz", - "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", - "dev": true - } - } - }, - "kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "object-keys": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", - "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", - "dev": true - }, - "object-visit": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz", - "integrity": "sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=", - "dev": true, - "requires": { - "isobject": "^3.0.0" - } - }, - "object.assign": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.2.tgz", - "integrity": "sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==", - "dev": true, - "requires": { - "call-bind": "^1.0.0", - "define-properties": "^1.1.3", - "has-symbols": "^1.0.1", - "object-keys": "^1.1.1" - } - }, - "object.defaults": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/object.defaults/-/object.defaults-1.1.0.tgz", - "integrity": "sha1-On+GgzS0B96gbaFtiNXNKeQ1/s8=", - "dev": true, - "requires": { - "array-each": "^1.0.1", - "array-slice": "^1.0.0", - "for-own": "^1.0.0", - "isobject": "^3.0.0" - } - }, - "object.map": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/object.map/-/object.map-1.0.1.tgz", - "integrity": "sha1-z4Plncj8wK1fQlDh94s7gb2AHTc=", - "dev": true, - "requires": { - "for-own": "^1.0.0", - "make-iterator": "^1.0.0" - } - }, - "object.pick": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz", - "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=", - "dev": true, - "requires": { - "isobject": "^3.0.1" - } - }, - "object.reduce": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/object.reduce/-/object.reduce-1.0.1.tgz", - "integrity": "sha1-b+NI8qx/oPlcpiEiZZkJaCW7A60=", - "dev": true, - "requires": { - "for-own": "^1.0.0", - "make-iterator": "^1.0.0" - } - }, - "once": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", - "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", - "dev": true, - "requires": { - "wrappy": "1" - } - }, - "ordered-read-streams": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/ordered-read-streams/-/ordered-read-streams-1.0.1.tgz", - "integrity": "sha1-d8DLN8QVJdZBZtmQ/61+xqDhNj4=", - "dev": true, - "requires": { - "readable-stream": "^2.0.1" - } - }, - "os-locale": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/os-locale/-/os-locale-1.4.0.tgz", - "integrity": "sha1-IPnxeuKe00XoveWDsT0gCYA8FNk=", - "dev": true, - "requires": { - "lcid": "^1.0.0" - } - }, - "parse-filepath": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/parse-filepath/-/parse-filepath-1.0.2.tgz", - "integrity": "sha1-pjISf1Oq89FYdvWHLz/6x2PWyJE=", - "dev": true, - "requires": { - "is-absolute": "^1.0.0", - "map-cache": "^0.2.0", - "path-root": "^0.1.1" - } - }, - "parse-json": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", - "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", - "dev": true, - "requires": { - "error-ex": "^1.2.0" - } - }, - "parse-node-version": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/parse-node-version/-/parse-node-version-1.0.1.tgz", - "integrity": "sha512-3YHlOa/JgH6Mnpr05jP9eDG254US9ek25LyIxZlDItp2iJtwyaXQb57lBYLdT3MowkUFYEV2XXNAYIPlESvJlA==", - "dev": true - }, - "parse-passwd": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/parse-passwd/-/parse-passwd-1.0.0.tgz", - "integrity": "sha1-bVuTSkVpk7I9N/QKOC1vFmao5cY=", - "dev": true - }, - "pascalcase": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz", - "integrity": "sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=", - "dev": true - }, - "path-dirname": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/path-dirname/-/path-dirname-1.0.2.tgz", - "integrity": "sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=", - "dev": true - }, - "path-exists": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz", - "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", - "dev": true, - "requires": { - "pinkie-promise": "^2.0.0" - } - }, - "path-is-absolute": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", - "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=", - "dev": true - }, - "path-parse": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", - "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", - "dev": true - }, - "path-root": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/path-root/-/path-root-0.1.1.tgz", - "integrity": "sha1-mkpoFMrBwM1zNgqV8yCDyOpHRbc=", - "dev": true, - "requires": { - "path-root-regex": "^0.1.0" - } - }, - "path-root-regex": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/path-root-regex/-/path-root-regex-0.1.2.tgz", - "integrity": "sha1-v8zcjfWxLcUsi0PsONGNcsBLqW0=", - "dev": true - }, - "path-type": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz", - "integrity": "sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.2", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0" - } - }, - "pause-stream": { - "version": "0.0.11", - "resolved": "https://registry.npmjs.org/pause-stream/-/pause-stream-0.0.11.tgz", - "integrity": "sha1-/lo0sMvOErWqaitAPuLnO2AvFEU=", - "dev": true, - "requires": { - "through": "~2.3" - } - }, - "picomatch": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", - "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", - "dev": true - }, - "pify": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", - "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", - "dev": true - }, - "pinkie": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz", - "integrity": "sha1-clVrgM+g1IqXToDnckjoDtT3+HA=", - "dev": true - }, - "pinkie-promise": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz", - "integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=", - "dev": true, - "requires": { - "pinkie": "^2.0.0" - } - }, - "plugin-error": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/plugin-error/-/plugin-error-0.1.2.tgz", - "integrity": "sha1-O5uzM1zPAPQl4HQ34ZJ2ln2kes4=", - "dev": true, - "requires": { - "ansi-cyan": "^0.1.1", - "ansi-red": "^0.1.1", - "arr-diff": "^1.0.1", - "arr-union": "^2.0.1", - "extend-shallow": "^1.1.2" - }, - "dependencies": { - "arr-diff": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-1.1.0.tgz", - "integrity": "sha1-aHwydYFjWI/vfeezb6vklesaOZo=", - "dev": true, - "requires": { - "arr-flatten": "^1.0.1", - "array-slice": "^0.2.3" - } - }, - "array-slice": { - "version": "0.2.3", - "resolved": "https://registry.npmjs.org/array-slice/-/array-slice-0.2.3.tgz", - "integrity": "sha1-3Tz7gO15c6dRF82sabC5nshhhvU=", - "dev": true - }, - "extend-shallow": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-1.1.4.tgz", - "integrity": "sha1-Gda/lN/AnXa6cR85uHLSH/TdkHE=", - "dev": true, - "requires": { - "kind-of": "^1.1.0" - } - }, - "kind-of": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-1.1.0.tgz", - "integrity": "sha1-FAo9LUGjbS78+pN3tiwk+ElaXEQ=", - "dev": true - } - } - }, - "posix-character-classes": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz", - "integrity": "sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=", - "dev": true - }, - "pretty-hrtime": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz", - "integrity": "sha1-t+PqQkNaTJsnWdmeDyAesZWALuE=", - "dev": true - }, - "process-nextick-args": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", - "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", - "dev": true - }, - "proto-list": { - "version": "1.2.4", - "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz", - "integrity": "sha1-IS1b/hMYMGpCD2QCuOJv85ZHqEk=", - "dev": true - }, - "pseudomap": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz", - "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=", - "dev": true - }, - "pump": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/pump/-/pump-2.0.1.tgz", - "integrity": "sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==", - "dev": true, - "requires": { - "end-of-stream": "^1.1.0", - "once": "^1.3.1" - } - }, - "pumpify": { - "version": "1.5.1", - "resolved": "https://registry.npmjs.org/pumpify/-/pumpify-1.5.1.tgz", - "integrity": "sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==", - "dev": true, - "requires": { - "duplexify": "^3.6.0", - "inherits": "^2.0.3", - "pump": "^2.0.0" - } - }, - "read-pkg": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz", - "integrity": "sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=", - "dev": true, - "requires": { - "load-json-file": "^1.0.0", - "normalize-package-data": "^2.3.2", - "path-type": "^1.0.0" - } - }, - "read-pkg-up": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz", - "integrity": "sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=", - "dev": true, - "requires": { - "find-up": "^1.0.0", - "read-pkg": "^1.0.0" - } - }, - "readable-stream": { - "version": "2.3.7", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz", - "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==", - "dev": true, - "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.3", - "isarray": "~1.0.0", - "process-nextick-args": "~2.0.0", - "safe-buffer": "~5.1.1", - "string_decoder": "~1.1.1", - "util-deprecate": "~1.0.1" - } - }, - "readdirp": { - "version": "3.6.0", - "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", - "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", - "dev": true, - "requires": { - "picomatch": "^2.2.1" - } - }, - "rechoir": { - "version": "0.6.2", - "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz", - "integrity": "sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=", - "dev": true, - "requires": { - "resolve": "^1.1.6" - } - }, - "regex-not": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz", - "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==", - "dev": true, - "requires": { - "extend-shallow": "^3.0.2", - "safe-regex": "^1.1.0" - } - }, - "remove-bom-buffer": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/remove-bom-buffer/-/remove-bom-buffer-3.0.0.tgz", - "integrity": "sha512-8v2rWhaakv18qcvNeli2mZ/TMTL2nEyAKRvzo1WtnZBl15SHyEhrCu2/xKlJyUFKHiHgfXIyuY6g2dObJJycXQ==", - "dev": true, - "requires": { - "is-buffer": "^1.1.5", - "is-utf8": "^0.2.1" - } - }, - "remove-bom-stream": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/remove-bom-stream/-/remove-bom-stream-1.2.0.tgz", - "integrity": "sha1-BfGlk/FuQuH7kOv1nejlaVJflSM=", - "dev": true, - "requires": { - "remove-bom-buffer": "^3.0.0", - "safe-buffer": "^5.1.0", - "through2": "^2.0.3" - } - }, - "remove-trailing-separator": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz", - "integrity": "sha1-wkvOKig62tW8P1jg1IJJuSN52O8=", - "dev": true - }, - "repeat-element": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.4.tgz", - "integrity": "sha512-LFiNfRcSu7KK3evMyYOuCzv3L10TW7yC1G2/+StMjK8Y6Vqd2MG7r/Qjw4ghtuCOjFvlnms/iMmLqpvW/ES/WQ==", - "dev": true - }, - "repeat-string": { - "version": "1.6.1", - "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz", - "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=", - "dev": true - }, - "replace-ext": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/replace-ext/-/replace-ext-1.0.1.tgz", - "integrity": "sha512-yD5BHCe7quCgBph4rMQ+0KkIRKwWCrHDOX1p1Gp6HwjPM5kVoCdKGNhN7ydqqsX6lJEnQDKZ/tFMiEdQ1dvPEw==", - "dev": true - }, - "replace-homedir": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/replace-homedir/-/replace-homedir-1.0.0.tgz", - "integrity": "sha1-6H9tUTuSjd6AgmDBK+f+xv9ueYw=", - "dev": true, - "requires": { - "homedir-polyfill": "^1.0.1", - "is-absolute": "^1.0.0", - "remove-trailing-separator": "^1.1.0" - } - }, - "require-directory": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", - "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=", - "dev": true - }, - "require-main-filename": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-1.0.1.tgz", - "integrity": "sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE=", - "dev": true - }, - "resolve": { - "version": "1.22.0", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.0.tgz", - "integrity": "sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==", - "dev": true, - "requires": { - "is-core-module": "^2.8.1", - "path-parse": "^1.0.7", - "supports-preserve-symlinks-flag": "^1.0.0" - } - }, - "resolve-dir": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/resolve-dir/-/resolve-dir-1.0.1.tgz", - "integrity": "sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=", - "dev": true, - "requires": { - "expand-tilde": "^2.0.0", - "global-modules": "^1.0.0" - } - }, - "resolve-options": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/resolve-options/-/resolve-options-1.1.0.tgz", - "integrity": "sha1-MrueOcBtZzONyTeMDW1gdFZq0TE=", - "dev": true, - "requires": { - "value-or-function": "^3.0.0" - } - }, - "resolve-url": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz", - "integrity": "sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=", - "dev": true - }, - "ret": { - "version": "0.1.15", - "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz", - "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==", - "dev": true - }, - "rimraf": { - "version": "2.7.1", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz", - "integrity": "sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==", - "dev": true, - "requires": { - "glob": "^7.1.3" - } - }, - "safe-buffer": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", - "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", - "dev": true - }, - "safe-regex": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz", - "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=", - "dev": true, - "requires": { - "ret": "~0.1.10" - } - }, - "semver": { - "version": "5.7.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", - "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", - "dev": true - }, - "semver-greatest-satisfied-range": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/semver-greatest-satisfied-range/-/semver-greatest-satisfied-range-1.1.0.tgz", - "integrity": "sha1-E+jCZYq5aRywzXEJMkAoDTb3els=", - "dev": true, - "requires": { - "sver-compat": "^1.5.0" - } - }, - "set-blocking": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", - "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=", - "dev": true - }, - "sigmund": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/sigmund/-/sigmund-1.0.1.tgz", - "integrity": "sha1-P/IfGYytIXX587eBhT/ZTQ0ZtZA=", - "dev": true - }, - "snapdragon": { - "version": "0.8.2", - "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz", - "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==", - "dev": true, - "requires": { - "base": "^0.11.1", - "debug": "^2.2.0", - "define-property": "^0.2.5", - "extend-shallow": "^2.0.1", - "map-cache": "^0.2.2", - "source-map": "^0.5.6", - "source-map-resolve": "^0.5.0", - "use": "^3.1.0" - }, - "dependencies": { - "define-property": { - "version": "0.2.5", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "requires": { - "is-descriptor": "^0.1.0" - } - }, - "extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - }, - "is-accessor-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", - "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "is-data-descriptor": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", - "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "is-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", - "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", - "dev": true, - "requires": { - "is-accessor-descriptor": "^0.1.6", - "is-data-descriptor": "^0.1.4", - "kind-of": "^5.0.0" - } - }, - "is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", - "dev": true - }, - "source-map": { - "version": "0.5.7", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", - "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", - "dev": true - } - } - }, - "snapdragon-node": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz", - "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==", - "dev": true, - "requires": { - "define-property": "^1.0.0", - "isobject": "^3.0.0", - "snapdragon-util": "^3.0.1" - }, - "dependencies": { - "define-property": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", - "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", - "dev": true, - "requires": { - "is-descriptor": "^1.0.0" - } - } - } - }, - "snapdragon-util": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz", - "integrity": "sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==", - "dev": true, - "requires": { - "kind-of": "^3.2.0" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "source-map": { - "version": "0.6.1", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", - "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", - "dev": true - }, - "source-map-resolve": { - "version": "0.5.3", - "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.3.tgz", - "integrity": "sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==", - "dev": true, - "requires": { - "atob": "^2.1.2", - "decode-uri-component": "^0.2.0", - "resolve-url": "^0.2.1", - "source-map-url": "^0.4.0", - "urix": "^0.1.0" - } - }, - "source-map-support": { - "version": "0.5.21", - "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", - "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", - "dev": true, - "requires": { - "buffer-from": "^1.0.0", - "source-map": "^0.6.0" - } - }, - "source-map-url": { - "version": "0.4.1", - "resolved": "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.1.tgz", - "integrity": "sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw==", - "dev": true - }, - "sparkles": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/sparkles/-/sparkles-1.0.1.tgz", - "integrity": "sha512-dSO0DDYUahUt/0/pD/Is3VIm5TGJjludZ0HVymmhYF6eNA53PVLhnUk0znSYbH8IYBuJdCE+1luR22jNLMaQdw==", - "dev": true - }, - "spdx-correct": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.1.tgz", - "integrity": "sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==", - "dev": true, - "requires": { - "spdx-expression-parse": "^3.0.0", - "spdx-license-ids": "^3.0.0" - } - }, - "spdx-exceptions": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz", - "integrity": "sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==", - "dev": true - }, - "spdx-expression-parse": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", - "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", - "dev": true, - "requires": { - "spdx-exceptions": "^2.1.0", - "spdx-license-ids": "^3.0.0" - } - }, - "spdx-license-ids": { - "version": "3.0.11", - "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.11.tgz", - "integrity": "sha512-Ctl2BrFiM0X3MANYgj3CkygxhRmr9mi6xhejbdO960nF6EDJApTYpn0BQnDKlnNBULKiCN1n3w9EBkHK8ZWg+g==", - "dev": true - }, - "split": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/split/-/split-1.0.1.tgz", - "integrity": "sha512-mTyOoPbrivtXnwnIxZRFYRrPNtEFKlpB2fvjSnCQUiAA6qAZzqwna5envK4uk6OIeP17CsdF3rSBGYVBsU0Tkg==", - "dev": true, - "requires": { - "through": "2" - } - }, - "split-string": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz", - "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==", - "dev": true, - "requires": { - "extend-shallow": "^3.0.0" - } - }, - "stack-trace": { - "version": "0.0.10", - "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.10.tgz", - "integrity": "sha1-VHxws0fo0ytOEI6hoqFZ5f3eGcA=", - "dev": true - }, - "static-extend": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz", - "integrity": "sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=", - "dev": true, - "requires": { - "define-property": "^0.2.5", - "object-copy": "^0.1.0" - }, - "dependencies": { - "define-property": { - "version": "0.2.5", - "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", - "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", - "dev": true, - "requires": { - "is-descriptor": "^0.1.0" - } - }, - "is-accessor-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", - "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "is-data-descriptor": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", - "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "is-descriptor": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", - "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", - "dev": true, - "requires": { - "is-accessor-descriptor": "^0.1.6", - "is-data-descriptor": "^0.1.4", - "kind-of": "^5.0.0" - } - } - } - }, - "stream-combiner": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/stream-combiner/-/stream-combiner-0.2.2.tgz", - "integrity": "sha1-rsjLrBd7Vrb0+kec7YwZEs7lKFg=", - "dev": true, - "requires": { - "duplexer": "~0.1.1", - "through": "~2.3.4" - } - }, - "stream-exhaust": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/stream-exhaust/-/stream-exhaust-1.0.2.tgz", - "integrity": "sha512-b/qaq/GlBK5xaq1yrK9/zFcyRSTNxmcZwFLGSTG0mXgZl/4Z6GgiyYOXOvY7N3eEvFRAG1bkDRz5EPGSvPYQlw==", - "dev": true - }, - "stream-shift": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.1.tgz", - "integrity": "sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==", - "dev": true - }, - "string_decoder": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", - "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", - "dev": true, - "requires": { - "safe-buffer": "~5.1.0" - } - }, - "string-width": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", - "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", - "dev": true, - "requires": { - "code-point-at": "^1.0.0", - "is-fullwidth-code-point": "^1.0.0", - "strip-ansi": "^3.0.0" - } - }, - "strip-ansi": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", - "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", - "dev": true, - "requires": { - "ansi-regex": "^2.0.0" - } - }, - "strip-bom": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz", - "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=", - "dev": true, - "requires": { - "is-utf8": "^0.2.0" - } - }, - "supports-preserve-symlinks-flag": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", - "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", - "dev": true - }, - "sver-compat": { - "version": "1.5.0", - "resolved": "https://registry.npmjs.org/sver-compat/-/sver-compat-1.5.0.tgz", - "integrity": "sha1-PPh9/rTQe0o/FIJ7wYaz/QxkXNg=", - "dev": true, - "requires": { - "es6-iterator": "^2.0.1", - "es6-symbol": "^3.1.1" - } - }, - "terser": { - "version": "3.17.0", - "resolved": "https://registry.npmjs.org/terser/-/terser-3.17.0.tgz", - "integrity": "sha512-/FQzzPJmCpjAH9Xvk2paiWrFq+5M6aVOf+2KRbwhByISDX/EujxsK+BAvrhb6H+2rtrLCHK9N01wO014vrIwVQ==", - "dev": true, - "requires": { - "commander": "^2.19.0", - "source-map": "~0.6.1", - "source-map-support": "~0.5.10" - } - }, - "through": { - "version": "2.3.8", - "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", - "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=", - "dev": true - }, - "through2": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz", - "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==", - "dev": true, - "requires": { - "readable-stream": "~2.3.6", - "xtend": "~4.0.1" - } - }, - "through2-filter": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/through2-filter/-/through2-filter-3.0.0.tgz", - "integrity": "sha512-jaRjI2WxN3W1V8/FMZ9HKIBXixtiqs3SQSX4/YGIiP3gL6djW48VoZq9tDqeCWs3MT8YY5wb/zli8VW8snY1CA==", - "dev": true, - "requires": { - "through2": "~2.0.0", - "xtend": "~4.0.0" - } - }, - "time-stamp": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/time-stamp/-/time-stamp-1.1.0.tgz", - "integrity": "sha1-dkpaEa9QVhkhsTPztE5hhofg9cM=", - "dev": true - }, - "to-absolute-glob": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/to-absolute-glob/-/to-absolute-glob-2.0.2.tgz", - "integrity": "sha1-GGX0PZ50sIItufFFt4z/fQ98hJs=", - "dev": true, - "requires": { - "is-absolute": "^1.0.0", - "is-negated-glob": "^1.0.0" - } - }, - "to-object-path": { - "version": "0.3.0", - "resolved": "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz", - "integrity": "sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=", - "dev": true, - "requires": { - "kind-of": "^3.0.2" - }, - "dependencies": { - "kind-of": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", - "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", - "dev": true, - "requires": { - "is-buffer": "^1.1.5" - } - } - } - }, - "to-regex": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz", - "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==", - "dev": true, - "requires": { - "define-property": "^2.0.2", - "extend-shallow": "^3.0.2", - "regex-not": "^1.0.2", - "safe-regex": "^1.1.0" - } - }, - "to-regex-range": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", - "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", - "dev": true, - "requires": { - "is-number": "^7.0.0" - }, - "dependencies": { - "is-number": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", - "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", - "dev": true - } - } - }, - "to-through": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/to-through/-/to-through-2.0.0.tgz", - "integrity": "sha1-/JKtq6ByZHvAtn1rA2ZKoZUJOvY=", - "dev": true, - "requires": { - "through2": "^2.0.3" - } - }, - "type": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/type/-/type-1.2.0.tgz", - "integrity": "sha512-+5nt5AAniqsCnu2cEQQdpzCAh33kVx8n0VoFidKpB1dVVLAN/F+bgVOqOJqOnEnrhp222clB5p3vUlD+1QAnfg==", - "dev": true - }, - "typedarray": { - "version": "0.0.6", - "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", - "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=", - "dev": true - }, - "unc-path-regex": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/unc-path-regex/-/unc-path-regex-0.1.2.tgz", - "integrity": "sha1-5z3T17DXxe2G+6xrCufYxqadUPo=", - "dev": true - }, - "undertaker": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/undertaker/-/undertaker-1.3.0.tgz", - "integrity": "sha512-/RXwi5m/Mu3H6IHQGww3GNt1PNXlbeCuclF2QYR14L/2CHPz3DFZkvB5hZ0N/QUkiXWCACML2jXViIQEQc2MLg==", - "dev": true, - "requires": { - "arr-flatten": "^1.0.1", - "arr-map": "^2.0.0", - "bach": "^1.0.0", - "collection-map": "^1.0.0", - "es6-weak-map": "^2.0.1", - "fast-levenshtein": "^1.0.0", - "last-run": "^1.1.0", - "object.defaults": "^1.0.0", - "object.reduce": "^1.0.0", - "undertaker-registry": "^1.0.0" - } - }, - "undertaker-registry": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/undertaker-registry/-/undertaker-registry-1.0.1.tgz", - "integrity": "sha1-XkvaMI5KiirlhPm5pDWaSZglzFA=", - "dev": true - }, - "union-value": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz", - "integrity": "sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==", - "dev": true, - "requires": { - "arr-union": "^3.1.0", - "get-value": "^2.0.6", - "is-extendable": "^0.1.1", - "set-value": "^2.0.1" - }, - "dependencies": { - "arr-union": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz", - "integrity": "sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=", - "dev": true - }, - "extend-shallow": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", - "integrity": "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==", - "dev": true, - "requires": { - "is-extendable": "^0.1.0" - } - }, - "is-extendable": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", - "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", - "dev": true - }, - "is-plain-object": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", - "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", - "dev": true, - "requires": { - "isobject": "^3.0.1" - } - }, - "set-value": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz", - "integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==", - "dev": true, - "requires": { - "extend-shallow": "^2.0.1", - "is-extendable": "^0.1.1", - "is-plain-object": "^2.0.3", - "split-string": "^3.0.1" - } - } - } - }, - "unique-stream": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/unique-stream/-/unique-stream-2.3.1.tgz", - "integrity": "sha512-2nY4TnBE70yoxHkDli7DMazpWiP7xMdCYqU2nBRO0UB+ZpEkGsSija7MvmvnZFUeC+mrgiUfcHSr3LmRFIg4+A==", - "dev": true, - "requires": { - "json-stable-stringify-without-jsonify": "^1.0.1", - "through2-filter": "^3.0.0" - } - }, - "unset-value": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz", - "integrity": "sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=", - "dev": true, - "requires": { - "has-value": "^0.3.1", - "isobject": "^3.0.0" - }, - "dependencies": { - "has-value": { - "version": "0.3.1", - "resolved": "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz", - "integrity": "sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=", - "dev": true, - "requires": { - "get-value": "^2.0.3", - "has-values": "^0.1.4", - "isobject": "^2.0.0" - }, - "dependencies": { - "isobject": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz", - "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=", - "dev": true, - "requires": { - "isarray": "1.0.0" - } - } - } - }, - "has-values": { - "version": "0.1.4", - "resolved": "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz", - "integrity": "sha1-bWHeldkd/Km5oCCJrThL/49it3E=", - "dev": true - } - } - }, - "upath": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz", - "integrity": "sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==", - "dev": true - }, - "urix": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz", - "integrity": "sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=", - "dev": true - }, - "use": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/use/-/use-3.1.1.tgz", - "integrity": "sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==", - "dev": true - }, - "util-deprecate": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", - "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=", - "dev": true - }, - "v8flags": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/v8flags/-/v8flags-3.2.0.tgz", - "integrity": "sha512-mH8etigqMfiGWdeXpaaqGfs6BndypxusHHcv2qSHyZkGEznCd/qAXCWWRzeowtL54147cktFOC4P5y+kl8d8Jg==", - "dev": true, - "requires": { - "homedir-polyfill": "^1.0.1" - } - }, - "validate-npm-package-license": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", - "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", - "dev": true, - "requires": { - "spdx-correct": "^3.0.0", - "spdx-expression-parse": "^3.0.0" - } - }, - "value-or-function": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/value-or-function/-/value-or-function-3.0.0.tgz", - "integrity": "sha1-HCQ6ULWVwb5Up1S/7OhWO5/42BM=", - "dev": true - }, - "vinyl": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/vinyl/-/vinyl-2.2.1.tgz", - "integrity": "sha512-LII3bXRFBZLlezoG5FfZVcXflZgWP/4dCwKtxd5ky9+LOtM4CS3bIRQsmR1KMnMW07jpE8fqR2lcxPZ+8sJIcw==", - "dev": true, - "requires": { - "clone": "^2.1.1", - "clone-buffer": "^1.0.0", - "clone-stats": "^1.0.0", - "cloneable-readable": "^1.0.0", - "remove-trailing-separator": "^1.0.1", - "replace-ext": "^1.0.0" - } - }, - "vinyl-fs": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/vinyl-fs/-/vinyl-fs-3.0.3.tgz", - "integrity": "sha512-vIu34EkyNyJxmP0jscNzWBSygh7VWhqun6RmqVfXePrOwi9lhvRs//dOaGOTRUQr4tx7/zd26Tk5WeSVZitgng==", - "dev": true, - "requires": { - "fs-mkdirp-stream": "^1.0.0", - "glob-stream": "^6.1.0", - "graceful-fs": "^4.0.0", - "is-valid-glob": "^1.0.0", - "lazystream": "^1.0.0", - "lead": "^1.0.0", - "object.assign": "^4.0.4", - "pumpify": "^1.3.5", - "readable-stream": "^2.3.3", - "remove-bom-buffer": "^3.0.0", - "remove-bom-stream": "^1.2.0", - "resolve-options": "^1.1.0", - "through2": "^2.0.0", - "to-through": "^2.0.0", - "value-or-function": "^3.0.0", - "vinyl": "^2.0.0", - "vinyl-sourcemap": "^1.1.0" - } - }, - "vinyl-sourcemap": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/vinyl-sourcemap/-/vinyl-sourcemap-1.1.0.tgz", - "integrity": "sha1-kqgAWTo4cDqM2xHYswCtS+Y7PhY=", - "dev": true, - "requires": { - "append-buffer": "^1.0.2", - "convert-source-map": "^1.5.0", - "graceful-fs": "^4.1.6", - "normalize-path": "^2.1.1", - "now-and-later": "^2.0.0", - "remove-bom-buffer": "^3.0.0", - "vinyl": "^2.0.0" - }, - "dependencies": { - "normalize-path": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", - "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", - "dev": true, - "requires": { - "remove-trailing-separator": "^1.0.1" - } - } - } - }, - "which": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", - "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", - "dev": true, - "requires": { - "isexe": "^2.0.0" - } - }, - "which-module": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/which-module/-/which-module-1.0.0.tgz", - "integrity": "sha1-u6Y8qGGUiZT/MHc2CJ47lgJsKk8=", - "dev": true - }, - "wrap-ansi": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz", - "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=", - "dev": true, - "requires": { - "string-width": "^1.0.1", - "strip-ansi": "^3.0.1" - } - }, - "wrappy": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", - "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=", - "dev": true - }, - "xtend": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", - "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", - "dev": true - }, - "y18n": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/y18n/-/y18n-3.2.2.tgz", - "integrity": "sha512-uGZHXkHnhF0XeeAPgnKfPv1bgKAYyVvmNL1xlKsPYZPaIHxGti2hHqvOCQv71XMsLxu1QjergkqogUnms5D3YQ==", - "dev": true - }, - "yallist": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz", - "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=", - "dev": true - }, - "yargs": { - "version": "7.1.2", - "resolved": "https://registry.npmjs.org/yargs/-/yargs-7.1.2.tgz", - "integrity": "sha512-ZEjj/dQYQy0Zx0lgLMLR8QuaqTihnxirir7EwUHp1Axq4e3+k8jXU5K0VLbNvedv1f4EWtBonDIZm0NUr+jCcA==", - "dev": true, - "requires": { - "camelcase": "^3.0.0", - "cliui": "^3.2.0", - "decamelize": "^1.1.1", - "get-caller-file": "^1.0.1", - "os-locale": "^1.4.0", - "read-pkg-up": "^1.0.1", - "require-directory": "^2.1.1", - "require-main-filename": "^1.0.1", - "set-blocking": "^2.0.0", - "string-width": "^1.0.2", - "which-module": "^1.0.0", - "y18n": "^3.2.1", - "yargs-parser": "^5.0.1" - } - }, - "yargs-parser": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-5.0.1.tgz", - "integrity": "sha512-wpav5XYiddjXxirPoCTUPbqM0PXvJ9hiBMvuJgInvo4/lAOTZzUprArw17q2O1P2+GHhbBr18/iQwjL5Z9BqfA==", - "dev": true, - "requires": { - "camelcase": "^3.0.0", - "object.assign": "^4.1.0" + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.28.1", + "@esbuild/android-arm": "0.28.1", + "@esbuild/android-arm64": "0.28.1", + "@esbuild/android-x64": "0.28.1", + "@esbuild/darwin-arm64": "0.28.1", + "@esbuild/darwin-x64": "0.28.1", + "@esbuild/freebsd-arm64": "0.28.1", + "@esbuild/freebsd-x64": "0.28.1", + "@esbuild/linux-arm": "0.28.1", + "@esbuild/linux-arm64": "0.28.1", + "@esbuild/linux-ia32": "0.28.1", + "@esbuild/linux-loong64": "0.28.1", + "@esbuild/linux-mips64el": "0.28.1", + "@esbuild/linux-ppc64": "0.28.1", + "@esbuild/linux-riscv64": "0.28.1", + "@esbuild/linux-s390x": "0.28.1", + "@esbuild/linux-x64": "0.28.1", + "@esbuild/netbsd-arm64": "0.28.1", + "@esbuild/netbsd-x64": "0.28.1", + "@esbuild/openbsd-arm64": "0.28.1", + "@esbuild/openbsd-x64": "0.28.1", + "@esbuild/openharmony-arm64": "0.28.1", + "@esbuild/sunos-x64": "0.28.1", + "@esbuild/win32-arm64": "0.28.1", + "@esbuild/win32-ia32": "0.28.1", + "@esbuild/win32-x64": "0.28.1" } } } diff --git a/package.json b/package.json index e0d316a..7fd9787 100644 --- a/package.json +++ b/package.json @@ -1,27 +1,62 @@ { "name": "@microsoft/msrcrypto", - "version": "1.6.6", + "version": "1.7.0", "description": "MSR JavaScript Cryptography Library", "license": "Apache-2.0", + "author": "Microsoft Corporation", + "homepage": "https://github.com/microsoft/MSR-JavaScript-Crypto#readme", "repository": { "type": "git", "url": "https://github.com/microsoft/MSR-JavaScript-Crypto.git" }, + "bugs": { + "url": "https://github.com/microsoft/MSR-JavaScript-Crypto/issues" + }, + "keywords": [ + "crypto", + "webcrypto", + "polyfill", + "subtlecrypto", + "aes", + "rsa", + "ecdsa", + "ecdh", + "hmac", + "sha" + ], + "main": "dist/msrcrypto.js", + "types": "types/msrCrypto.d.ts", + "exports": { + ".": { + "types": "./types/msrCrypto.d.ts", + "default": "./dist/msrcrypto.js" + }, + "./package.json": "./package.json" + }, + "sideEffects": [ + "./dist/IE11PromiseWrapper.js" + ], + "files": [ + "dist/", + "types/", + "LICENSE", + "README.md", + "SECURITY.md", + "CHANGELOG.md" + ], "scripts": { - "build": "gulp" - }, + "build": "node build.mjs", + "build:watch": "node build.mjs --watch", + "clean": "node build.mjs --clean", + "prepublishOnly": "npm run clean && npm run build" + }, "devDependencies": { - "@types/gulp": "^4.0.9", - "@types/gulp-concat": "0.0.32", - "@types/gulp-header": "^2.0.1", - "@types/gulp-strip-comments": "^2.5.1", - "gulp": "^4.0.2", - "gulp-beautify": "^3.0.0", - "gulp-clean": "^0.4.0", - "gulp-concat": "^2.6.1", - "gulp-header": "^2.0.9", - "gulp-minify": "^3.1.0", - "gulp-strip-code": "^0.1.4", - "gulp-strip-comments": "^2.5.2" + "esbuild": "^0.28.0" + }, + "publishConfig": { + "access": "public" + }, + "engines": { + "node": ">=18" } } diff --git a/scripts/curves_NUMS_old.js b/scripts/curves_NUMS_old.js deleted file mode 100644 index a92f9ba..0000000 --- a/scripts/curves_NUMS_old.js +++ /dev/null @@ -1,132 +0,0 @@ -//******************************************************************************* -// -// Copyright 2020 Microsoft -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -//******************************************************************************* - -// tslint:disable: max-line-length -// tslint:disable: variable-name - -// -// "Jac256": Weierstrass curve a=-3, E: gy:^2 = x^3 - 3x + 152961, p = 2^256-189 -// -var curve_Jac256 = { - // Curve ID, 2 x targeted security: level, order bitlength, prime bitlength - info: ["Jac256", 256, 256, 256], - // Name - name: "Jac256", - // Curve Type 0 = Weierstrass, 1 Twisted Edwards - type: 0, - // Prime p = 2^256-189 - p: [0x43, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), - // Parameter "a" - a: [0x40, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), - // Parameter "b" - b: [0x81, 0x55, 0x02].reverse(), - // Order of the group - order: [0x25, 0xa8, 0x51, 0x47, 0x29, 0x20, 0xab, 0x20, 0x60, 0x5c, 0x26, 0xea, 0x75, 0x82, 0x3c, 0xe4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), - // x(generator) - gx: [1], //, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - // gy:(generator) - gy: [0x77, 0x6c, 0xb5, 0xc2, 0x06, 0x63, 0xf4, 0x0b, 0xc1, 0x4e, 0x89, 0x75, 0x93, 0x2f, 0x2c, 0xd0, 0x6b, 0xdd, 0xee, 0xce, 0x6c, 0xc9, 0x82, 0xfc, 0xd7, 0x66, 0xe4, 0xc1, 0x53, 0x18, 0x6f, 0x69].reverse(), - // co-factor - cf: 1 -}; - -// -// "Ted256": twisted Edwards curve a=-1, E: -x^2 + gy:^2 = 1 + 15342x^2gy:^2, p = 2^256-189 -// -var curve_Ted256 = { - // Curve ID, 2 x targeted security: level, order bitlength, prime bitlength - info: ["Ted256", 256, 254, 256], - // Name - name: "Ted256", - // Curve Type 0 = Weierstrass, 1 Twisted Edwards - type: 1, - // Prime p = 2^256-189 - p: [0x43, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), - // Parameter "a" - a: [0x42, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), - // Parameter "d" - d: [0xEE, 0x3B].reverse(), - // Order of the subgroup - order: [0xad, 0xb4, 0x22, 0x11, 0x6f, 0x4e, 0xb8, 0xe5, 0x64, 0xbc, 0xa6, 0xd0, 0x5a, 0xa5, 0x6a, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f].reverse(), - // gx:(generator) - gx: [0x0D], - // gy:(generator) - gy: [0xba, 0xad, 0x1c, 0x33, 0xb5, 0x6f, 0x7f, 0x70, 0x3f, 0x30, 0x4d, 0x82, 0x63, 0x6d, 0x2a, 0xbe, 0xbf, 0x46, 0xa0, 0x9f, 0xb3, 0x30, 0xd3, 0xa3, 0xdb, 0x76, 0x12, 0x2a, 0x1e, 0xb4, 0x0a, 0x7d].reverse(), - // co-factor - cf: 4 -}; - -// -// "Jac384": Weierstrass curve a=-3, E: gy:^2 = x^3 - 3x - 34568, p = 2^384-317 -// -var curve_Jac384 = { - // Curve ID, 2 x targeted security: level, order bitlength, prime bitlength - info: ["Jac384", 384, 384, 384], - // Name - name: "Jac384", - // Curve Type 0 = Weierstrass, 1 Twisted Edwards - type: 0, - // Prime p = 2^384-317 - p: [0xC3, 0xFE, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), - // Parameter "a" - a: [0xC0, 0xFE, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), - // Parameter "b" - b: [0xBB, 0x77, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), - // Order of the group - order: [0xb9, 0x61, 0x0e, 0x7b, 0xf6, 0x81, 0x4d, 0x60, 0x7a, 0xe2, 0x37, 0x4c, 0x3d, 0x9d, 0xda, 0xbe, 0x81, 0x68, 0x5d, 0xeb, 0x1e, 0xaf, 0x1e, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), - // x(generator) - gx: [0x02], - // gy:(generator) - gy: [0x43, 0x6f, 0xa6, 0x3e, 0x50, 0xbf, 0xcb, 0x5b, 0x86, 0x0f, 0xd3, 0xd5, 0xba, 0xd0, 0xa3, 0xb4, 0xa2, 0xff, 0x15, 0x8d, 0xc5, 0x0d, 0x33, 0x73, 0x26, 0xf8, 0x04, 0x2f, 0x42, 0xed, 0x34, 0x80, 0xbd, 0x5d, 0x3e, 0x66, 0xe0, 0x63, 0xe7, 0x71, 0xdc, 0xb4, 0x87, 0x4b, 0xcb, 0x82, 0x9f, 0x3c].reverse(), - // co-factor - cf: 1 -}; - -// -// "Ted384": twisted Edwards curve a=-1, E: -x^2 + gy:^2 = 1 + 333194x^2gy:^2, p = 2^384-317 -// -var curve_Ted384 = { - // Curve ID, 2 x targeted security: level, order bitlength, prime bitlength - info: ["Ted384", 384, 382, 384], - // Name - name: "Ted384", - // Curve Type 0 = Weierstrass, 1 Twisted Edwards - type: 1, - // Prime p = 2^2^384-317 - p: [0xC3, 0xFE, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), - // Parameter "a" - a: [0xC2, 0xFE, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff].reverse(), - // Parameter "d" - d: [0x8A, 0x15, 0x05].reverse(), - // Order of the subgroup - order: [0x25, 0x6e, 0x42, 0x70, 0x1f, 0xd7, 0xd6, 0x51, 0xe4, 0xf4, 0x39, 0x8e, 0x45, 0xa0, 0x13, 0x5a, 0xa2, 0x59, 0xa2, 0xd5, 0x1e, 0xd1, 0xd7, 0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f].reverse(), - // x(generator) - gx: [0x08], - // gy:(generator) - gy: [0xee, 0x5b, 0x7f, 0xfa, 0xf5, 0xac, 0xa4, 0x34, 0xd5, 0xba, 0xba, 0xfe, 0x60, 0x38, 0x00, 0x2f, 0xd7, 0xc6, 0x53, 0xe7, 0x8a, 0x8a, 0x79, 0xbd, 0x8e, 0xff, 0x0b, 0x93, 0x4c, 0x7b, 0x5c, 0xaa, 0x9d, 0x61, 0xaa, 0x94, 0x17, 0x47, 0xd4, 0x5b, 0xb6, 0xe9, 0x6c, 0x13, 0xba, 0xda, 0x9c, 0x74].reverse(), - // co-factor - cf: 4 -}; - -if (typeof cryptoECC !== "undefined") { - // Add curves to ECC object - cryptoECC.curves["TED-256"] = curve_Ted256; - cryptoECC.curves["TED-384"] = curve_Ted384; - cryptoECC.curves["JAC-256"] = curve_Jac256; - cryptoECC.curves["JAC-384"] = curve_Jac384; -} diff --git a/scripts/kdf.js b/scripts/kdf.js deleted file mode 100644 index 941d5d8..0000000 --- a/scripts/kdf.js +++ /dev/null @@ -1,126 +0,0 @@ -//******************************************************************************* -// -// Copyright 2020 Microsoft -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -//******************************************************************************* - -/// The "concat" key derivation function from NIST SP-800-56A. -var msrcryptoKdf = function(hashFunction) { - - var utils = msrcryptoUtilities; - - function deriveKey(secretBytes, otherInfo, keyOutputLength) { - /// - /// - /// - /// - /// - - var reps = Math.ceil(keyOutputLength / (hashFunction.hashLen / 8)), - counter = 1, - digest = secretBytes.concat(otherInfo), - output = []; - - for (var i = 0; i < reps; i++) { - - var data = utils.int32ToBytes(counter++).concat(digest); - - var /*type(Array)*/ h = hashFunction.computeHash(data); - - output = output.concat(h); - } - - return output.slice(0, keyOutputLength); - } - - return { - - deriveKey: deriveKey - - }; - -}; - -var msrcryptoKdfInstance = null; - -if (typeof operations !== "undefined") { - - msrcryptoKdf.deriveKey = function(/*@dynamic*/p) { - - var utils = msrcryptoUtilities; - - var hashName = p.algorithm.hash.name; - - var hashFunction = msrcryptoHashFunctions[hashName.toUpperCase()](); - - msrcryptoKdfInstance = msrcryptoKdf(hashFunction); - - var alg = p.algorithm; - - var otherInfo = - utils.toArray(alg.algorithmId).concat( - utils.toArray(alg.partyUInfo), - utils.toArray(alg.partyVInfo), - utils.toArray(alg.publicInfo), - utils.toArray(alg.privateInfo)); - - var result = - msrcryptoKdfInstance.deriveKey(p.keyData, otherInfo, p.derivedKeyType.length); - - msrcryptoKdfInstance = null; - - return { - type: "keyDerive", - keyData: result, - keyHandle: { - algorithm: p.derivedKeyType, - extractable: p.extractable, - usages: null || p.usages, - type: "secret" - } - }; - - }; - - msrcryptoKdf.deriveBits = function(/*@dynamic*/p) { - - var hashName = p.algorithm.hash.name; - - var hashFunction = msrcryptoHashFunctions[hashName.toUpperCase()](); - - msrcryptoKdfInstance = msrcryptoKdf(hashFunction); - - var alg = p.algorithm; - - var otherInfo = - alg.algorithmId.concat( - alg.partyUInfo, - alg.partyVInfo, - alg.publicInfo || [], - alg.privateInfo || []); - - var result = - msrcryptoKdfInstance.deriveKey(p.keyData, otherInfo, p.length); - - msrcryptoKdfInstance = null; - - return result; - - }; - - operations.register("deriveKey", "concat", msrcryptoKdf.deriveKey); - operations.register("deriveBits", "concat", msrcryptoKdf.deriveBits); - -} diff --git a/scripts/subtle.js b/scripts/subtle.js deleted file mode 100644 index 4e286c7..0000000 --- a/scripts/subtle.js +++ /dev/null @@ -1,975 +0,0 @@ -//******************************************************************************* -// -// Copyright 2020 Microsoft -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -//******************************************************************************* -var msrcryptoSubtle; - -var utils = msrcryptoUtilities; - -msrcryptoSubtle = (function() { - - function syncWorker() { - var result; - - function postMessage(data) { - - try { - data.workerid = this.id; - result = msrcryptoWorker.jsCryptoRunner({ - data: data - }); - } catch (ex) { - this.onerror({ - data: ex, - type: "error" - }); - return; - } - - this.onmessage({ - data: result - }); - } - - return { - postMessage: postMessage, - onmessage: null, - onerror: null, - terminate: function() {} - }; - } - - var streamObject = function(op) { - - return { - process: function(buffer) { - return op.process(buffer); - }, - finish: function() { - return op.finish(); - }, - abort: function() { - return op.abort(); - } - }; - }; - - function baseOperation(processResults) { - - var result = null, - oncompleteCallback = null, - onerrorCallback = null, - retObj, - promise, - resolveFunc, - rejectFunc; - - promise = new Promise( - function(resolve, reject) { - resolveFunc = resolve; - rejectFunc = reject; - }); - - function opDispatchEvent(e) { - if (e.type === "error") { - if (rejectFunc) { - e.data && (e.data.stack = "Error") && (e.data.code = 0); - rejectFunc.apply(promise, [e.data || e]); - } - return; - } - - if (e.data.type === "process") { - processResults(e.data.result, true); - return; - } - - if (e.data.type === "finish") { - processResults(e.data.result, true); - return; - } - - this.result = processResults(e.data); - resolveFunc.apply(promise, [this.result]); - - return; - } - - retObj = { - dispatchEvent: opDispatchEvent, - promise: promise, - result: null - }; - - return retObj; - } - - function keyOperation() { - - function processResult(result) { - - var publicKey, - privateKey; - - switch (result.type) { - - case "keyGeneration": - case "keyImport": - case "keyDerive": - if (result.keyPair) { - keys.add(result.keyPair.publicKey.keyHandle, result.keyPair.publicKey.keyData); - keys.add(result.keyPair.privateKey.keyHandle, result.keyPair.privateKey.keyData); - return { - publicKey: result.keyPair.publicKey.keyHandle, - privateKey: result.keyPair.privateKey.keyHandle - }; - } else { - keys.add(result.keyHandle, result.keyData); - return result.keyHandle; - } - - case "keyExport": - return result.keyHandle; - - case "keyPairGeneration": - privateKey = result.keyPair.privateKey; - publicKey = result.keyPair.publicKey; - keys.add(publicKey.keyHandle, publicKey.keyData); - keys.add(privateKey.keyHandle, privateKey.keyData); - return { - publicKey: publicKey.keyHandle, - privateKey: privateKey.keyHandle - }; - - default: - throw new Error("Unknown key operation"); - } - } - - return baseOperation(processResult); - } - - function toArrayBufferIfSupported(dataArray) { - - if (typedArraySupport && dataArray.pop) { - - return (new Uint8Array(dataArray)).buffer; - } - - return dataArray; - } - - function cryptoOperation(cryptoContext) { - - function processResult(result, isProcessCall) { - - result = result && toArrayBufferIfSupported(result); - - if (isProcessCall) { - promiseQueue.resolve(result); - return; - } - - return result; - } - - var promiseQueue = [], - op = baseOperation(processResult); - - op.stream = cryptoContext.algorithm.stream; - - promiseQueue.add = function(label) { - - var resolveFunc, - rejectFunc, - promise = new Promise( - function(resolve, reject) { - resolveFunc = resolve; - rejectFunc = reject; - }); - - promise.label = label; - - promiseQueue.push({ - resolve: resolveFunc, - reject: rejectFunc, - promise: promise - }); - - return promise; - }; - - promiseQueue.resolve = function(result) { - var queueItem = promiseQueue.shift(); - queueItem.resolve.apply(queueItem.promise, [result]); - }; - - op.process = function(buffer) { - cryptoContext.operationSubType = "process"; - cryptoContext.buffer = utils.toArray(buffer); - workerManager.continueJob(this, - utils.clone(cryptoContext)); - - return promiseQueue.add("process"); - }; - - op.finish = function() { - cryptoContext.operationSubType = "finish"; - cryptoContext.buffer = []; - workerManager.continueJob(this, - utils.clone(cryptoContext)); - - return promiseQueue.add("finish"); - }; - - op.abort = function() { - workerManager.abortJob(this); - }; - op.algorithm = cryptoContext.algorithm || null; - op.key = cryptoContext.keyHandle || null; - - return op; - } - - var keys = []; - - keys.add = function(keyHandle, keyData) { - keys.push({ - keyHandle: keyHandle, - keyData: keyData - }); - }; - - keys.remove = function(keyHandle) { - for (var i = 0; i < keys.length; i += 1) { - if (keys[i].keyHandle === keyHandle) { - keys = keys.splice(i, 1); - return; - } - } - }; - - keys.lookup = function(keyHandle) { - for (var i = 0; i < keys.length; i += 1) { - if (keys[i].keyHandle === keyHandle) { - return keys[i].keyData; - } - } - return null; - }; - - var workerManager = (function() { - - var maxWorkers = 12; - - var maxFreeWorkers = 2; - - var workerPool = []; - - var jobQueue = []; - - var jobId = 0; - - var workerId = 0; - - var callbackQueue = []; - - var setFunction = typeof setImmediate === "undefined" ? setTimeout : setImmediate; - - function executeNextCallback() { - callbackQueue.shift()(); - } - - function queueCallback(callback) { - callbackQueue.push(callback); - setFunction(executeNextCallback, 0); - } - - var workerStatus = webWorkerSupport ? "available" : "unavailable"; - - function getFreeWorker() { - - purgeWorkerType(!asyncMode); - - for (var i = 0; i < workerPool.length; i++) { - if (!workerPool[i].busy) { - return workerPool[i]; - } - } - - return null; - } - - function purgeWorkerType(webWorker) { - for (var i = workerPool.length - 1; i >= 0; i -= 1) { - if (workerPool[i].isWebWorker === webWorker) { - workerPool[i].terminate(); - workerPool.splice(i, 1); - } - } - } - - function freeWorkerCount() { - var freeWorkers = 0; - for (var i = 0; i < workerPool.length; i++) { - if (!workerPool[i].busy) { - freeWorkers += 1; - } - } - return freeWorkers; - } - - function addWorkerToPool(worker) { - workerPool.push(worker); - } - - function removeWorkerFromPool(worker) { - for (var i = 0; i < workerPool.length; i++) { - if (workerPool[i] === worker) { - worker.terminate(); - workerPool.splice(i, 1); - return; - } - } - } - - function lookupWorkerByOperation(operation) { - for (var i = 0; i < workerPool.length; i++) { - if (workerPool[i].operation === operation) { - return workerPool[i]; - } - } - return null; - } - - function queueJob(operation, data) { - jobQueue.push({ - operation: operation, - data: data, - id: jobId++ - }); - } - - function jobCompleted(worker) { - - worker.busy = false; - - if (asyncMode) { - if (jobQueue.length > 0) { - - var job = jobQueue.shift(), - i; - - continueJob(job.operation, job.data); - - if (job.data.operationSubType === "process") { - for (i = 0; i < jobQueue.length; i++) { - if (job.operation === jobQueue[i].operation) { - continueJob(jobQueue[i].operation, jobQueue[i].data); - } - } - for (i = jobQueue.length - 1; i >= 0; i--) { - if (job.operation === jobQueue[i].operation) { - jobQueue.splice(i, 1); - } - } - } - } else if (freeWorkerCount() > maxFreeWorkers) { - removeWorkerFromPool(worker); - } - } - - } - - function createNewWorker(operation) { - - var worker; - - if (workerStatus === "pending") { - throw new Error("Creating new worker while workerstatus=pending"); - } - - if (workerStatus === "ready") { - try { - worker = new Worker(scriptUrl); - worker.postMessage({ - prngSeed: msrcryptoPseudoRandom.getBytes(48) - }); - worker.isWebWorker = true; - } catch (ex) { - asyncMode = false; - workerStatus = "failed"; - worker.terminate(); - worker = syncWorker(); - worker.isWebWorker = false; - } - - } else { - worker = syncWorker(); - worker.isWebWorker = false; - } - - worker.operation = operation; - - worker.id = workerId++; - - worker.busy = false; - - worker.onmessage = function(e) { - - if (e.data.initialized === true) { - return; - } - - var op = worker.operation; - - e.target || (e.target = { - data: worker.data - }); - - for (var i = 0; i < jobQueue.length; i++) { - if (jobQueue[i].operation === worker.operation) { - var job = jobQueue[i]; - jobQueue.splice(i, 1); - postMessageToWorker(worker, job.data); - return; - } - } - - if (!(e.data.hasOwnProperty("type") && e.data.type === "process")) { - jobCompleted(worker); - } - - op.dispatchEvent(e); - }; - - worker.onerror = function(e) { - - var op = worker.operation; - - jobCompleted(worker); - - op.dispatchEvent(e); - }; - - addWorkerToPool(worker); - - return worker; - } - - function useWebWorkers(enable) { - if (workerStatus === "unavailable") { - utils.consoleLog("web workers not available in this browser."); - return; - } - - if (enable === true && workerStatus === "ready") { - return; - } - - if (enable === false && workerStatus === "available") { - return; - } - - if (enable === false && workerStatus === "ready") { - asyncMode = false; - workerStatus = "available"; - utils.consoleLog("web workers disabled."); - return; - } - - if (workerStatus === "pending") { - return; - } - - workerStatus = "pending"; - - var worker = new Worker(scriptUrl); - - function setWorkerStatus(e) { - var succeeded = !!(e.data && e.data.initialized === true); - worker.removeEventListener("message", setWorkerStatus, false); - worker.removeEventListener("error", setWorkerStatus, false); - worker.terminate(); - workerStatus = succeeded ? "ready" : "failed"; - asyncMode = succeeded; - utils.consoleLog("web worker initialization " + (succeeded ? "succeeded. Now using web workers." : - "failed. running synchronously." + (e.message || ""))); - if (jobQueue.length > 0) { - var job = jobQueue.shift(); - runJob(job.operation, job.data); - } - return; - } - - worker.addEventListener("message", setWorkerStatus, false); - worker.addEventListener("error", setWorkerStatus, false); - - worker.postMessage({ - prngSeed: msrcryptoPseudoRandom.getBytes(48) - }); - - return; - } - - function abortJob(cryptoOperationObject) { - var worker = lookupWorkerByOperation(cryptoOperationObject); - if (worker) { - removeWorkerFromPool(worker); - } - } - - function runJob(operation, data) { - - var worker = null; - - if (workerStatus === "pending") { - queueJob(operation, data); - return; - } - - worker = getFreeWorker(); - - if (asyncMode && worker === null && workerPool.length >= maxWorkers) { - queueJob(operation, data); - return; - } - - if (worker === null) { - worker = createNewWorker(operation); - } - - if (worker === null) { - queueJob(operation, data); - throw new Error("could not create new worker"); - } - - worker.operation = operation; - - worker.busy = true; - - data.workerid = worker.id; - - postMessageToWorker(worker, data); - } - - function continueJob(operation, data) { - - var worker = lookupWorkerByOperation(operation); - - if (worker) { - postMessageToWorker(worker, data); - return; - } - - runJob(operation, data); - } - - function postMessageToWorker(worker, data) { - data.workerid = worker.id; - - if (asyncMode) { - - worker.postMessage(data); - - } else { - - var func = (function(postData) { - return function() { - return worker.postMessage(postData); - }; - })(data); - - queueCallback(func); - } - - return; - } - - return { - runJob: runJob, - continueJob: continueJob, - abortJob: abortJob, - useWebWorkers: useWebWorkers - }; - - })(); - - function checkOperation(operationType, algorithmName) { - if (!operations.exists(operationType, algorithmName)) { - throw new Error("unsupported algorithm"); - } - } - - var subtleParameters = [{ - name: "algorithm", - type: "Object", - required: true - }, - { - name: "keyHandle", - type: "Object", - required: true - }, - { - name: "buffer", - type: "Array", - required: false - }, - { - name: "signature", - type: "Array", - required: true - }, - { - name: "format", - type: "String", - required: true - }, - { - name: "keyData", - type: "Object", - required: true - }, - { - name: "extractable", - type: "Boolean", - required: false - }, - { - name: "usages", - type: "Array", - required: false - }, - { - name: "derivedKeyType", - type: "Object", - required: true - }, - { - name: "length", - type: "Number", - required: false - }, - { - name: "extractable", - type: "Boolean", - required: true - }, - { - name: "usages", - type: "Array", - required: true - }, - { - name: "keyData", - type: "Array", - required: true - } - ]; - - var subtleParametersSets = { - encrypt: [0, 1, 2], - decrypt: [0, 1, 2], - sign: [0, 1, 2], - verify: [0, 1, 3, 2], - digest: [0, 2], - generateKey: [0, 6, 7], - importKeyRaw: [4, 12, 0, 10, 11], - importKeyJwk: [4, 5, 0, 10, 11], - exportKey: [0, 4, 1, 6, 7], - deriveKey: [0, 1, 8, 6, 7], - deriveBits: [0, 1, 9], - wrapKey: [1, 1, 0], - unwrapKey: [2, 0, 1, 6, 7] - }; - - function lookupKeyData(handle) { - var data = keys.lookup(handle); - - if (!data) { - throw new Error("key not found"); - } - - return data; - } - - function buildParameterCollection(operationName, parameterSet) { - - var parameterCollection = { - operationType: operationName - }, - operationParameterSet, - expectedParam, - actualParam, - i; - - if (operationName === "importKey" && (parameterSet[0] === "raw" || parameterSet[0] === "spki" || parameterSet[0] === "pkcs8")) { - operationName = "importKeyRaw"; - } - - if (operationName === "importKey" && parameterSet[0] === "jwk") { - operationName = "importKeyJwk"; - } - - operationParameterSet = subtleParametersSets[operationName]; - - for (i = 0; i < operationParameterSet.length; i += 1) { - - expectedParam = subtleParameters[operationParameterSet[i]]; - actualParam = parameterSet[i]; - - if (actualParam == null) { - if (expectedParam.required) { - throw new Error(expectedParam.name); - } else { - continue; - } - } - - if (actualParam.subarray) { - actualParam = utils.toArray(actualParam); - } - - if (utils.getObjectType(actualParam) === "ArrayBuffer") { - actualParam = utils.toArray(actualParam); - } - - if (msrcryptoUtilities.getObjectType(actualParam) !== expectedParam.type) { - throw new Error(expectedParam.name); - } - - if (expectedParam.name === "algorithm") { - - actualParam.name = actualParam.name.toUpperCase(); - - if (actualParam.iv) { - actualParam.iv = utils.toArray(actualParam.iv); - } - - if (actualParam.publicExponent) { - actualParam.publicExponent = utils.toArray(actualParam.publicExponent); - } - - if (actualParam.salt) { - actualParam.salt = utils.toArray(actualParam.salt); - } - - if (actualParam.additionalData) { - actualParam.additionalData = utils.toArray(actualParam.additionalData); - } - - if (actualParam.hash && !actualParam.hash.name && utils.getObjectType(actualParam.hash) === "String") { - actualParam.hash = { - name: actualParam.hash - }; - } - } - - if (parameterCollection.hasOwnProperty(expectedParam.name)) { - parameterCollection[expectedParam.name + "1"] = actualParam; - } else { - parameterCollection[expectedParam.name] = actualParam; - } - } - - return parameterCollection; - } - - function executeOperation(operationName, parameterSet, keyFunc) { - - var pc = buildParameterCollection(operationName, parameterSet); - - checkOperation(operationName, pc.algorithm.name); - - if (pc.keyHandle) { - pc.keyData = lookupKeyData(pc.keyHandle); - } - - if (pc.keyHandle1) { - pc.keyData1 = lookupKeyData(pc.keyHandle1); - } - - if (pc.algorithm && pc.algorithm.public) { - pc.additionalKeyData = lookupKeyData(pc.algorithm.public); - } - - var op = keyFunc ? keyOperation(pc) : cryptoOperation(pc); - - if (keyFunc || pc.buffer || operationName === "deriveBits" || operationName === "wrapKey") { - workerManager.runJob(op, pc); - } - - if (op.stream) { - return Promise.resolve(streamObject(op)); - } - - return op.promise; - } - var publicMethods = { - - encrypt: function(algorithm, keyHandle, buffer) { - return executeOperation("encrypt", arguments, 0); - }, - - decrypt: function(algorithm, keyHandle, buffer) { - return executeOperation("decrypt", arguments, 0); - }, - - sign: function(algorithm, keyHandle, buffer) { - return executeOperation("sign", arguments, 0); - }, - - verify: function(algorithm, keyHandle, signature, buffer) { - return executeOperation("verify", arguments, 0); - }, - - digest: function(algorithm, buffer) { - return executeOperation("digest", arguments, 0); - }, - - generateKey: function(algorithm, extractable, keyUsage) { - return executeOperation("generateKey", arguments, 1); - }, - - deriveKey: function(algorithm, baseKey, derivedKeyType, extractable, keyUsage) { - var deriveBits = this.deriveBits, - importKey = this.importKey; - - return new Promise(function(resolve, reject) { - - var keyLength; - - switch (derivedKeyType.name.toUpperCase()) { - case "AES-CBC": - case "AES-GCM": - keyLength = derivedKeyType.length; - break; - case "HMAC": - keyLength = derivedKeyType.length || { - "SHA-1": 512, - "SHA-224": 512, - "SHA-256": 512, - "SHA-384": 1024, - "SHA-512": 1024 - } [derivedKeyType.hash.name.toUpperCase()]; - break; - default: - reject(new Error("No Supported")); - return; - } - - deriveBits(algorithm, baseKey, keyLength) - .then(function(bits) { - return importKey("raw", bits, derivedKeyType, extractable, keyUsage); - }) - .then(function(key) { - resolve(key); - })["catch"](function(err) { - reject(err); - }); - - }); - - }, - - deriveBits: function(algorithm, baseKey, length) { - return executeOperation("deriveBits", arguments, 0); - }, - - importKey: function(format, keyData, algorithm, extractable, keyUsage) { - return executeOperation("importKey", arguments, 1); - }, - - exportKey: function(format, keyHandle) { - return executeOperation("exportKey", [keyHandle.algorithm, format, keyHandle], 1); - }, - - wrapKey: function(format, key, wrappingKey, wrappingKeyAlgorithm) { - var encrypt = this.encrypt, - exportKey = this.exportKey; - - return new Promise(function(resolve, reject) { - - if (key.extractable === false || - wrappingKey.usages.indexOf("wrapKey") < 0 || - wrappingKey.algorithm.name.toUpperCase() !== wrappingKeyAlgorithm.name) { - reject(new Error("InvalidAccessError")); - return; - } - - exportKey(format, key) - - .then(function(keyData) { - - console.log(utils.toBase64(keyData)); - - return encrypt(wrappingKeyAlgorithm, wrappingKey, format === "jwk" ? - utils.stringToBytes(JSON.stringify(keyData, null, 0)) : keyData); - }) - - .then(function(cipherArrayBuffer) { - resolve(cipherArrayBuffer); - }) - - ["catch"](function(err) { - reject(err); - }); - }); - }, - - unwrapKey: function(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) { - var decrypt = this.decrypt, - importKey = this.importKey; - - return new Promise(function(resolve, reject) { - - if (unwrappingKey.usages.indexOf("unwrapKey") < 0 || - unwrappingKey.algorithm.name.toUpperCase() !== unwrapAlgorithm.name) { - reject(new Error("InvalidAccessError")); - return; - } - - decrypt(unwrapAlgorithm, unwrappingKey, wrappedKey) - - .then(function(keyPlain) { - return importKey(format, format === "jwk" ? JSON.parse(utils.bytesToString(keyPlain)) : keyPlain, - unwrappedKeyAlgorithm, extractable, keyUsages); - }) - - .then(function(key) { - resolve(key); - }) - - ["catch"](function(err) { - reject(err); - }); - }); - - } - - }; - - var internalMethods = { - useWebWorkers: workerManager.useWebWorkers - }; - - return { - publicMethods: publicMethods, - internalMethods: internalMethods - }; - -})(); \ No newline at end of file diff --git a/scripts/subtle/subtleInterface.js b/scripts/subtle/subtleInterface.js deleted file mode 100644 index b07ac3e..0000000 --- a/scripts/subtle/subtleInterface.js +++ /dev/null @@ -1,534 +0,0 @@ -//******************************************************************************* -// -// Copyright 2020 Microsoft -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -//******************************************************************************* - -function checkOperation(operationType, algorithmName) { - if (!operations.exists(operationType, algorithmName)) { - throw new Error("unsupported algorithm"); - } -} - -// The list of possible parameters passed to the subtle interface. -var subtleParameters = [ - /* 0 */ { name: "algorithm", type: "Object", required: true }, - /* 1 */ { name: "keyHandle", type: "Object", required: true }, - /* 2 */ { name: "buffer", type: "Array", required: false }, - /* 3 */ { name: "signature", type: "Array", required: true }, - /* 4 */ { name: "format", type: "String", required: true }, - /* 5 */ { name: "keyData", type: "Object", required: true }, - /* 6 */ { name: "extractable", type: "Boolean", required: false }, - /* 7 */ { name: "usages", type: "Array", required: false }, - /* 8 */ { name: "derivedKeyType", type: "Object", required: true }, - /* 9 */ { name: "length", type: "Number", required: false }, - /* 10 */ { name: "extractable", type: "Boolean", required: true }, - /* 11 */ { name: "usages", type: "Array", required: true }, - /* 12 */ { name: "keyData", type: "Array", required: true } -]; - -// The set of expected parameters passed to each subtle function. -var subtleParametersSets = { - encrypt: [0, 1, 2], - decrypt: [0, 1, 2], - sign: [0, 1, 2], - verify: [0, 1, 3, 2], - digest: [0, 2], - generateKey: [0, 6, 7], - importKeyRaw: [4, 12, 0, 10, 11], - importKeyJwk: [4, 5, 0, 10, 11], - exportKey: [0, 4, 1, 6, 7], - deriveKey: [0, 1, 8, 6, 7], - deriveBits: [0, 1, 9], - wrapKey: [1, 1, 0], - unwrapKey: [2, 0, 1, 6, 7] -}; - -// Looks up the stored key data for a given keyHandle -function lookupKeyData(handle) { - var data = keys.lookup(handle); - - if (!data) { - throw new Error("key not found"); - } - - return data; -} - -// This function processes each parameter passed by the user. Each parameter -// is compared against an expected parameter. It should be of the expected type. -// Typed-Array parameters are converted to regular Arrays. -function buildParameterCollection(operationName, parameterSet) { - - var parameterCollection = { operationType: operationName }, - operationParameterSet, - expectedParam, - actualParam, - i; - - if (operationName === "importKey" && (parameterSet[0] === "raw" || parameterSet[0] === "spki" || parameterSet[0] === "pkcs8")) { - operationName = "importKeyRaw"; - } - - if (operationName === "importKey" && parameterSet[0] === "jwk") { - operationName = "importKeyJwk"; - } - - operationParameterSet = subtleParametersSets[operationName]; - - for (i = 0; i < operationParameterSet.length; i += 1) { - - expectedParam = subtleParameters[operationParameterSet[i]]; - actualParam = parameterSet[i]; - - // Verify the required parameters are present. - if (actualParam == null) { - if (expectedParam.required) { - throw new Error(expectedParam.name); - } else { - continue; - } - } - - // If this parameter is a typed-array convert it to a regular array. - if (actualParam.subarray) { - actualParam = utils.toArray(actualParam); - } - - // If this parameter is an ArrayBuffer convert it to a regular array. - if (utils.getObjectType(actualParam) === "ArrayBuffer") { - actualParam = utils.toArray(actualParam); - } - - // Verify the actual parameter is of the expected type. - if (msrcryptoUtilities.getObjectType(actualParam) !== expectedParam.type) { - throw new Error(expectedParam.name); - } - - // If this parameter is an algorithm object convert it's name to upperCase. - if (expectedParam.name === "algorithm") { - - actualParam.name = actualParam.name.toUpperCase(); - - // If the algorithm has a typed-array IV, convert it to a regular array. - if (actualParam.iv) { - actualParam.iv = utils.toArray(actualParam.iv); - } - - // If the algorithm has a typed-array publicExponent, convert it to a regular array. - if (actualParam.publicExponent) { - actualParam.publicExponent = utils.toArray(actualParam.publicExponent); - } - - // If the algorithm has a typed-array Salt, convert it to a regular array. - if (actualParam.salt) { - actualParam.salt = utils.toArray(actualParam.salt); - } - - // If the algorithm has a typed-array AdditionalData, convert it to a regular array. - if (actualParam.additionalData) { - actualParam.additionalData = utils.toArray(actualParam.additionalData); - } - - // If this algorithm has a hash property in the form 'hash: hashName' - // Convert it to hash: {name: hashName} as per the W3C spec. - if (actualParam.hash && !actualParam.hash.name && utils.getObjectType(actualParam.hash) === "String") { - actualParam.hash = { name: actualParam.hash }; - } - } - - // KeyWrap has two keyHandle parameters. We add '1' to the second param name - // to avoid a duplicate name. - if (parameterCollection.hasOwnProperty(expectedParam.name)) { - parameterCollection[expectedParam.name + "1"] = actualParam; - } else { - parameterCollection[expectedParam.name] = actualParam; - } - } - - return parameterCollection; -} - -function executeOperation(operationName, parameterSet, keyFunc) { - - var pc = buildParameterCollection(operationName, parameterSet); - - // Verify this type of operation is supported by this library (encrypt, digest, etc...) - checkOperation(operationName, pc.algorithm.name); - - // Add the key data to the parameter object - if (pc.keyHandle) { - pc.keyData = lookupKeyData(pc.keyHandle); - } - - // Add the key data to the parameter object - // KeyWrap has two keyHandle parameters - this handles the second key. - if (pc.keyHandle1) { - pc.keyData1 = lookupKeyData(pc.keyHandle1); - } - - // ECDH.DeriveBits passes a public key in the algorithm - if (pc.algorithm && pc.algorithm.public) { - pc.additionalKeyData = lookupKeyData(pc.algorithm.public); - } - - var op = keyFunc ? keyOperation(pc) : cryptoOperation(pc); - - // Run the crypto now if a buffer is supplied - // else wait until process() and finish() are called. - if (keyFunc || pc.buffer || operationName === "deriveBits" || operationName === "wrapKey") { - workerManager.runJob(op, pc); - } - - if (op.stream) { - // This is streaming operation. A streamObject will be returned to the promise now. - return Promise.resolve(streamObject(op)); - } - - return op.promise; -} -var publicMethods = { - - encrypt: function(algorithm, keyHandle, buffer) { - /// - /// Encrypt a UInt8Array of data. Encrypt will return an ArrayBuffer if supported, - /// otherwise it will return a regular Array. - /// - /// - /// UInt8Array - /// - /// - /// - /// Encrypt an array of bytes. Encrypt will return an ArrayBuffer if supported, - /// otherwise it will return a regular Array. - /// - /// - /// An array of bytes (number from 0-255) - /// - /// - /// - /// Encrypt an array of bytes. Encrypt will return an ArrayBuffer if supported, - /// otherwise it will return a regular Array. - /// - /// - /// an array of bytes (number from 0-255) - /// - /// - - return executeOperation("encrypt", arguments, 0); - }, - - decrypt: function(algorithm, keyHandle, buffer) { - /// - /// Decrypt a UInt8Array of data. - /// Decrypt will return an ArrayBuffer if supported, otherwise it will return an Array of byte - /// values(numbers from 0 - 255) - /// - /// - /// UInt8Array - /// - /// - /// - /// Decrypt an array of byte values. Decrypt will return an ArrayBuffer if supported, - /// otherwise it will return a regular Array. - /// - /// - /// An array of bytes values (numbers from 0-255) - /// - /// - - return executeOperation("decrypt", arguments, 0); - }, - - sign: function(algorithm, keyHandle, buffer) { - /// - /// Sign a UInt8Array of data. - /// Sign will return a signature as an ArrayBuffer if supported, - /// otherwise it will return an Array of byte values (numbers from 0-255) - /// - /// - /// UInt8Array - /// - /// - /// - /// Sign an array of byte values. Sign will return an ArrayBuffer if supported, - /// otherwise it will return a regular Array. - /// - /// - /// An array of bytes values (numbers from 0-255) - /// - /// - - return executeOperation("sign", arguments, 0); - }, - - verify: function(algorithm, keyHandle, signature, buffer) { - /// - /// Verify a signature. - /// - /// - /// UInt8Array - /// UInt8Array - /// - /// - /// - /// Verify a signature. - /// - /// - /// UInt8Array - /// An array of bytes values (numbers from 0-255) - /// - /// - /// - /// Verify a signature. - /// - /// - /// An array of bytes values (numbers from 0-255) - /// An array of bytes values (numbers from 0-255) - /// - /// - /// - /// Verify a signature. - /// - /// - /// An array of bytes values (numbers from 0-255) - /// UInt8Array - /// - /// - - return executeOperation("verify", arguments, 0); - }, - - digest: function(algorithm, buffer) { - /// - /// Digest data using a specified cryptographic hash algorithm - /// - /// UInt8Array - /// - /// - /// - /// Digest data using a specified cryptographic hash algorithm - /// - /// An array of bytes values (numbers from 0-255) - /// - /// - return executeOperation("digest", arguments, 0); - }, - - generateKey: function(algorithm, extractable, keyUsage) { - /// - /// Generate a new key for use with the algorithm specified by the algorithm parameter - /// - /// - /// - /// - /// - - return executeOperation("generateKey", arguments, 1); - }, - - deriveKey: function(algorithm, baseKey, derivedKeyType, extractable, keyUsage) { - /// - /// Generate a key for the specified derivedKeyType, using the specified cryptographic - /// key derivation algorithm with the given baseKey as input. - /// - /// - /// - /// - /// - /// - /// - - var deriveBits = this.deriveBits, - importKey = this.importKey; - - return new Promise(function(resolve, reject) { - - var keyLength; - - switch (derivedKeyType.name.toUpperCase()) { - case "AES-CBC": - case "AES-GCM": - keyLength = derivedKeyType.length; - break; - case "HMAC": - keyLength = derivedKeyType.length || // HMAC length defaults to hash block size - { "SHA-1": 512, "SHA-224": 512, "SHA-256": 512, "SHA-384": 1024, "SHA-512": 1024 }[derivedKeyType.hash.name.toUpperCase()]; - break; - default: - reject(new Error("No Supported")); - return; - } - - deriveBits(algorithm, baseKey, keyLength) - .then(function(bits) { - return importKey("raw", bits, derivedKeyType, extractable, keyUsage); - }) - .then(function(key) { - resolve(key); - }) - // tslint:disable-next-line: no-string-literal - ["catch"](function(err) { - reject(err); - }); - - }); - - }, - - deriveBits: function(algorithm, baseKey, length) { - /// - /// Generate an array of bytes from a given baseKey as input. - /// - /// - /// Number of bits to return. - /// - /// - - return executeOperation("deriveBits", arguments, 0); - }, - - importKey: function(format, keyData, algorithm, extractable, keyUsage) { - /// - /// Constructs a new Key object using the key data specified by the keyData parameter. - /// - /// An object representing a key in jwk format. - /// - /// - /// - /// - /// - return executeOperation("importKey", arguments, 1); - }, - - exportKey: function(format, keyHandle) { - /// - /// Exports the given key material of the Key object as specified by the key parameter. - /// - /// - /// - /// - - // Export is one of the few calls where the caller does not supply an algorithm - // since it's already a property of the key to be exported. - // So, we're pulling it out of the key and adding it to the parameter set since - // it is used as a switch to route the parameters to the right function. - // Now we don't have to treat this as a special case in the underlying code. - return executeOperation("exportKey", [keyHandle.algorithm, format, keyHandle], 1); - }, - - wrapKey: function(format, key, wrappingKey, wrappingKeyAlgorithm) { - /// - /// Returns a KeyOperation object which will asynchronously return an array containing the - /// key material of key, encrypted with keyEncryptionKey using the specified - /// keyWrappingAlgorithm. - /// - /// - /// - /// - /// - /// - - var encrypt = this.encrypt, - exportKey = this.exportKey; - - return new Promise(function(resolve, reject) { - - if (key.extractable === false || - wrappingKey.usages.indexOf("wrapKey") < 0 || - wrappingKey.algorithm.name.toUpperCase() !== wrappingKeyAlgorithm.name) { - reject(new Error("InvalidAccessError")); - return; - } - - exportKey(format, key) - - .then(function(keyData) { - - console.log(utils.toBase64(keyData)); - - return encrypt(wrappingKeyAlgorithm, wrappingKey, format === "jwk" ? - utils.stringToBytes(JSON.stringify(keyData, null, 0)) : keyData); - }) - - .then(function(cipherArrayBuffer) { - resolve(cipherArrayBuffer); - }) - - // tslint:disable-next-line: no-string-literal - ["catch"](function(err) { - reject(err); - }); - }); - }, - - unwrapKey: function(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) { - //format, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable and keyUsages - /// - /// Construct a Key object from encrypted key material. - /// - /// An array of bytes values (numbers from 0-255) - /// - /// - /// - /// - /// - /// - /// - /// Construct a Key object from encrypted key material. - /// - /// - /// - /// - /// - /// - /// - /// - - var decrypt = this.decrypt, - importKey = this.importKey; - - return new Promise(function(resolve, reject) { - - if (unwrappingKey.usages.indexOf("unwrapKey") < 0 || - unwrappingKey.algorithm.name.toUpperCase() !== unwrapAlgorithm.name) { - reject(new Error("InvalidAccessError")); - return; - } - - decrypt(unwrapAlgorithm, unwrappingKey, wrappedKey) - - .then(function(keyPlain) { - return importKey(format, format === "jwk" ? JSON.parse(utils.bytesToString(keyPlain)) : keyPlain, - unwrappedKeyAlgorithm, extractable, keyUsages); - }) - - .then(function(key) { - resolve(key); - }) - - // tslint:disable-next-line: no-string-literal - ["catch"](function(err) { - reject(err); - }); - }); - - } - -}; - -var internalMethods = { - useWebWorkers: workerManager.useWebWorkers -}; diff --git a/scripts/testInterface.js b/scripts/testInterface.js deleted file mode 100644 index e8f9415..0000000 --- a/scripts/testInterface.js +++ /dev/null @@ -1,34 +0,0 @@ -//******************************************************************************* -// -// Copyright 2020 Microsoft -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -//******************************************************************************* - -var testInterface = (function() { - - return { - cryptoMath: cryptoMath, - rsa: msrcryptoRsa, - hashFunctions : msrcryptoHashFunctions, - sha1: msrcryptoSha1.sha1, - sha256: msrcryptoSha256.sha256, - cryptoECC: cryptoECC, - utilities: msrcryptoUtilities, - entropy: MsrcryptoEntropy, - random: msrcryptoPseudoRandom, - ecdsa: msrcryptoEcdsa - }; - -})(); diff --git a/scripts/tests/Test.WrapKey.js b/scripts/tests/Test.WrapKey.js deleted file mode 100644 index 24f88c5..0000000 --- a/scripts/tests/Test.WrapKey.js +++ /dev/null @@ -1,203 +0,0 @@ -//******************************************************************************* -// -// Copyright 2020 Microsoft -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -//******************************************************************************* - -// #region WrapKey - -QUnit.module("Wrap Key"); - -/// Wrap an AES-CBC key with a RSA-OAEP key using msrCrypto -/// then unwrap the key using IE11 msCrypto - -if (typeof msCrypto !== "undefined") { // msCrypto is only defined in IE - - var ieCrypto = crypto; - - asyncTest("JS to IE OAEP/AES-GCM", function() { - - var encryptedData, - encryptedData1; - - // Generate encryptionKey: - msrCrypto.subtle.generateKey({ name: "Aes-CBC", length: 128 }, true, ["sign", "verify"]).then( - - function(encryptionKey) { - - msrCrypto.subtle.encrypt( - { - name: "Aes-CBC", - iv: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] - }, encryptionKey, [1, 2, 3]).then( - - function(e) { - - encryptedData = shared.getArrayResult(e); - - shared.getRsaKeyPair( - { name: "rSa-OAEP", modulusLength: 1024 }, - function(keyPair) { - - var publicKey = keyPair.keyHandlePublic; - var privateKey = keyPair.keyHandlePrivateIE; - - msrCrypto.subtle.wrapKey( - encryptionKey, - publicKey, - { name: "Aes-GCM" }).then( - - function(wrappedKeyData) { - - var key = wrappedKeyData; - - if (msrCrypto) { - wrappedKeyData = JSON.stringify(wrappedKeyData); - wrappedKeyData = shared.toBase64(wrappedKeyData); - key = shared.base64ToBytes(wrappedKeyData); - } - - var cryptoObj = ieCrypto.subtle.unwrapKey( - //new Uint8Array(wrappedKeyData), - key, - { name: "Aes-CBC" }, - privateKey, true, ["encrypt", "decrypt"]); - - cryptoObj.oncomplete = - - function(e0) { - - var unwrappedEncryptionKey = e0.target.result; - - var encryptObj = ieCrypto.subtle.encrypt( - { - name: "Aes-CBC", - iv: new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15]) - }, unwrappedEncryptionKey, new Uint8Array([1, 2, 3])); - - encryptObj.oncomplete = - - function(e1) { - start(); - encryptedData1 = shared.getArrayResult(e1.target.result); - equal(encryptedData.join(), encryptedData1.join(), - encryptedData.join() + "==" + encryptedData1.join()); - }; - }; - cryptoObj.onerror = shared.error("unwrapKey"); - - }, - shared.error("wrapKey") - ); - } - ); - } - ); - } - ); - }); - - asyncTest("IE to JS OAEP/AES-GCM", function() { - - // Generate encryptionKey: - var importOp = ieCrypto.subtle.generateKey( - { name: "Aes-CBC", length: 128 }, - true, ["sign", "verify"]); - - importOp.oncomplete = - - function(e) { - - var encryptionKey = e.target.result; - - shared.getRsaKeyPair({ name: "rSa-OAEP", modulusLength: 1024 }, function(keyPair) { - - var publicKey = keyPair.keyHandlePublicIE; - var privateKey = keyPair.keyHandlePrivate; - - var wrapOp = ieCrypto.subtle.wrapKey( - encryptionKey, - publicKey, - { name: "Aes-GCM" }); - - wrapOp.oncomplete = - - function(e0) { - - var wrappedKeyData = e0.target.result; - - var unWrapOp = msrCrypto.subtle.unwrapKey( - new Uint8Array(wrappedKeyData), - { name: "Aes-CBC" }, - privateKey, true, ["encrypt", "decrypt"]).then( - - function(e1) { - start(); - var unwrappedEncryptionKey = ENGINE_METHOD_PKEY_ASN1_METHS; - ok(true); - }, - shared.error("unwrapKey") - ); - - }; - wrapOp.onerror = shared.error("wrapKey"); - - }); - }; - }); - - asyncTest("JS to JS OAEP/AES-GCM", function() { - - // Generate encryptionKey: - var importOp = msrCrypto.subtle.generateKey( - { name: "Aes-CBC", length: 128 }, - true, ["sign", "verify"]).then( - - function(encryptionKey) { - - shared.getRsaKeyPair({ name: "rSa-OAEP", modulusLength: 1024 }, function(keyPair) { - - var publicKey = keyPair.keyHandlePublic; - var privateKey = keyPair.keyHandlePrivate; - - msrCrypto.subtle.wrapKey( - encryptionKey, - publicKey, - { name: "Aes-GCM" }).then( - - function(wrappedKeyData) { - - msrCrypto.subtle.unwrapKey( - new Uint8Array(wrappedKeyData), - { name: "Aes-CBC" }, - privateKey, true, ["encrypt", "decrypt"]).then( - - function(unwrappedEncryptionKey) { - start(); - ok(true); - }, - shared.error("unwrapKey") - ); - - }, - shared.error("wrapKey") - ); - }); - } - ); - }); -} -// #endregion WrapKey diff --git a/scripts/wrapKey.js b/scripts/wrapKey.js deleted file mode 100644 index e3e06b5..0000000 --- a/scripts/wrapKey.js +++ /dev/null @@ -1,142 +0,0 @@ -//******************************************************************************* -// -// Copyright 2020 Microsoft -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -//******************************************************************************* -var msrcryptoWrapKey = (function() { - - var utils = msrcryptoUtilities; - - function wrapKey(params) { - - var rsaObj = msrcryptoRsa( - params.keyData1, - params.keyHandle1.algorithm.name, - msrcryptoHashFunctions["SHA-1"])(); - - var tagLength = 128; - - var keyToWrapJwk = msrcryptoJwk.keyToJwkOld(params.keyHandle, params.keyData); - - var jweHeader = { - "alg": params.keyHandle1.algorithm.name.toUpperCase(), - "enc": "A128GCM" - }; - - var encodedJweHeader = - utils.toBase64(JSON.stringify(jweHeader), true); - - var cmk = msrcryptoPseudoRandom.getBytes(32); - - var jweEncryptedKey = rsaObj.encrypt(cmk); - - var encodedJweEncryptedKey = utils.toBase64(jweEncryptedKey, true); - - var jweIv = msrcryptoPseudoRandom.getBytes(12); - - var encodedJweIv = utils.toBase64(jweIv, true); - - var additionalData = encodedJweHeader.concat(".", encodedJweEncryptedKey, ".", encodedJweIv); - - var gcm = msrcryptoGcm(msrcryptoBlockCipher.aes(cmk)); - gcm.init(jweIv, utils.stringToBytes(additionalData), tagLength); - - var ciphertextPlusTag = gcm.encrypt(keyToWrapJwk); - - var tag = ciphertextPlusTag.slice(-(tagLength / 8)); - - var encodedIntegrityValue = utils.toBase64(tag, true); - - var encodedCiphertext = - utils.toBase64(ciphertextPlusTag.slice(0, ciphertextPlusTag.length - tag.length), true); - - var jwe = { - - recipients: [{ - header: encodedJweHeader, - encrypted_key: encodedJweEncryptedKey, - integrity_value: encodedIntegrityValue - } - ], - initialization_vector: encodedJweIv, - ciphertext: encodedCiphertext - - }; - - return utils.stringToBytes(JSON.stringify(jwe)); - - } - - function unwrapKey(params) { - - var b64Tobytes = utils.fromBase64; - - var keyDataJwk = - JSON.parse(String.fromCharCode.apply(null, params.buffer)); - - var header = utils.fromBase64(keyDataJwk.recipients[0].header); - - // tslint:disable-next-line: variable-name - var encrypted_key = - b64Tobytes(keyDataJwk.recipients[0].encrypted_key); - - // tslint:disable-next-line: variable-name - var integrity_value = - b64Tobytes(keyDataJwk.recipients[0].integrity_value); - - // tslint:disable-next-line: variable-name - var initialization_vector = - b64Tobytes(keyDataJwk.initialization_vector); - - var ciphertext = - b64Tobytes(keyDataJwk.ciphertext); - - var hashFunc = msrcryptoHashFunctions["SHA-1"](); - var rsaObj = msrcryptoRsa(params.keyData, params.keyHandle.algorithm.name, hashFunc); - var inKey = rsaObj.decrypt(encrypted_key); - - var additionalData = - keyDataJwk.recipients[0].header.concat(".", keyDataJwk.recipients[0].encrypted_key, ".", - keyDataJwk.initialization_vector); - - var gcm = msrcryptoGcm(msrcryptoBlockCipher.aes(inKey)); - gcm.init(initialization_vector, utils.stringToBytes(additionalData), 128); - - var result = gcm.decrypt(ciphertext, integrity_value); - - var keyObject = msrcryptoJwk.jwkToKey(result, params.algorithm, ["k"]); - - return { - type: "keyImport", - keyData: keyObject.k, - keyHandle: { - algorithm: { name: params.algorithm.name }, - extractable: params.extractable || keyObject.extractable, - usages: params.usages, - type: "secret" - } - }; - } - return { - wrapKey: wrapKey, - unwrapKey: unwrapKey - - }; - -})(); -if (typeof operations !== "undefined") { - operations.register("wrapKey", "AES-GCM", msrcryptoWrapKey.wrapKey); - operations.register("unwrapKey", "AES-CBC", msrcryptoWrapKey.unwrapKey); -} diff --git a/scripts/aes-cbc.js b/src/aes-cbc.js similarity index 98% rename from scripts/aes-cbc.js rename to src/aes-cbc.js index acc26e8..f536690 100644 --- a/scripts/aes-cbc.js +++ b/src/aes-cbc.js @@ -307,8 +307,8 @@ if (typeof operations !== "undefined") { msrcryptoCbc.generateKey = function(p) { - if (p.algorithm.length % 8 !== 0) { - throw new Error(); + if (p.algorithm.length !== 128 && p.algorithm.length !== 192 && p.algorithm.length !== 256) { + throw new Error("invalid key length (should be 128, 192, or 256 bits)"); } return { diff --git a/scripts/aes-gcm.js b/src/aes-gcm.js similarity index 96% rename from scripts/aes-gcm.js rename to src/aes-gcm.js index 7bf0d4e..25bfdc6 100644 --- a/scripts/aes-gcm.js +++ b/src/aes-gcm.js @@ -172,7 +172,7 @@ var msrcryptoGcm = function(blockCipher) { mTagLength = isNaN(tagLength) ? 128 : tagLength; if (mTagLength % 8 !== 0) { - throw new Error("DataError"); + throw msrcryptoUtilities.error("DataError", "tagLength must be a multiple of 8"); } mIvBytes = ivBytes; @@ -398,7 +398,7 @@ if (typeof operations !== "undefined") { if (p.operationSubType === "finish") { result = gcmInstances[id].finishDecrypt(); gcmInstances[id] = null; - if (result === null) { throw new Error("OperationError"); } + if (result === null) { throw msrcryptoUtilities.error("OperationError", ""); } return result; } @@ -409,15 +409,15 @@ if (typeof operations !== "undefined") { result = gcmInstances[id].decrypt(cipherBytes, tagBytes); gcmInstances[id] = null; - if (result === null) { throw new Error("OperationError"); } + if (result === null) { throw msrcryptoUtilities.error("OperationError", ""); } return result; }; msrcryptoGcm.generateKey = function( /*@dynamic*/ p) { - if (p.algorithm.length % 8 !== 0) { - throw new Error(); + if (p.algorithm.length !== 128 && p.algorithm.length !== 192 && p.algorithm.length !== 256) { + throw new Error("invalid key length (should be 128, 192, or 256 bits)"); } return { diff --git a/scripts/aes-kw.js b/src/aes-kw.js similarity index 98% rename from scripts/aes-kw.js rename to src/aes-kw.js index 93d66f4..26aa069 100644 --- a/scripts/aes-kw.js +++ b/src/aes-kw.js @@ -172,7 +172,7 @@ if (typeof operations !== "undefined") { }; msrcryptoAESKW.generateKey = function (p) { - if (p.algorithm.length % 8 !== 0) { + if (p.algorithm.length !== 128 && p.algorithm.length !== 192 && p.algorithm.length !== 256) { throw msrcryptoUtilities.error("OperationError", "AES key length must be 128, 192, or 256 bits"); } diff --git a/scripts/aes.js b/src/aes.js similarity index 100% rename from scripts/aes.js rename to src/aes.js diff --git a/scripts/asn1.js b/src/asn1.js similarity index 100% rename from scripts/asn1.js rename to src/asn1.js diff --git a/scripts/bundleHead.js b/src/bundleHead.js similarity index 100% rename from scripts/bundleHead.js rename to src/bundleHead.js diff --git a/scripts/bundleTail.js b/src/bundleTail.js similarity index 87% rename from scripts/bundleTail.js rename to src/bundleTail.js index 37f54cb..3d52d41 100644 --- a/scripts/bundleTail.js +++ b/src/bundleTail.js @@ -21,6 +21,9 @@ var publicMethods = { /// Microsoft Research Javascript Crypto Library Subtle interface. subtle: msrcryptoSubtle ? msrcryptoSubtle.publicMethods : null, + /// Web Crypto API CryptoKey interface object. Not directly constructible; instances are returned by the subtle key operations. + CryptoKey: CryptoKey, + getRandomValues: function(array) { /// /// Places cryptographically random values into the given array. @@ -34,6 +37,23 @@ var publicMethods = { /// var i; + + // WebCrypto only fills integer-typed arrays; floating-point typed + // arrays are a type mismatch. + var arrayType = msrcryptoUtilities.getObjectType(array); + if (arrayType === "Float32Array" || arrayType === "Float64Array") { + throw msrcryptoUtilities.error("TypeMismatchError", + "The provided ArrayBufferView is not an integer-typed array."); + } + + // Enforce the specification's 65,536-byte entropy quota. + var byteLength = (array.byteLength != null) ? array.byteLength : (array.length || 0); + if (byteLength > 65536) { + throw msrcryptoUtilities.error("QuotaExceededError", + "The ArrayBufferView's byte length (" + byteLength + + ") exceeds the number of bytes of entropy available via this API (65536)."); + } + var randomValues = msrcryptoPseudoRandom.getBytes(array.length); for (i = 0; i < array.length; i += 1) { array[i] = randomValues[i]; @@ -143,10 +163,6 @@ var publicMethods = { if (typeof cryptoMath !== "undefined") { publicMethods.cryptoMath = cryptoMath; } - -if (typeof testInterface !== "undefined") { - publicMethods.testInterface = testInterface; -} /* end-debug-block */ // Initialize the main entropy pool instance on the main thread, only. diff --git a/scripts/concat.js b/src/concat.js similarity index 95% rename from scripts/concat.js rename to src/concat.js index aab3fc8..d9cffa6 100644 --- a/scripts/concat.js +++ b/src/concat.js @@ -16,7 +16,7 @@ // //******************************************************************************* -/// key derivation function from RFC 5869A https://www.ietf.org/rfc/rfc5869.txt +/// The "concat" key derivation function from NIST SP-800-56A. var msrcryptoConcatKdf = (function () { function deriveBits(p) { @@ -53,8 +53,6 @@ var msrcryptoConcatKdf = (function () { }()); -var msrcryptoConcatKdfInstance = null; - if (typeof operations !== "undefined") { msrcryptoConcatKdf.importKey = function (p) { diff --git a/scripts/cryptoECC.js b/src/cryptoECC.js similarity index 100% rename from scripts/cryptoECC.js rename to src/cryptoECC.js diff --git a/scripts/cryptoMath.js b/src/cryptoMath.js similarity index 96% rename from scripts/cryptoMath.js rename to src/cryptoMath.js index c7f09e3..59255c0 100644 --- a/scripts/cryptoMath.js +++ b/src/cryptoMath.js @@ -1300,19 +1300,48 @@ function msrcryptoMath() { } } - function optimalWindowSize(length) { - - var i = 2, - t1, t0, bits = length * DIGIT_BITS; + // Optimal fixed-window width for modExp, indexed by exponent size. + // Each threshold is the exponent bit-length at which the next-larger + // window first becomes cheaper under the cost model (precompute table + + // squaring/multiply loop + constant-time table scan). Because the + // modulus and exponent are the same order of magnitude for every real + // caller (RSA-CRT half-exponents, DH, Miller-Rabin), the scan term is + // effectively constant and the optimum depends only on the exponent + // length. Verified against RSA-1024/2048/4096 signing. + // + // Cost model (montgomeryMultiply-equivalent units; lower is faster), + // for window w, exponent of `bits`, modulus of `s` digits: + // 2^w - 1 precompute the base table + // + ceil(bits/w) * (w + 1) w squarings + 1 multiply per window + // + ceil(bits/w) * 2^w / s constant-time getTableEntry scan + // + 1 final unmontgomery-ize + // optimalWindowSize returns the w minimizing this. (The original model + // omitted the scan term, 2^w/s per window, and so over-sized windows.) + // To regenerate: minimize the above over w for each bit-length, take + // s = ceil(bits / DIGIT_BITS), then re-validate against real signing. + var windowSizeThresholds = [ + // [ max exponent bits (inclusive), window ] + [158, 2], // RSA public exponent (e.g. 65537) + [634, 3], // ~RSA-1024 CRT exponent (~512 bits) + [1984, 4], // ~RSA-2048 CRT exponent (~1024 bits) + [5568, 5], // ~RSA-4096 CRT exponent (~2048 bits) + [14670, 6] + ]; - t0 = 4 + Math.ceil(bits / 2) * 3 + 1; - do { - i++; - t1 = t0; - t0 = Math.pow(2, i) + Math.ceil(bits / i) * (i + 1) + 1; - } while (t0 < t1); + function optimalWindowSize(length) { + /// Look up the fixed-window width that minimizes modExp cost + /// for an exponent of the given digit length. + /// Exponent length in digits. + /// Window size in bits. + + var bits = length * DIGIT_BITS; + for (var i = 0; i < windowSizeThresholds.length; i++) { + if (bits <= windowSizeThresholds[i][0]) { + return windowSizeThresholds[i][1]; + } + } - return i - 1; + return windowSizeThresholds[windowSizeThresholds.length - 1][1] + 1; } function modExp(base, exponent, result, skipSideChannel) { diff --git a/scripts/curves_BN.js b/src/curves_BN.js similarity index 100% rename from scripts/curves_BN.js rename to src/curves_BN.js diff --git a/scripts/curves_NIST.js b/src/curves_NIST.js similarity index 100% rename from scripts/curves_NIST.js rename to src/curves_NIST.js diff --git a/scripts/curves_NUMS.js b/src/curves_NUMS.js similarity index 100% rename from scripts/curves_NUMS.js rename to src/curves_NUMS.js diff --git a/scripts/ecdh.js b/src/ecdh.js similarity index 89% rename from scripts/ecdh.js rename to src/ecdh.js index 9946c7a..f267881 100644 --- a/scripts/ecdh.js +++ b/src/ecdh.js @@ -154,6 +154,21 @@ if ( typeof operations !== "undefined" ) { var keyPairData = ecdhInstance.generateKey(); + // Pad each value to the curve's fixed element length so leading zeros + // are preserved (matches Chrome / Chromium-based Edge behavior). + var partLen = { + "P-256": 32, "P-384": 48, "P-521": 66, + "NUMSP256D1": 32, "NUMSP256T1": 32, + "NUMSP384D1": 48, "NUMSP384T1": 48, + "NUMSP512D1": 64, "NUMSP512T1": 64 + }[p.algorithm.namedCurve]; + var pad = msrcryptoUtilities.padFront; + keyPairData.publicKey.x = pad(keyPairData.publicKey.x, 0, partLen); + keyPairData.publicKey.y = pad(keyPairData.publicKey.y, 0, partLen); + keyPairData.privateKey.x = pad(keyPairData.privateKey.x, 0, partLen); + keyPairData.privateKey.y = pad(keyPairData.privateKey.y, 0, partLen); + keyPairData.privateKey.d = pad(keyPairData.privateKey.d, 0, partLen); + return { type: "keyPairGeneration", keyPair: { @@ -233,6 +248,18 @@ if ( typeof operations !== "undefined" ) { keyObject.y = publicKey.y; } + // Accept keys with or without trimmed leading zeros and pad each + // value to the curve's fixed element length (Chrome/Chromium behavior). + var partLen = { + "P-256": 32, "P-384": 48, "P-521": 66, + "NUMSP256D1": 32, "NUMSP256T1": 32, + "NUMSP384D1": 48, "NUMSP384T1": 48, + "NUMSP512D1": 64, "NUMSP512T1": 64 + }[p.algorithm.namedCurve]; + if ( keyObject.x ) { keyObject.x = msrcryptoUtilities.padFront(keyObject.x, 0, partLen); } + if ( keyObject.y ) { keyObject.y = msrcryptoUtilities.padFront(keyObject.y, 0, partLen); } + if ( keyObject.d ) { keyObject.d = msrcryptoUtilities.padFront(keyObject.d, 0, partLen); } + if ( cryptoECC.validatePoint( p.algorithm.namedCurve.toUpperCase( ), keyObject.x, keyObject.y ) === false ) { throw new Error( "DataError" ); } @@ -360,7 +387,7 @@ if ( typeof operations !== "undefined" ) { } } catch(err) { - throw new msrcryptoUtilities.error("DataError", ""); + throw msrcryptoUtilities.error("DataError", ""); } }; diff --git a/scripts/ecdsa.js b/src/ecdsa.js similarity index 90% rename from scripts/ecdsa.js rename to src/ecdsa.js index de5bb7f..46dc708 100644 --- a/scripts/ecdsa.js +++ b/src/ecdsa.js @@ -205,15 +205,21 @@ if (typeof operations !== "undefined") { var dtb = cryptoMath.digitsToBytes; - // Sometimes the result is a byte short because the byte-conversion - // trims leading zeros. We pad the zeros back on if needed. - function padTo8BytesIncrement( array ) { - return array; - //return msrcryptoUtilities.padFront(array, 0, Math.ceil(array.length / 8) * 8); + // Pad each value to the curve's fixed element length so leading zeros + // are preserved (matches Chrome / Chromium-based Edge behavior). + var partLen = { + "P-256": 32, "P-384": 48, "P-521": 66, + "NUMSP256D1": 32, "NUMSP256T1": 32, + "NUMSP384D1": 48, "NUMSP384T1": 48, + "NUMSP512D1": 64, "NUMSP512T1": 64 + }[p.algorithm.namedCurve]; + + function padToCurveLength( array ) { + return msrcryptoUtilities.padFront(array, 0, partLen); } - var x = padTo8BytesIncrement(dtb(keyPairData.publicKey.x)); - var y = padTo8BytesIncrement(dtb(keyPairData.publicKey.y)); - var d = padTo8BytesIncrement(dtb(keyPairData.privateKey)); + var x = padToCurveLength(dtb(keyPairData.publicKey.x)); + var y = padToCurveLength(dtb(keyPairData.publicKey.y)); + var d = padToCurveLength(dtb(keyPairData.privateKey)); return { type: "keyPairGeneration", @@ -257,7 +263,7 @@ if (typeof operations !== "undefined") { var keyData = p.keyData; - if (keyData[0] !== 4) { throw new Error("DataError"); } + if (keyData[0] !== 4) { throw msrcryptoUtilities.error("DataError", "invalid point encoding"); } // tslint:disable-next-line: no-bitwise var elementSize = ~~((keyData.length - 1) / 2); @@ -268,7 +274,7 @@ if (typeof operations !== "undefined") { y = keyData.slice(elementSize + 1); if (cryptoECC.validatePoint(curveName, x, y) === false) { - throw new Error("DataError"); + throw msrcryptoUtilities.error("DataError", "the imported point is not on the curve"); } return { @@ -299,8 +305,20 @@ if (typeof operations !== "undefined") { keyObject.y = publicKey.y; } + // Accept keys with or without trimmed leading zeros and pad each + // value to the curve's fixed element length (Chrome/Chromium behavior). + var partLen = { + "P-256": 32, "P-384": 48, "P-521": 66, + "NUMSP256D1": 32, "NUMSP256T1": 32, + "NUMSP384D1": 48, "NUMSP384T1": 48, + "NUMSP512D1": 64, "NUMSP512T1": 64 + }[p.algorithm.namedCurve]; + if ( keyObject.x ) { keyObject.x = msrcryptoUtilities.padFront(keyObject.x, 0, partLen); } + if ( keyObject.y ) { keyObject.y = msrcryptoUtilities.padFront(keyObject.y, 0, partLen); } + if ( keyObject.d ) { keyObject.d = msrcryptoUtilities.padFront(keyObject.d, 0, partLen); } + if (cryptoECC.validatePoint(p.algorithm.namedCurve.toUpperCase(), keyObject.x, keyObject.y) === false) { - throw new Error("DataError"); + throw msrcryptoUtilities.error("DataError", "the imported point is not on the curve"); } return { diff --git a/scripts/entropy.js b/src/entropy.js similarity index 100% rename from scripts/entropy.js rename to src/entropy.js diff --git a/scripts/global.js b/src/global.js similarity index 73% rename from scripts/global.js rename to src/global.js index 5440c8e..3447acc 100644 --- a/scripts/global.js +++ b/src/global.js @@ -25,7 +25,7 @@ var scriptUrl = (function() { throw new Error(); } catch (e) { if (e.stack) { - var match = /\w+:\/\/(.+?\/)*.+\.js/.exec(e.stack); + var match = /\w+:\/\/(?:[^/\s]+\/)*[^/\s]*\.js/.exec(e.stack); return (match && match.length > 0) ? match[0] : null; } } @@ -98,3 +98,34 @@ var createProperty = function(parentObject, propertyName, /*@dynamic*/initialVal // Collection of hash functions for global availability. // Each hash function will add itself to the collection as it is evaluated. var msrcryptoHashFunctions = {}; + +// Web Crypto API CryptoKey interface object. +// +// Per the W3C Web Cryptography API, CryptoKey is a top-level interface that is +// exposed on the global scope but is NOT directly constructible by user code +// (calling 'new CryptoKey()' throws an "Illegal constructor" error). Instances +// are produced only by the SubtleCrypto key operations (generateKey, importKey, +// deriveKey, unwrapKey). +// +// A CryptoKey is created internally from the 'keyHandle' object produced by an +// algorithm operation, copying its public attributes (type, extractable, +// algorithm, usages). A private token gates construction so external callers +// cannot create one directly, matching native behavior. +var cryptoKeyInternalToken = {}; + +function CryptoKey(token, keyHandle) { + /// + /// Web Crypto API CryptoKey. Not directly constructible by user code; + /// instances are returned by the SubtleCrypto key operations. + /// + + if (token !== cryptoKeyInternalToken) { + throw new Error("Illegal constructor"); + } + + for (var property in keyHandle) { + if (keyHandle.hasOwnProperty(property)) { + this[property] = keyHandle[property]; + } + } +} diff --git a/scripts/hkdf-ctr.js b/src/hkdf-ctr.js similarity index 96% rename from scripts/hkdf-ctr.js rename to src/hkdf-ctr.js index 897fd18..b6c6e3d 100644 --- a/scripts/hkdf-ctr.js +++ b/src/hkdf-ctr.js @@ -57,10 +57,6 @@ var msrcryptoHkdfCtr = (function () { throw new Error("The length provided for HKDF-CTR is too large."); } - // if (labelBytes.length === 0) { - // labelBytes = msrcryptoUtilities.getVector(hLen); - // } - hmacContext = { workerid: 0, keyHandle: { algorithm: algorithm }, diff --git a/scripts/hkdf.js b/src/hkdf.js similarity index 99% rename from scripts/hkdf.js rename to src/hkdf.js index a9c48a6..df49153 100644 --- a/scripts/hkdf.js +++ b/src/hkdf.js @@ -87,8 +87,6 @@ var msrcryptoHkdf = (function() { }()); -var msrcryptoKdfInstance = null; - if (typeof operations !== "undefined") { msrcryptoHkdf.importKey = function(p) { diff --git a/scripts/hmac.js b/src/hmac.js similarity index 90% rename from scripts/hmac.js rename to src/hmac.js index 36d961e..d1b5cf4 100644 --- a/scripts/hmac.js +++ b/src/hmac.js @@ -193,18 +193,24 @@ if ( typeof operations !== "undefined" ) { msrcryptoHmac.generateKey = function( p ) { - // keyLength = hash alg block size with length is not specified - var defaultKeyLengths = { "SHA-1": 64, "SHA-224": 64, "SHA-256": 64, "SHA-384": 128, "SHA-512": 128 }; + // HMAC key length is specified in bits (per the Web Crypto spec). + // When no length is supplied it defaults to the hash's block size. + var defaultKeyLengthBits = { "SHA-1": 512, "SHA-224": 512, "SHA-256": 512, "SHA-384": 1024, "SHA-512": 1024 }; - var keyLength = p.algorithm.length; + var keyLengthBits = p.algorithm.length || defaultKeyLengthBits[p.algorithm.hash.name.toUpperCase()]; - if ( !keyLength ) { - keyLength = defaultKeyLengths[p.algorithm.hash.name.toUpperCase()]; + var keyData = msrcryptoPseudoRandom.getBytes( Math.ceil( keyLengthBits / 8 ) ); + + // For a length that is not a multiple of 8, zero the unused low bits of the + // final byte so the exported key matches native WebCrypto behavior. + var unusedBits = ( keyData.length * 8 ) - keyLengthBits; + if ( unusedBits > 0 ) { + keyData[keyData.length - 1] &= ( 0xFF << unusedBits ) & 0xFF; } return { type: "keyGeneration", - keyData: msrcryptoPseudoRandom.getBytes( keyLength ), + keyData: keyData, keyHandle: { algorithm: p.algorithm, extractable: p.extractable, diff --git a/scripts/jwk.js b/src/jwk.js similarity index 62% rename from scripts/jwk.js rename to src/jwk.js index 1fd12d6..e057d9f 100644 --- a/scripts/jwk.js +++ b/src/jwk.js @@ -20,21 +20,6 @@ var msrcryptoJwk = (function() { var utils = msrcryptoUtilities; - function stringToArray(stringData) { - - var result = []; - - for (var i = 0; i < stringData.length; i++) { - result[i] = stringData.charCodeAt(i); - } - - if (result[result.length - 1] === 0) { - result.pop(); - } - - return result; - } - function getKeyType(keyHandle) { var algType = keyHandle.algorithm.name.slice(0, 3).toUpperCase(); @@ -104,7 +89,6 @@ var msrcryptoJwk = (function() { key.alg = algorithmMap[keyHandle.algorithm.name.toUpperCase()]( keyHandle.algorithm ); } key.key_ops = keyHandle.usages; - //key.key_ops = (keyHandle.type !== "secret") ? getPublicPrivateUsage(key, keyData) : keyHandle.usages; // Using .pop to determine if a property value is an array. if (keyData.pop) { @@ -125,70 +109,6 @@ var msrcryptoJwk = (function() { return key; } - function findUsage(usage, usages) { - for (var i = 0; i < usages.length; i++) { - if (usage.toUpperCase() === usages[i].toUpperCase()) { return true; } - } - return false; - } - - // function getPublicPrivateUsage(keyObj, keyData) { - - // var newUsages = []; - // var usages = keyObj.key_ops; - - // if (keyObj.kty.toUpperCase() === "RSA") { - - // if (keyData.d) { - // findUsage("decrypt", usages) && newUsages.push("decrypt"); - // findUsage("sign", usages) && newUsages.push("sign"); - // } else { - // findUsage("encrypt", usages) && newUsages.push("encrypt"); - // findUsage("verify", usages) && newUsages.push("verify"); - // } - // return newUsages; - // } - - // if ( keyObj.kty.toUpperCase() === "EC" ) { - - // if ( keyData.d ) { - // findUsage( "deriveBits", usages ) && newUsages.push( "deriveBits" ); - // findUsage( "deriveKey", usages ) && newUsages.push( "deriveKey" ); - // } - // return newUsages; - // } - - // return keyData.usages; - // } - - function keyToJwkOld(keyHandle, keyData) { - - var key = {}; - - key.kty = getKeyType(keyHandle); - key.extractable = keyHandle.extractable; - - // Using .pop to determine if a property value is an array. - if (keyData.pop) { - key.k = utils.toBase64(keyData, true); - } else { - // Convert the base64Url properties to byte arrays - for (var property in keyData) { - if (keyData[property].pop) { - key[property] = utils.toBase64(keyData[property], true); - } - } - } - - if (keyHandle.algorithm.namedCurve) { - key.crv = keyHandle.algorithm.namedCurve; - } - - var stringData = JSON.stringify(key, null, "\t"); - - return stringToArray(stringData); - } - // 'jwkKeyData' is an array of bytes. Each byte is a charCode for a json key string function jwkToKey(keyData, algorithm, propsToArray) { // Convert the json string to an object @@ -207,7 +127,6 @@ var msrcryptoJwk = (function() { } return { - keyToJwkOld: keyToJwkOld, keyToJwk: keyToJwk, jwkToKey: jwkToKey }; diff --git a/scripts/operations.js b/src/operations.js similarity index 69% rename from scripts/operations.js rename to src/operations.js index d6a68fc..665f64b 100644 --- a/scripts/operations.js +++ b/src/operations.js @@ -20,22 +20,27 @@ var operations = {}; operations.register = function(operationType, algorithmName, functionToCall) { - if (!operations[operationType]) { + if (!Object.prototype.hasOwnProperty.call(operations, operationType) || + typeof operations[operationType] !== "object") { operations[operationType] = {}; } var op = operations[operationType]; - if (!op[algorithmName]) { + if (!Object.prototype.hasOwnProperty.call(op, algorithmName)) { op[algorithmName] = functionToCall; } }; operations.exists = function(operationType, algorithmName) { - if (!operations[operationType]) { + if (!Object.prototype.hasOwnProperty.call(operations, operationType) || + typeof operations[operationType] !== "object") { return false; } - return operations[operationType][algorithmName] ? true : false; + var op = operations[operationType]; + + return Object.prototype.hasOwnProperty.call(op, algorithmName) && + typeof op[algorithmName] === "function"; }; diff --git a/scripts/pbkdf2.js b/src/pbkdf2.js similarity index 99% rename from scripts/pbkdf2.js rename to src/pbkdf2.js index 62dcf58..6101b12 100644 --- a/scripts/pbkdf2.js +++ b/src/pbkdf2.js @@ -97,8 +97,6 @@ var msrcryptoPbkdf2 = (function() { }()); -var msrcryptoKdfInstance = null; - if (typeof operations !== "undefined") { msrcryptoPbkdf2.importKey = function(p) { diff --git a/scripts/prime.js b/src/prime.js similarity index 100% rename from scripts/prime.js rename to src/prime.js diff --git a/scripts/random.js b/src/random.js similarity index 100% rename from scripts/random.js rename to src/random.js diff --git a/scripts/rsa-base.js b/src/rsa-base.js similarity index 95% rename from scripts/rsa-base.js rename to src/rsa-base.js index c53d5a1..bc62be3 100644 --- a/scripts/rsa-base.js +++ b/src/rsa-base.js @@ -41,12 +41,6 @@ var msrcryptoRsaBase = function(keyStruct) { var base = group.createElementFromBytes(dataBytes); var result = group.modexp(base, exponent); - // var modulus = cryptoMath.bytesToDigits(modulusBytes); - // var exponent = cryptoMath.bytesToDigits(expBytes); - // var base = cryptoMath.bytesToDigits(dataBytes); - - // var result = cryptoMath.modExp(base, exponent, modulus); - return result.m_digits; } diff --git a/scripts/rsa-oaep.js b/src/rsa-oaep.js similarity index 100% rename from scripts/rsa-oaep.js rename to src/rsa-oaep.js diff --git a/scripts/rsa-pkcs1.js b/src/rsa-pkcs1.js similarity index 100% rename from scripts/rsa-pkcs1.js rename to src/rsa-pkcs1.js diff --git a/scripts/rsa-pss.js b/src/rsa-pss.js similarity index 100% rename from scripts/rsa-pss.js rename to src/rsa-pss.js diff --git a/scripts/rsa.js b/src/rsa.js similarity index 91% rename from scripts/rsa.js rename to src/rsa.js index 8e5fc9f..3b875c2 100644 --- a/scripts/rsa.js +++ b/src/rsa.js @@ -107,7 +107,7 @@ var msrcryptoRsa = function(keyStruct, mode, /*@optional*/ hashFunction) { ///JS3053.IncorrectNumberOfArguments if (decryptedData.valid === false) { - throw new Error("OperationError"); + throw msrcryptoUtilities.error("OperationError", ""); } decryptedData = decryptedData.data; @@ -463,14 +463,42 @@ if (typeof operations !== "undefined") { var algName = p.algorithm.name; var rsaKeyType = algName.slice(algName.indexOf("-") + 1).toUpperCase(); + // The usages valid for each half of the key pair for this algorithm. var publicUsage, privateUsage; if (algName === "RSASSA-PKCS1-V1_5" || algName === "RSA-PSS") { publicUsage = ["verify"]; privateUsage = ["sign"]; } else { // OAEP, RSAES - publicUsage = ["encrypt"]; - privateUsage = ["decrypt"]; + publicUsage = ["encrypt", "wrapKey"]; + privateUsage = ["decrypt", "unwrapKey"]; + } + + // Honor the caller's requested usages (like the other algorithms do), + // routing each requested usage to the key half it applies to. When no + // usages are requested, default to all usages valid for the algorithm. + // Note: Array.prototype.filter/indexOf are ES5 (unavailable on IE8), so + // use plain loops and the IE8-safe msrcryptoUtilities.indexOf helper. + if (p.usages) { + var requestedUsages = p.usages; + var filteredPublic = []; + var filteredPrivate = []; + var usageIndex; + + for (usageIndex = 0; usageIndex < publicUsage.length; usageIndex += 1) { + if (msrcryptoUtilities.indexOf(requestedUsages, publicUsage[usageIndex]) >= 0) { + filteredPublic.push(publicUsage[usageIndex]); + } + } + + for (usageIndex = 0; usageIndex < privateUsage.length; usageIndex += 1) { + if (msrcryptoUtilities.indexOf(requestedUsages, privateUsage[usageIndex]) >= 0) { + filteredPrivate.push(privateUsage[usageIndex]); + } + } + + publicUsage = filteredPublic; + privateUsage = filteredPrivate; } return { @@ -481,7 +509,7 @@ if (typeof operations !== "undefined") { keyHandle: { algorithm: p.algorithm, extractable: p.extractable, - usages: null || publicUsage, + usages: publicUsage, type: "public" } }, @@ -490,7 +518,7 @@ if (typeof operations !== "undefined") { keyHandle: { algorithm: p.algorithm, extractable: p.extractable, - usages: null || privateUsage, + usages: privateUsage, type: "private" } } diff --git a/scripts/sha.js b/src/sha.js similarity index 100% rename from scripts/sha.js rename to src/sha.js diff --git a/scripts/sha1.js b/src/sha1.js similarity index 100% rename from scripts/sha1.js rename to src/sha1.js diff --git a/scripts/sha256.js b/src/sha256.js similarity index 100% rename from scripts/sha256.js rename to src/sha256.js diff --git a/scripts/sha512.js b/src/sha512.js similarity index 100% rename from scripts/sha512.js rename to src/sha512.js diff --git a/scripts/subtle/head.js b/src/subtle/head.js similarity index 100% rename from scripts/subtle/head.js rename to src/subtle/head.js diff --git a/scripts/subtle/keyManager.js b/src/subtle/keyManager.js similarity index 76% rename from scripts/subtle/keyManager.js rename to src/subtle/keyManager.js index 5f74b07..8bd5f05 100644 --- a/scripts/subtle/keyManager.js +++ b/src/subtle/keyManager.js @@ -17,25 +17,25 @@ //******************************************************************************* // Storage for the keyData. -// Stored as {keyHandle: keyHandle, keyData: keyData} objects. +// Stored as {cryptoKey: cryptoKey, keyData: keyData} objects. var keys = []; -keys.add = function(keyHandle, keyData) { - keys.push({ keyHandle: keyHandle, keyData: keyData }); +keys.add = function(cryptoKey, keyData) { + keys.push({ cryptoKey: cryptoKey, keyData: keyData }); }; -keys.remove = function(keyHandle) { +keys.remove = function(cryptoKey) { for (var i = 0; i < keys.length; i += 1) { - if (keys[i].keyHandle === keyHandle) { + if (keys[i].cryptoKey === cryptoKey) { keys = keys.splice(i, 1); return; } } }; -keys.lookup = function(keyHandle) { +keys.lookup = function(cryptoKey) { for (var i = 0; i < keys.length; i += 1) { - if (keys[i].keyHandle === keyHandle) { + if (keys[i].cryptoKey === cryptoKey) { return keys[i].keyData; } } diff --git a/scripts/subtle/operations.js b/src/subtle/operations.js similarity index 76% rename from scripts/subtle/operations.js rename to src/subtle/operations.js index fbfcf31..5e9bde4 100644 --- a/scripts/subtle/operations.js +++ b/src/subtle/operations.js @@ -55,7 +55,14 @@ function baseOperation(processResults) { if (e.type === "error") { // If the onerror callback has been set, call it. if (rejectFunc) { - e.data && (e.data.stack = "Error") && (e.data.code = 0); + // A real Web Worker may deliver an error stripped of its + // prototype, so ensure stack/code exist. Guard the assignments + // because a DOMException exposes read-only stack/code accessors + // that must not be clobbered. + if (e.data) { + try { if (!e.data.stack) { e.data.stack = "Error"; } } catch (ex) { /* read-only */ } + try { if (e.data.code == null) { e.data.code = 0; } } catch (ex) { /* read-only */ } + } rejectFunc.apply(promise, [e.data || e]); } return; @@ -95,10 +102,19 @@ function baseOperation(processResults) { function keyOperation() { + // Wrap an algorithm-produced keyHandle in a Web Crypto CryptoKey instance. + // The same instance is used both as the lookup token (keys.add) and as the + // value handed back to the caller, so key identity is preserved for + // subsequent operations. + function toCryptoKey(keyHandle) { + return new CryptoKey(cryptoKeyInternalToken, keyHandle); + } + function processResult(result) { var publicKey, - privateKey; + privateKey, + cryptoKey; // Could be the result of an import, export, generate. // Get the keyData and keyHandle out. @@ -109,15 +125,18 @@ function keyOperation() { case "keyImport": case "keyDerive": if (result.keyPair) { - keys.add(result.keyPair.publicKey.keyHandle, result.keyPair.publicKey.keyData); - keys.add(result.keyPair.privateKey.keyHandle, result.keyPair.privateKey.keyData); + publicKey = toCryptoKey(result.keyPair.publicKey.keyHandle); + privateKey = toCryptoKey(result.keyPair.privateKey.keyHandle); + keys.add(publicKey, result.keyPair.publicKey.keyData); + keys.add(privateKey, result.keyPair.privateKey.keyData); return { - publicKey: result.keyPair.publicKey.keyHandle, - privateKey: result.keyPair.privateKey.keyHandle + publicKey: publicKey, + privateKey: privateKey }; } else { - keys.add(result.keyHandle, result.keyData); - return result.keyHandle; + cryptoKey = toCryptoKey(result.keyHandle); + keys.add(cryptoKey, result.keyData); + return cryptoKey; } // KeyExport: return the export data @@ -125,13 +144,13 @@ function keyOperation() { return result.keyHandle; case "keyPairGeneration": - privateKey = result.keyPair.privateKey; - publicKey = result.keyPair.publicKey; - keys.add(publicKey.keyHandle, publicKey.keyData); - keys.add(privateKey.keyHandle, privateKey.keyData); + publicKey = toCryptoKey(result.keyPair.publicKey.keyHandle); + privateKey = toCryptoKey(result.keyPair.privateKey.keyHandle); + keys.add(publicKey, result.keyPair.publicKey.keyData); + keys.add(privateKey, result.keyPair.privateKey.keyData); return { - publicKey: publicKey.keyHandle, - privateKey: privateKey.keyHandle + publicKey: publicKey, + privateKey: privateKey }; default: diff --git a/scripts/subtle/promises.js b/src/subtle/promises.js similarity index 50% rename from scripts/subtle/promises.js rename to src/subtle/promises.js index 06c32be..7184d60 100644 --- a/scripts/subtle/promises.js +++ b/src/subtle/promises.js @@ -15,15 +15,41 @@ // limitations under the License. // //******************************************************************************* -// AMD/global wrapper -(function(root, factory) { +// Promise polyfill wrapper. +// Exposes the constructor on msrCrypto.Promise (the native Promise when one is +// available, otherwise the bundled implementation) so the polyfill installer +// can wire it to the global scope. Also installs a global Promise directly +// when the host lacks one (for example, legacy IE). +(function(factory) { + + // Resolve the real global object across browsers, web workers, and Node. + var globalObject = (function() { + if (typeof globalThis !== "undefined") { return globalThis; } + if (typeof self !== "undefined") { return self; } + if (typeof window !== "undefined") { return window; } + if (typeof global !== "undefined") { return global; } + return this; + })(); + + // Prefer a native Promise; only build the bundled one when needed. + var providedPromise = (typeof globalObject.Promise !== "undefined") + ? globalObject.Promise + : factory(); + + // Expose the constructor on the msrCrypto export so msrcryptoPolyfill.js + // (or any consumer) can install it on the global scope on demand. + if (typeof module === "object" && module.exports) { + module.exports.Promise = module.exports.Promise || providedPromise; + } else if (globalObject.msrCrypto) { + globalObject.msrCrypto.Promise = globalObject.msrCrypto.Promise || providedPromise; + } - if (typeof Promise !== "undefined") { - return; + // Install a global Promise when the host lacks one. + if (typeof globalObject.Promise === "undefined") { + globalObject.Promise = providedPromise; } - root.Promise = factory(); -}(this, function() { +}(function() { var Promise = function(executor, id) { /// @@ -37,158 +63,141 @@ throw new Error("use 'new' keyword with Promise constructor"); } - var successResult = null, - failReason = null, - thenResolved = [], - thenRejected = [], - rejectThenPromise = [], - resolveThenPromise = []; - - this.then = function(onCompleted, onRejected) { - - var thenFunctionResult; - - // If we already have a result because resolveFunction was synchronous, - // then just call onCompleted with the result. - if (successResult) { - thenFunctionResult = onCompleted(successResult.result); - - if (thenFunctionResult && thenFunctionResult.then) { - return thenFunctionResult; - } - - // Create a new promise; resolve with the result; - // return the resolved promise. - return Promise.resolve(thenFunctionResult); + // State: 0 = pending, 1 = fulfilled, 2 = rejected. + var state = 0, + settledValue = null, + // Queue of handlers registered while pending. Each entry is + // { onCompleted, onRejected, resolveNext, rejectNext } so a single + // list keeps each handler aligned with its chained promise's + // resolve/reject. This lets rejections propagate through then() + // calls that omit a rejection handler so a trailing catch() still + // receives the error. (The previous implementation tracked these in + // separate arrays that fell out of alignment and dropped such + // rejections, silently swallowing errors.) + handlers = []; + + // Invoke a single registered handler against the settled value and + // route the outcome to its chained promise. A missing handler passes + // the value through (fulfilled -> resolveNext, rejected -> rejectNext) + // so a later catch() still sees an earlier rejection. A throwing + // handler rejects the chained promise. + function runHandler(handler) { + + var callback = (state === 1) ? handler.onCompleted : handler.onRejected; + + if (!callback) { + (state === 1 ? handler.resolveNext : handler.rejectNext)(settledValue); + return; } - // If we already have a fail reason from a rejected promise - if (failReason) { - thenFunctionResult = onRejected ? onRejected(failReason.result) : failReason.result; - - if (thenFunctionResult && thenFunctionResult.then) { - return thenFunctionResult; - } - - // Create a new promise; reject with the result; - // return the resolved promise. - return Promise.resolve(thenFunctionResult); + var result; + try { + result = callback(settledValue); + } catch (handlerError) { + handler.rejectNext(handlerError); + return; } - // If we do not have a result, store the onCompleted/onRejected functions - // to call when we do get a result. - thenResolved.push(onCompleted); - if (onRejected) { - thenRejected.push(onRejected); - } - - // Return a new promise object. This will allow chaining with then/catch(). - // tslint:disable-next-line: no-shadowed-variable - return new Promise(function(resolve, reject) { - resolveThenPromise.push(resolve); - rejectThenPromise.push(reject); - }); - }; + handler.resolveNext(result); + } - // tslint:disable-next-line: no-string-literal - this["catch"] = function(onRejected) { + // Move the promise to its final state and flush any queued handlers. + // When fulfilled with a thenable, adopt that thenable's eventual state + // so returning a promise from then() chains as expected. + function settle(newState, value) { - var catchFunctionResult; + if (state !== 0) { + return; + } - // If we already have a result because resolveFunction was synchronous, - // then just call onRejected with the result. - if (failReason) { - catchFunctionResult = onRejected(failReason.result); + if (newState === 1 && value && (typeof value === "object" || typeof value === "function")) { - if (catchFunctionResult && catchFunctionResult.then) { - return catchFunctionResult; + var thenFunction; + try { + thenFunction = value.then; + } catch (accessError) { + settle(2, accessError); + return; } - return Promise.resolve(catchFunctionResult); + if (typeof thenFunction === "function") { + var handled = false; + try { + thenFunction.call( + value, + function(result) { if (!handled) { handled = true; settle(1, result); } }, + function(reason) { if (!handled) { handled = true; settle(2, reason); } }); + } catch (thenableError) { + if (!handled) { handled = true; settle(2, thenableError); } + } + return; + } } - // If we do not have a result, store the onRejected function - // to call when we do get a result. - thenRejected.push(onRejected); + state = newState; + settledValue = value; - // Return a new promise object. This will allow chaining with then/catch(). - // tslint:disable-next-line: no-shadowed-variable - return new Promise(function(resolve, reject) { - resolveThenPromise.push(resolve); - rejectThenPromise.push(reject); - }); - }; + for (var i = 0; i < handlers.length; i += 1) { + runHandler(handlers[i]); + } + handlers = []; + } function resolve(param) { /// - /// Called by the executor function when the function has succeeded. + /// Called by the executor function when the operation has succeeded. /// - /// A result value that will be passed to the then() function. - - var result, i; - - // Call each attached Then function with the result - for (i = 0; i < thenResolved.length; i += 1) { - - result = thenResolved[i](param); - - // If the result of the then() function is a Promise, - // set then() to call the chained resolve function. - if (result && result.then) { - result.then(resolveThenPromise[i]); - - // Also set catch() if present - if (rejectThenPromise[i]) { - // tslint:disable-next-line: no-string-literal - result["catch"](rejectThenPromise[i]); - } - - } else { - - // If a then() promise was chained to this promise, call its resolve - // function. - if (resolveThenPromise[i]) { - resolveThenPromise[i](result); - } - } - } - - // If the onCompleted function has not yet been assigned, store the result. - successResult = { result: param }; - - return; + /// A result value passed to the then() function. + settle(1, param); } function reject(param) { + /// + /// Called by the executor function when the operation has failed. + /// + /// A reason value passed to the catch() function. + settle(2, param); + } - var reason, i; + this.then = function(onCompleted, onRejected) { - // Call each catch function on this promise - for (i = 0; i < thenRejected.length; i += 1) { + var resolveNext, rejectNext; - reason = thenRejected[i](param); + // tslint:disable-next-line: no-shadowed-variable + var nextPromise = new Promise(function(resolve, reject) { + resolveNext = resolve; + rejectNext = reject; + }); - // If the result of the catch() function is a Promise, - // set then() to call the chained resolve function. - if (reason && reason.then) { - reason.then(resolveThenPromise[i], rejectThenPromise[i]); + var handler = { + onCompleted: (typeof onCompleted === "function") ? onCompleted : null, + onRejected: (typeof onRejected === "function") ? onRejected : null, + resolveNext: resolveNext, + rejectNext: rejectNext + }; - } else { - if (resolveThenPromise[i]) { - resolveThenPromise[i](reason); - } - } + // Run immediately if already settled, otherwise queue until it is. + if (state === 0) { + handlers.push(handler); + } else { + runHandler(handler); } - // If the onCompleted function has not yet been assigned, store the result. - failReason = { result: param }; + return nextPromise; + }; - return; - } + // tslint:disable-next-line: no-string-literal + this["catch"] = function(onRejected) { + return this.then(null, onRejected); + }; // Call the executor function passing the resolve & reject functions of - // this instance. - executor(resolve, reject); + // this instance. A throw from the executor rejects the promise. + try { + executor(resolve, reject); + } catch (executorError) { + reject(executorError); + } return; }; diff --git a/src/subtle/subtleInterface.js b/src/subtle/subtleInterface.js new file mode 100644 index 0000000..9b1bf1c --- /dev/null +++ b/src/subtle/subtleInterface.js @@ -0,0 +1,474 @@ +//******************************************************************************* +// +// Copyright 2020 Microsoft +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//******************************************************************************* + +function checkOperation(operationType, algorithmName) { + if (!operations.exists(operationType, algorithmName)) { + throw utils.error("NotSupportedError", "Unrecognized or unsupported algorithm."); + } +} + +// The list of possible parameters passed to the subtle interface. +var subtleParameters = [ + /* 0 */ { name: "algorithm", type: "Object", required: true }, + /* 1 */ { name: "keyHandle", type: "Object", required: true }, + /* 2 */ { name: "buffer", type: "Array", required: false }, + /* 3 */ { name: "signature", type: "Array", required: true }, + /* 4 */ { name: "format", type: "String", required: true }, + /* 5 */ { name: "keyData", type: "Object", required: true }, + /* 6 */ { name: "extractable", type: "Boolean", required: false }, + /* 7 */ { name: "usages", type: "Array", required: false }, + /* 8 */ { name: "derivedKeyType", type: "Object", required: true }, + /* 9 */ { name: "length", type: "Number", required: false }, + /* 10 */ { name: "extractable", type: "Boolean", required: true }, + /* 11 */ { name: "usages", type: "Array", required: true }, + /* 12 */ { name: "keyData", type: "Array", required: true } +]; + +// The set of expected parameters passed to each subtle function. +var subtleParametersSets = { + encrypt: [0, 1, 2], + decrypt: [0, 1, 2], + sign: [0, 1, 2], + verify: [0, 1, 3, 2], + digest: [0, 2], + generateKey: [0, 6, 7], + importKeyRaw: [4, 12, 0, 10, 11], + importKeyJwk: [4, 5, 0, 10, 11], + exportKey: [0, 4, 1, 6, 7], + deriveKey: [0, 1, 8, 6, 7], + deriveBits: [0, 1, 9] +}; + +// Looks up the stored key data for a given keyHandle +function lookupKeyData(handle) { + var data = keys.lookup(handle); + + if (!data) { + throw utils.error("InvalidAccessError", "key not found"); + } + + return data; +} + +// This function processes each parameter passed by the user. Each parameter +// is compared against an expected parameter. It should be of the expected type. +// Typed-Array parameters are converted to regular Arrays. +function buildParameterCollection(operationName, parameterSet) { + + var parameterCollection = { operationType: operationName }, + operationParameterSet, + expectedParam, + actualParam, + i; + + if (operationName === "importKey" && (parameterSet[0] === "raw" || parameterSet[0] === "spki" || parameterSet[0] === "pkcs8")) { + operationName = "importKeyRaw"; + } + + if (operationName === "importKey" && parameterSet[0] === "jwk") { + operationName = "importKeyJwk"; + } + + operationParameterSet = subtleParametersSets[operationName]; + + for (i = 0; i < operationParameterSet.length; i += 1) { + + expectedParam = subtleParameters[operationParameterSet[i]]; + actualParam = parameterSet[i]; + + // Verify the required parameters are present. + if (actualParam == null) { + if (expectedParam.required) { + throw new TypeError("Missing required parameter: " + expectedParam.name); + } else { + continue; + } + } + + // A string algorithm identifier (e.g. "SHA-256") is shorthand for + // { name: "SHA-256" }, per the W3C AlgorithmIdentifier (object or + // DOMString). Normalize it to an object before the type check below. + if (expectedParam.name === "algorithm" && utils.getObjectType(actualParam) === "String") { + actualParam = { name: actualParam }; + } + + // If this parameter is a typed-array convert it to a regular array. + if (actualParam.subarray) { + actualParam = utils.toArray(actualParam); + } + + // If this parameter is an ArrayBuffer convert it to a regular array. + if (utils.getObjectType(actualParam) === "ArrayBuffer") { + actualParam = utils.toArray(actualParam); + } + + // Verify the actual parameter is of the expected type. + if (msrcryptoUtilities.getObjectType(actualParam) !== expectedParam.type) { + throw new TypeError("Invalid type for parameter: " + expectedParam.name); + } + + // If this parameter is an algorithm object convert it's name to upperCase. + if (expectedParam.name === "algorithm") { + + actualParam.name = actualParam.name.toUpperCase(); + + // If the algorithm has a typed-array IV, convert it to a regular array. + if (actualParam.iv) { + actualParam.iv = utils.toArray(actualParam.iv); + } + + // If the algorithm has a typed-array publicExponent, convert it to a regular array. + if (actualParam.publicExponent) { + actualParam.publicExponent = utils.toArray(actualParam.publicExponent); + } + + // If the algorithm has a typed-array Salt, convert it to a regular array. + if (actualParam.salt) { + actualParam.salt = utils.toArray(actualParam.salt); + } + + // If the algorithm has a typed-array AdditionalData, convert it to a regular array. + if (actualParam.additionalData) { + actualParam.additionalData = utils.toArray(actualParam.additionalData); + } + + // If this algorithm has a hash property in the form 'hash: hashName' + // Convert it to hash: {name: hashName} as per the W3C spec. + if (actualParam.hash && !actualParam.hash.name && utils.getObjectType(actualParam.hash) === "String") { + actualParam.hash = { name: actualParam.hash }; + } + } + + // KeyWrap has two keyHandle parameters. We add '1' to the second param name + // to avoid a duplicate name. + if (parameterCollection.hasOwnProperty(expectedParam.name)) { + parameterCollection[expectedParam.name + "1"] = actualParam; + } else { + parameterCollection[expectedParam.name] = actualParam; + } + } + + return parameterCollection; +} + +function executeOperation(operationName, parameterSet, keyFunc) { + + // WebCrypto SubtleCrypto methods never throw synchronously; any error + // (bad parameters, unsupported algorithm, etc.) must be surfaced as a + // rejected promise. Wrap the synchronous setup so we honor that contract. + try { + + var pc = buildParameterCollection(operationName, parameterSet); + + // Verify this type of operation is supported by this library (encrypt, digest, etc...) + checkOperation(operationName, pc.algorithm.name); + + // Add the key data to the parameter object + if (pc.keyHandle) { + pc.keyData = lookupKeyData(pc.keyHandle); + } + + // Add the key data to the parameter object + // KeyWrap has two keyHandle parameters - this handles the second key. + if (pc.keyHandle1) { + pc.keyData1 = lookupKeyData(pc.keyHandle1); + } + + // ECDH.DeriveBits passes a public key in the algorithm + if (pc.algorithm && pc.algorithm.public) { + pc.additionalKeyData = lookupKeyData(pc.algorithm.public); + } + + var op = keyFunc ? keyOperation(pc) : cryptoOperation(pc); + + // Run the crypto now if a buffer is supplied + // else wait until process() and finish() are called. + if (keyFunc || pc.buffer || operationName === "deriveBits") { + workerManager.runJob(op, pc); + } + + if (op.stream) { + // This is streaming operation. A streamObject will be returned to the promise now. + return Promise.resolve(streamObject(op)); + } + + return op.promise; + + } catch (error) { + return Promise.reject(error); + } +} +var publicMethods = { + + encrypt: function(algorithm, cryptoKey, buffer) { + /** + * Encrypt data. Returns an ArrayBuffer if supported, otherwise a regular Array. + * @param {Algorithm} algorithm - The encryption algorithm and its parameters. + * @param {CryptoKey} cryptoKey - The key to encrypt with. + * @param {Uint8Array|Array} [buffer] - The data to encrypt (a Uint8Array or an array of byte values 0-255). + * @returns {Promise} The encrypted data. + */ + + return executeOperation("encrypt", arguments, 0); + }, + + decrypt: function(algorithm, cryptoKey, buffer) { + /** + * Decrypt data. Returns an ArrayBuffer if supported, otherwise an array of byte values (0-255). + * @param {Algorithm} algorithm - The decryption algorithm and its parameters. + * @param {CryptoKey} cryptoKey - The key to decrypt with. + * @param {Uint8Array|Array} [buffer] - The data to decrypt (a Uint8Array or an array of byte values 0-255). + * @returns {Promise} The decrypted data. + */ + + return executeOperation("decrypt", arguments, 0); + }, + + sign: function(algorithm, cryptoKey, buffer) { + /** + * Sign data. Returns a signature as an ArrayBuffer if supported, otherwise an array of byte values (0-255). + * @param {Algorithm} algorithm - The signature algorithm and its parameters. + * @param {CryptoKey} cryptoKey - The key to sign with. + * @param {Uint8Array|Array} [buffer] - The data to sign (a Uint8Array or an array of byte values 0-255). + * @returns {Promise} The signature. + */ + + return executeOperation("sign", arguments, 0); + }, + + verify: function(algorithm, cryptoKey, signature, buffer) { + /** + * Verify a signature. + * @param {Algorithm} algorithm - The signature algorithm and its parameters. + * @param {CryptoKey} cryptoKey - The key to verify with. + * @param {Uint8Array|Array} signature - The signature to verify (a Uint8Array or an array of byte values 0-255). + * @param {Uint8Array|Array} [buffer] - The data that was signed (a Uint8Array or an array of byte values 0-255). + * @returns {Promise} True if the signature is valid. + */ + + return executeOperation("verify", arguments, 0); + }, + + digest: function(algorithm, buffer) { + /** + * Digest data using a specified cryptographic hash algorithm. + * @param {Algorithm} algorithm - The hash algorithm. + * @param {Uint8Array|Array} [buffer] - The data to hash (a Uint8Array or an array of byte values 0-255). + * @returns {Promise} The computed digest. + */ + return executeOperation("digest", arguments, 0); + }, + + generateKey: function(algorithm, extractable, keyUsage) { + /** + * Generate a new key for use with the algorithm specified by the algorithm parameter. + * @param {Algorithm} algorithm - The algorithm the key will be used with. + * @param {boolean} [extractable] - Whether the key may be exported. + * @param {Array} [keyUsage] - The permitted key usages. + * @returns {Promise} The generated key or key pair. + */ + + return executeOperation("generateKey", arguments, 1); + }, + + deriveKey: function(algorithm, baseKey, derivedKeyType, extractable, keyUsage) { + /** + * Generate a key for the specified derivedKeyType, using the specified cryptographic + * key derivation algorithm with the given baseKey as input. + * @param {Algorithm} algorithm - The key derivation algorithm and its parameters. + * @param {Key} baseKey - The base key used to derive the new key. + * @param {Algorithm} derivedKeyType - The algorithm the derived key will be used with. + * @param {boolean} [extractable] - Whether the derived key may be exported. + * @param {Array} [keyUsage] - The permitted key usages. + * @returns {Promise} The derived key. + */ + + var deriveBits = this.deriveBits, + importKey = this.importKey; + + return new Promise(function(resolve, reject) { + + var keyLength; + + // Accept both the string and object HashAlgorithmIdentifier forms. + if (derivedKeyType.hash && !derivedKeyType.hash.name && utils.getObjectType(derivedKeyType.hash) === "String") { + derivedKeyType.hash = { name: derivedKeyType.hash }; + } + + switch (derivedKeyType.name.toUpperCase()) { + case "AES-CBC": + case "AES-GCM": + keyLength = derivedKeyType.length; + break; + case "HMAC": + keyLength = derivedKeyType.length || // HMAC length defaults to hash block size + { "SHA-1": 512, "SHA-224": 512, "SHA-256": 512, "SHA-384": 1024, "SHA-512": 1024 }[derivedKeyType.hash.name.toUpperCase()]; + break; + default: + reject(new Error("No Supported")); + return; + } + + deriveBits(algorithm, baseKey, keyLength) + .then(function(bits) { + return importKey("raw", bits, derivedKeyType, extractable, keyUsage); + }) + .then(function(key) { + resolve(key); + }) + // tslint:disable-next-line: no-string-literal + ["catch"](function(err) { + reject(err); + }); + + }); + + }, + + deriveBits: function(algorithm, baseKey, length) { + /** + * Generate an array of bytes from a given baseKey as input. + * @param {Algorithm} algorithm - The key derivation algorithm and its parameters. + * @param {Key} baseKey - The base key used to derive the bits. + * @param {number} length - Number of bits to return. + * @returns {Promise} The derived bits. + */ + + return executeOperation("deriveBits", arguments, 0); + }, + + importKey: function(format, keyData, algorithm, extractable, keyUsage) { + /** + * Construct a new Key object using the key data specified by the keyData parameter. + * @param {string} format - The format of the key data (e.g. "raw", "jwk", "spki", "pkcs8"). + * @param {Object|Array} keyData - The key data (a JWK object, or key bytes for other formats). + * @param {Algorithm} algorithm - The algorithm the key will be used with. + * @param {boolean} [extractable] - Whether the key may be exported. + * @param {Array} [keyUsage] - The permitted key usages. + * @returns {Promise} The imported key. + */ + return executeOperation("importKey", arguments, 1); + }, + + exportKey: function(format, cryptoKey) { + /** + * Export the key material of the Key object as specified by the format parameter. + * @param {string} format - The format to export the key in (e.g. "raw", "jwk", "spki", "pkcs8"). + * @param {CryptoKey} cryptoKey - The key to export. + * @returns {Promise} The exported key material. + */ + + // Export is one of the few calls where the caller does not supply an algorithm + // since it's already a property of the key to be exported. + // So, we're pulling it out of the key and adding it to the parameter set since + // it is used as a switch to route the parameters to the right function. + // Now we don't have to treat this as a special case in the underlying code. + return executeOperation("exportKey", [cryptoKey.algorithm, format, cryptoKey], 1); + }, + + wrapKey: function(format, key, wrappingKey, wrappingKeyAlgorithm) { + /** + * Asynchronously return an array containing the key material of key, encrypted with + * wrappingKey using the specified wrappingKeyAlgorithm. + * @param {string} format - The format to export the key in before wrapping. + * @param {Key} key - The key to wrap. + * @param {Key} wrappingKey - The key used to encrypt (wrap) the exported key material. + * @param {Algorithm} wrappingKeyAlgorithm - The algorithm used to wrap the key. + * @returns {Promise} The wrapped key. + */ + + var encrypt = this.encrypt, + exportKey = this.exportKey; + + return new Promise(function(resolve, reject) { + + if (key.extractable === false || + utils.indexOf(wrappingKey.usages, "wrapKey") < 0 || + wrappingKey.algorithm.name.toUpperCase() !== wrappingKeyAlgorithm.name) { + reject(utils.error("InvalidAccessError", "key cannot be wrapped with the supplied wrapping key")); + return; + } + + exportKey(format, key) + + .then(function(keyData) { + + return encrypt(wrappingKeyAlgorithm, wrappingKey, format === "jwk" ? + utils.stringToBytes(JSON.stringify(keyData, null, 0)) : keyData); + }) + + .then(function(cipherArrayBuffer) { + resolve(cipherArrayBuffer); + }) + + // tslint:disable-next-line: no-string-literal + ["catch"](function(err) { + reject(err); + }); + }); + }, + + unwrapKey: function(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) { + //format, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable and keyUsages + /** + * Construct a Key object from encrypted key material. + * @param {string} format - The format of the wrapped key material. + * @param {Uint8Array|Array} wrappedKey - The encrypted key material. + * @param {Key} unwrappingKey - The key used to decrypt (unwrap) the wrapped key. + * @param {Algorithm} unwrapAlgorithm - The algorithm used to unwrap the key. + * @param {Algorithm} unwrappedKeyAlgorithm - The algorithm the unwrapped key will be used with. + * @param {boolean} [extractable] - Whether the unwrapped key may be exported. + * @param {Array} [keyUsages] - The permitted key usages. + * @returns {Promise} The unwrapped key. + */ + + var decrypt = this.decrypt, + importKey = this.importKey; + + return new Promise(function(resolve, reject) { + + if (utils.indexOf(unwrappingKey.usages, "unwrapKey") < 0 || + unwrappingKey.algorithm.name.toUpperCase() !== unwrapAlgorithm.name) { + reject(utils.error("InvalidAccessError", "key cannot be unwrapped with the supplied unwrapping key")); + return; + } + + decrypt(unwrapAlgorithm, unwrappingKey, wrappedKey) + + .then(function(keyPlain) { + return importKey(format, format === "jwk" ? JSON.parse(utils.bytesToString(keyPlain)) : keyPlain, + unwrappedKeyAlgorithm, extractable, keyUsages); + }) + + .then(function(key) { + resolve(key); + }) + + // tslint:disable-next-line: no-string-literal + ["catch"](function(err) { + reject(err); + }); + }); + + } + +}; + +var internalMethods = { + useWebWorkers: workerManager.useWebWorkers +}; diff --git a/scripts/subtle/syncWorker.js b/src/subtle/syncWorker.js similarity index 100% rename from scripts/subtle/syncWorker.js rename to src/subtle/syncWorker.js diff --git a/scripts/subtle/tail.js b/src/subtle/tail.js similarity index 100% rename from scripts/subtle/tail.js rename to src/subtle/tail.js diff --git a/scripts/subtle/workerManager.js b/src/subtle/workerManager.js similarity index 92% rename from scripts/subtle/workerManager.js rename to src/subtle/workerManager.js index 783f64b..1e4d910 100644 --- a/scripts/subtle/workerManager.js +++ b/src/subtle/workerManager.js @@ -214,6 +214,16 @@ var workerManager = (function() { // The worker will call this function when it completes its job. worker.onmessage = function(/*@type(typeEvent)*/ e) { + // Guard against messages that arrive without a data payload. A + // well-behaved worker always posts a result, but a malformed or + // empty event must not throw while reading e.data.* below. Use a + // null/undefined check (not a falsy check): a legitimate result can + // itself be falsy, e.g. `verify` posts the boolean `false`, which + // must still complete the operation rather than be dropped. + if (e.data == null) { + return; + } + // onmessage will return initialized==true when the worker is first created. // we don't need to do any work yet. if (e.data.initialized === true) { @@ -226,6 +236,19 @@ var workerManager = (function() { // tslint:disable-next-line: no-unused-expression e.target || (e.target = { data: worker.data }); + // A thrown error inside the worker is posted back as a structured + // envelope (a native ErrorEvent loses the original name/code). + // Rebuild a proper DOMException and reject this operation, mirroring + // the synchronous syncWorker error path. + if (e.data.error) { + jobCompleted(worker); + op.dispatchEvent({ + type: "error", + data: utils.error(e.data.error.name, e.data.error.message) + }); + return; + } + // Check if there are queued jobs for this operation for (var i = 0; i < jobQueue.length; i++) { if (jobQueue[i].operation === worker.operation) { diff --git a/scripts/utilities.js b/src/utilities.js similarity index 88% rename from scripts/utilities.js rename to src/utilities.js index 89e5bbf..d310f1b 100644 --- a/scripts/utilities.js +++ b/src/utilities.js @@ -458,6 +458,33 @@ var msrcryptoUtilities = (function() { return result; } + function indexOf(array, searchElement, fromIndex) { + /// + /// IE8-safe replacement for Array.prototype.indexOf (added in IE9). + /// Returns the first index at which searchElement is found using strict + /// equality, or -1 if it is not present. + /// + /// The value to locate. + /// Index to start the search at. + /// + /// + + var length = array.length >>> 0; + var start = fromIndex | 0; + + if (start < 0) { + start = Math.max(length + start, 0); + } + + for (; start < length; start += 1) { + if (array[start] === searchElement) { + return start; + } + } + + return -1; + } + function verifyByteArray(array) { /// /// Verify that an Array contains only byte values (0-255) @@ -581,10 +608,45 @@ var msrcryptoUtilities = (function() { return result; } + // Legacy DOMException codes, used to populate err.code on environments + // (e.g. IE8) that lack a usable DOMException constructor. + var domExceptionCodes = { + IndexSizeError: 1, HierarchyRequestError: 3, WrongDocumentError: 4, + InvalidCharacterError: 5, NoModificationAllowedError: 7, NotFoundError: 8, + NotSupportedError: 9, InUseAttributeError: 10, InvalidStateError: 11, + SyntaxError: 12, InvalidModificationError: 13, NamespaceError: 14, + InvalidAccessError: 15, TypeMismatchError: 17, SecurityError: 18, + NetworkError: 19, AbortError: 20, URLMismatchError: 21, + QuotaExceededError: 22, TimeoutError: 23, InvalidNodeTypeError: 24, + DataCloneError: 25 + }; + function error(name, message) { - var err = Error(message); - err.name = name; - throw err; + /// + /// Creates an error matching the WebCrypto specification. + /// Returns a DOMException with the given name where the constructor + /// is available, otherwise an Error with the name (and legacy code) + /// set so consumers can still branch on err.name. + /// The DOMException name, e.g. "OperationError". + /// + /// + /// + + message = message || ""; + + try { + // DOMException is a global in browsers and web workers (and modern + // Node). The two-argument form sets the .name to the spec value. + return new DOMException(message, name); + } catch (e) { + // No usable DOMException constructor (e.g. IE8); fall back to Error. + var err = new Error(message); + err.name = name; + if (domExceptionCodes.hasOwnProperty(name)) { + err.code = domExceptionCodes[name]; + } + return err; + } } function isBytes(array) { @@ -616,6 +678,7 @@ var msrcryptoUtilities = (function() { int32ArrayToBytes: int32ArrayToBytes, toArray: toArray, arraysEqual: arraysEqual, + indexOf: indexOf, clone: clone, xorVectors: xorVectors, padEnd: padEnd, diff --git a/scripts/worker.js b/src/worker.js similarity index 57% rename from scripts/worker.js rename to src/worker.js index 899aea5..e58db48 100644 --- a/scripts/worker.js +++ b/src/worker.js @@ -42,11 +42,33 @@ var msrcryptoWorker = (function() { operationSubType = e.data.operationSubType; var operation = e.data.operationType, + algorithmName = e.data.algorithm.name, result, - func = operations[operation][e.data.algorithm.name], p = e.data; - if (!operations.exists(operation, e.data.algorithm.name)) { + // Resolve the registered handler with the dynamic lookup, the + // own-property checks, and the function-type check all performed + // locally, using the direct obj.hasOwnProperty(name) form shown in + // CodeQL's "unvalidated dynamic method call" guidance. The registry + // of registered operations is itself the whitelist: a user-supplied + // operation/algorithm name is only honored when it is an own, + // registered property — so it can never dispatch to an inherited + // Object.prototype member (valueOf, hasOwnProperty, ...) or to a + // non-function value. + if (!operations.hasOwnProperty(operation)) { + throw new Error("unregistered algorithm."); + } + + var algorithmMap = operations[operation]; + + if (typeof algorithmMap !== "object" || algorithmMap === null || + !algorithmMap.hasOwnProperty(algorithmName)) { + throw new Error("unregistered algorithm."); + } + + var func = algorithmMap[algorithmName]; + + if (typeof func !== "function") { throw new Error("unregistered algorithm."); } @@ -84,7 +106,24 @@ if (runningInWorkerInstance) { } // Process the crypto operation - if (workerInitialized === true) { msrcryptoWorker.jsCryptoRunner(e); } + if (workerInitialized === true) { + try { + msrcryptoWorker.jsCryptoRunner(e); + } catch (ex) { + // A real web worker surfaces a thrown error as an ErrorEvent on + // the main thread, stripped of the original name/code (and it + // also bubbles as an uncaught error). Post a serializable + // envelope instead so the worker manager can rebuild a proper + // DOMException, matching the synchronous syncWorker path. + msrcryptoWorker.returnResult({ + error: { + name: (ex && ex.name) || "OperationError", + message: (ex && ex.message) || "", + code: (ex && ex.code) || 0 + } + }); + } + } }; } diff --git a/test/SubtleTests.html b/test/SubtleTests.html new file mode 100644 index 0000000..ce4121f --- /dev/null +++ b/test/SubtleTests.html @@ -0,0 +1,219 @@ + + + + + + + + + + Subtle Tests + + + + + + + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/scripts/tests/Test.Aes.Cbc.js b/test/Test.Aes.Cbc.js similarity index 100% rename from scripts/tests/Test.Aes.Cbc.js rename to test/Test.Aes.Cbc.js diff --git a/scripts/tests/Test.Aes.Gcm.js b/test/Test.Aes.Gcm.js similarity index 100% rename from scripts/tests/Test.Aes.Gcm.js rename to test/Test.Aes.Gcm.js diff --git a/scripts/tests/Test.Aes.Kw.js b/test/Test.Aes.Kw.js similarity index 100% rename from scripts/tests/Test.Aes.Kw.js rename to test/Test.Aes.Kw.js diff --git a/scripts/tests/Test.ConcatKdf.js b/test/Test.ConcatKdf.js similarity index 100% rename from scripts/tests/Test.ConcatKdf.js rename to test/Test.ConcatKdf.js diff --git a/test/Test.CryptoKey.js b/test/Test.CryptoKey.js new file mode 100644 index 0000000..9046d02 --- /dev/null +++ b/test/Test.CryptoKey.js @@ -0,0 +1,121 @@ +//******************************************************************************* +// +// Copyright 2020 Microsoft +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//******************************************************************************* + +"use strict"; + +QUnit.module("CryptoKey"); + +QUnit.test("CryptoKey constructor is exposed at the library root", function(assert) { + assert.equal(typeof msrCrypto.CryptoKey, "function", "msrCrypto.CryptoKey should be a function"); +}); + +QUnit.test("CryptoKey is not directly constructible", function(assert) { + assert.throws( + function() { return new msrCrypto.CryptoKey(); }, + /Illegal constructor/, + "calling 'new CryptoKey()' should throw 'Illegal constructor'"); +}); + +QUnit.test("generateKey returns CryptoKey instances", function(assert) { + var done = assert.async(); + + subtle.generateKey({ name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"]) + .then(function(key) { + assert.ok(key instanceof msrCrypto.CryptoKey, "secret key is an instance of CryptoKey"); + return subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, true, ["sign", "verify"]); + }) + .then(function(keyPair) { + assert.ok(keyPair.publicKey instanceof msrCrypto.CryptoKey, "public key is an instance of CryptoKey"); + assert.ok(keyPair.privateKey instanceof msrCrypto.CryptoKey, "private key is an instance of CryptoKey"); + done(); + }) + // IE8 will not allow .catch() + // tslint:disable-next-line: no-string-literal + ["catch"](function(error) { + assert.ok(false, error ? error.toString() : "unexpected error"); + done(); + }); +}); + +QUnit.test("importKey returns a CryptoKey", function(assert) { + var done = assert.async(); + + var rawKey = msrCrypto.fromBase64("AAECAwQFBgcICQoLDA0ODw=="); + + subtle.importKey("raw", rawKey, { name: "AES-GCM" }, true, ["encrypt", "decrypt"]) + .then(function(key) { + assert.ok(key instanceof msrCrypto.CryptoKey, "imported key is an instance of CryptoKey"); + done(); + }) + // IE8 will not allow .catch() + // tslint:disable-next-line: no-string-literal + ["catch"](function(error) { + assert.ok(false, error ? error.toString() : "unexpected error"); + done(); + }); +}); + +QUnit.test("CryptoKey exposes only metadata and no key material", function(assert) { + var done = assert.async(); + + subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, true, ["sign", "verify"]) + .then(function(keyPair) { + var privateKey = keyPair.privateKey; + + assert.equal(privateKey.type, "private", "type attribute is exposed"); + assert.equal(privateKey.extractable, true, "extractable attribute is exposed"); + assert.equal(privateKey.algorithm.name, "ECDSA", "algorithm attribute is exposed"); + assert.deepEqual(privateKey.usages, ["sign"], "usages attribute is exposed"); + + // Secret material must not be stored on the CryptoKey itself. + assert.equal(privateKey.d, undefined, "private scalar 'd' is not on the CryptoKey"); + assert.equal(privateKey.keyData, undefined, "keyData is not on the CryptoKey"); + + done(); + }) + // IE8 will not allow .catch() + // tslint:disable-next-line: no-string-literal + ["catch"](function(error) { + assert.ok(false, error ? error.toString() : "unexpected error"); + done(); + }); +}); + +QUnit.test("a returned CryptoKey can be used in a subsequent operation", function(assert) { + var done = assert.async(); + + var data = [1, 2, 3, 4, 5]; + + subtle.generateKey({ name: "HMAC", hash: "SHA-256" }, true, ["sign", "verify"]) + .then(function(key) { + return subtle.sign({ name: "HMAC" }, key, data) + .then(function(signature) { + return subtle.verify({ name: "HMAC" }, key, testShared.toArray(signature), data); + }); + }) + .then(function(isValid) { + assert.ok(isValid, "sign/verify using the returned CryptoKey succeeds"); + done(); + }) + // IE8 will not allow .catch() + // tslint:disable-next-line: no-string-literal + ["catch"](function(error) { + assert.ok(false, error ? error.toString() : "unexpected error"); + done(); + }); +}); diff --git a/scripts/tests/Test.Ecdh.js b/test/Test.Ecdh.js similarity index 87% rename from scripts/tests/Test.Ecdh.js rename to test/Test.Ecdh.js index 1bf3763..41adae3 100644 --- a/scripts/tests/Test.Ecdh.js +++ b/test/Test.Ecdh.js @@ -83,6 +83,36 @@ function ecdhTests() { ts.keyPairImportExportTest(ecdh.p521.jwk, undefined, undefined, context(iterations, assert)); }); + QUnit.test(label + " key import jwk re-pads leading-zero-trimmed P-256 ", function(assert) { + // Regression: a private 'd' (and x/y) supplied with leading zeros trimmed + // must be accepted on import and re-padded to the full curve element + // length on export (32 bytes for P-256), matching Chrome/Chromium. + var vector = ecdh.p256.jwkTrimmed; + var expected = vector.expectedPrivateKey; + var elementLength = vector.elementLength; + var done = assert.async(); + + subtle.importKey("jwk", vector.trimmedPrivateKey, vector.algorithm, true, vector.trimmedPrivateKey.key_ops) + .then(function(key) { + return subtle.exportKey("jwk", key); + }) + .then(function(jwk) { + assert.equal(msrCrypto.fromBase64(jwk.d).length, elementLength, "exported 'd' is full curve length"); + assert.equal(msrCrypto.fromBase64(jwk.x).length, elementLength, "exported 'x' is full curve length"); + assert.equal(msrCrypto.fromBase64(jwk.y).length, elementLength, "exported 'y' is full curve length"); + assert.equal(jwk.d, expected.d, "exported 'd' matches the zero-padded value"); + assert.equal(jwk.x, expected.x, "exported 'x' matches the zero-padded value"); + assert.equal(jwk.y, expected.y, "exported 'y' matches the zero-padded value"); + done(); + }) + // IE8 will not allow .catch() + // tslint:disable-next-line: no-string-literal + ["catch"](function(error) { + assert.ok(false, error ? error.toString() : "unexpected error"); + done(); + }); + }); + QUnit.test(label + " generateKeyTest P-256", function(assert) { ts.keyGeneratePairTest(ecdhKeyAlg("P-256"), ["deriveKey", "deriveBits"], inspectEcdhKey, context(iterations, assert)); }); @@ -216,7 +246,7 @@ var inspectEcdhKey = { var fail = []; var expLenMax = ecdhKeyLengths[algorithm.namedCurve]; - var expLenMin = expLenMax - 2; + var expLenMin = expLenMax; // has crv property equal to "P-521" if (!validation.prop.string(keyObj, "crv", algorithm.namedCurve)) { @@ -275,7 +305,7 @@ var inspectEcdhKey = { // } var expLenMax = ecdhKeyLengths[algorithm.namedCurve]; - var expLenMin = expLenMax - 2; + var expLenMin = expLenMax; this.public(keyObj, algorithm, usages, reason); diff --git a/scripts/tests/Test.Ecdsa.js b/test/Test.Ecdsa.js similarity index 91% rename from scripts/tests/Test.Ecdsa.js rename to test/Test.Ecdsa.js index c63c3ac..e0b8215 100644 --- a/scripts/tests/Test.Ecdsa.js +++ b/test/Test.Ecdsa.js @@ -115,6 +115,36 @@ function ecdsaTests() { ts.keyPairImportExportTest( ecdsa.p521.jwk, undefined, undefined, context( iterations, assert ) ); } ); + QUnit.test( label + " key import jwk re-pads leading-zero-trimmed P-256", function( assert ) { + // Regression: a private 'd' (and x/y) supplied with leading zeros trimmed + // must be accepted on import and re-padded to the full curve element + // length on export (32 bytes for P-256), matching Chrome/Chromium. + var vector = ecdsa.p256.jwkTrimmed; + var expected = vector.expectedPrivateKey; + var elementLength = vector.elementLength; + var done = assert.async(); + + subtle.importKey( "jwk", vector.trimmedPrivateKey, vector.algorithm, true, vector.trimmedPrivateKey.key_ops ) + .then( function( key ) { + return subtle.exportKey( "jwk", key ); + } ) + .then( function( jwk ) { + assert.equal( msrCrypto.fromBase64( jwk.d ).length, elementLength, "exported 'd' is full curve length" ); + assert.equal( msrCrypto.fromBase64( jwk.x ).length, elementLength, "exported 'x' is full curve length" ); + assert.equal( msrCrypto.fromBase64( jwk.y ).length, elementLength, "exported 'y' is full curve length" ); + assert.equal( jwk.d, expected.d, "exported 'd' matches the zero-padded value" ); + assert.equal( jwk.x, expected.x, "exported 'x' matches the zero-padded value" ); + assert.equal( jwk.y, expected.y, "exported 'y' matches the zero-padded value" ); + done(); + } ) + // IE8 will not allow .catch() + // tslint:disable-next-line: no-string-literal + ["catch"]( function( error ) { + assert.ok( false, error ? error.toString() : "unexpected error" ); + done(); + } ); + } ); + QUnit.test(label + " key import/export spki P-256 ", function(assert) { @@ -421,7 +451,7 @@ var inspectEcdsaKey = { var fail = []; var expLenMax = ecdsaKeyLengths[algorithm.namedCurve]; - var expLenMin = expLenMax - 2; + var expLenMin = expLenMax; // has crv property equal to "P-521" if (!validation.prop.string(keyObj, "crv", algorithm.namedCurve)) { @@ -462,27 +492,9 @@ var inspectEcdsaKey = { return (fail.length === 0); }, private: function(keyObj, algorithm, usages, reason) { - // { - // "publicKey": - // { - // "crv": "P-521", - // "ext": true, - // "key_ops": [], - // "kty": "EC", - // "x": "AcThC2XVslnUodlFE7a1GduKl_Y4ZwqKEImbmCQR-qeE72TOks3vymiVTjHF84S4ASboyCdGuXrBtuYVUO9DZwTo", - // "y": "AZCxpia5Bs9rGZ_BVLuFLb5vZbIg2zQnsCkPrNuZC_yyn95o1C9QhdHtgG6AN0doU5szQ_Rpb72LPOj1phStohBn" - // }, - // "privateKey": { - // // all of public key + d - // "key_ops": ["deriveBits", "deriveKey"], - // "d": "ACdJfF-OVXloqPVvwMAc770Grkogs6FctANcyQ9elPJesD1hUxJ_ihR_1q-7t4P218dVL2PfbA6LCBiQcNG6jR6w", - // } - // } - - // var hashLen = algorithm.hash.name.slice(algorithm.hash.name.indexOf("-")); var expLenMax = ecdsaKeyLengths[algorithm.namedCurve]; - var expLenMin = expLenMax - 2; + var expLenMin = expLenMax; this.public(keyObj, algorithm, usages, reason); diff --git a/scripts/tests/Test.Encoding.js b/test/Test.Encoding.js similarity index 100% rename from scripts/tests/Test.Encoding.js rename to test/Test.Encoding.js diff --git a/test/Test.Errors.js b/test/Test.Errors.js new file mode 100644 index 0000000..90d24cc --- /dev/null +++ b/test/Test.Errors.js @@ -0,0 +1,181 @@ +//******************************************************************************* +// +// Copyright 2020 Microsoft +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//******************************************************************************* + +"use strict"; + +QUnit.module("Errors"); + +// Asserts that 'promise' rejects (never resolves) with a DOMException whose +// name matches 'expectedName'. +function assertRejectsWith(assert, promise, expectedName, description) { + var done = assert.async(); + + promise + .then(function() { + assert.ok(false, description + ": expected a rejection but the promise resolved"); + done(); + }) + // IE8 will not allow .catch() + // tslint:disable-next-line: no-string-literal + ["catch"](function(err) { + assert.equal(err && err.name, expectedName, description + ": rejects with " + expectedName); + if (typeof DOMException !== "undefined") { + assert.ok(err instanceof DOMException, description + ": error is a DOMException"); + } + done(); + }); +} + +// A subtle method that is given a bad algorithm/parameters must surface the +// error as a rejected promise, never as a synchronous throw (WebCrypto contract). +QUnit.test("subtle methods reject (do not throw synchronously) on bad input", function(assert) { + var data = [97, 98, 99]; + + var promise = subtle.digest({ name: "NOT-A-REAL-ALGORITHM" }, data); + + assert.ok(promise && typeof promise.then === "function", + "digest returns a promise even for an unsupported algorithm"); + + assertRejectsWith(assert, promise, "NotSupportedError", + "digest with an unrecognized algorithm"); +}); + +QUnit.test("unrecognized algorithm rejects with NotSupportedError", function(assert) { + assertRejectsWith(assert, subtle.encrypt({ name: "BOGUS-CBC" }, {}, [1, 2, 3]), + "NotSupportedError", "encrypt with an unrecognized algorithm"); +}); + +QUnit.test("missing required argument rejects with a TypeError", function(assert) { + var done = assert.async(); + + subtle.digest() + .then(function() { + assert.ok(false, "digest() with no arguments should reject"); + done(); + }) + // tslint:disable-next-line: no-string-literal + ["catch"](function(err) { + assert.ok(err instanceof TypeError, "missing argument rejects with a TypeError"); + done(); + }); +}); + +QUnit.test("AES-GCM rejects with OperationError when authentication fails", function(assert) { + var done = assert.async(); + var iv = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]; + + subtle.generateKey({ name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"]) + .then(function(key) { + return subtle.encrypt({ name: "AES-GCM", iv: iv }, key, [1, 2, 3, 4, 5]) + .then(function(cipher) { + var tampered = testShared.toArray(cipher); + tampered[0] ^= 0xff; // corrupt the ciphertext so the tag check fails + return subtle.decrypt({ name: "AES-GCM", iv: iv }, key, tampered); + }); + }) + .then(function() { + assert.ok(false, "decrypting tampered AES-GCM data should reject"); + done(); + }) + // tslint:disable-next-line: no-string-literal + ["catch"](function(err) { + assert.equal(err && err.name, "OperationError", "tampered AES-GCM data rejects with OperationError"); + if (typeof DOMException !== "undefined") { + assert.ok(err instanceof DOMException, "error is a DOMException"); + } + done(); + }); +}); + +QUnit.test("wrapKey rejects with InvalidAccessError when the wrapping key lacks 'wrapKey' usage", function(assert) { + var done = assert.async(); + + Promise.all([ + // wrapping key can encrypt/decrypt but is NOT allowed to wrapKey + subtle.generateKey({ name: "AES-CBC", length: 256 }, true, ["encrypt", "decrypt"]), + subtle.generateKey({ name: "AES-CBC", length: 128 }, true, ["encrypt", "decrypt"]) + ]) + .then(function(keys) { + var wrappingKey = keys[0]; + var keyToWrap = keys[1]; + return subtle.wrapKey("raw", keyToWrap, wrappingKey, + { name: "AES-CBC", iv: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] }); + }) + .then(function() { + assert.ok(false, "wrapKey with a key lacking 'wrapKey' usage should reject"); + done(); + }) + // tslint:disable-next-line: no-string-literal + ["catch"](function(err) { + assert.equal(err && err.name, "InvalidAccessError", "wrapKey rejects with InvalidAccessError"); + done(); + }); +}); + +QUnit.test("importing a malformed EC point rejects with DataError", function(assert) { + // 65 bytes that are not a valid uncompressed P-256 point (leading byte != 4). + var badPoint = []; + for (var i = 0; i < 65; i += 1) { badPoint.push(i); } + + assertRejectsWith(assert, subtle.importKey("raw", badPoint, { name: "ECDSA", namedCurve: "P-256" }, true, ["verify"]), + "DataError", "importKey of a malformed EC point"); +}); + +QUnit.test("getRandomValues throws QuotaExceededError past 65,536 bytes", function(assert) { + // Fall back to a regular Array where TypedArrays are unavailable (e.g. IE8); + // getRandomValues enforces the quota on the array's length either way. + var oversized = (typeof Uint8Array !== "undefined") ? new Uint8Array(65537) : new Array(65537); + + assert.throws( + function() { msrCrypto.getRandomValues(oversized); }, + function(err) { + return err && err.name === "QuotaExceededError" && + (typeof DOMException === "undefined" || err instanceof DOMException); + }, + "an oversized array throws QuotaExceededError"); +}); + +QUnit.test("getRandomValues throws TypeMismatchError for floating-point arrays", function(assert) { + if (typeof Float32Array === "undefined") { + assert.ok(true, "TypedArrays not supported - skipped"); + return; + } + + assert.throws( + function() { msrCrypto.getRandomValues(new Float32Array(4)); }, + function(err) { + return err && err.name === "TypeMismatchError" && + (typeof DOMException === "undefined" || err instanceof DOMException); + }, + "a floating-point typed array throws TypeMismatchError"); +}); + +QUnit.test("getRandomValues fills and returns the same array for valid input", function(assert) { + // Where TypedArrays are unavailable (e.g. IE8) getRandomValues accepts and + // returns a regular Array instead. + var array = (typeof Uint8Array !== "undefined") ? new Uint8Array(16) : new Array(16); + var result = msrCrypto.getRandomValues(array); + + assert.strictEqual(result, array, "returns the same array instance that was passed in"); + + var nonZero = false; + for (var i = 0; i < array.length; i += 1) { + if (array[i] !== 0) { nonZero = true; break; } + } + assert.ok(nonZero, "the array was populated with random values"); +}); diff --git a/scripts/tests/Test.Hkdf.js b/test/Test.Hkdf.js similarity index 100% rename from scripts/tests/Test.Hkdf.js rename to test/Test.Hkdf.js diff --git a/scripts/tests/Test.HkdfCtr.js b/test/Test.HkdfCtr.js similarity index 100% rename from scripts/tests/Test.HkdfCtr.js rename to test/Test.HkdfCtr.js diff --git a/scripts/tests/Test.Hmac.js b/test/Test.Hmac.js similarity index 73% rename from scripts/tests/Test.Hmac.js rename to test/Test.Hmac.js index d71434b..6e4b238 100644 --- a/scripts/tests/Test.Hmac.js +++ b/test/Test.Hmac.js @@ -44,6 +44,62 @@ function hmacTests() { ts.keyGenerateTest( hmacKeyAlg( "SHA-512" ), hmacUsages, inspectHmacKey, context( iterations, assert ) ); } ); + // Verify that an explicit `length` (in bits, per the Web Crypto spec) produces a key + // of the requested byte length, and that omitting `length` defaults to the hash block size. + QUnit.test( label + " generateKey optional length (bits)", function( assert ) { + + var blockSizeBytes = { "SHA-1": 64, "SHA-256": 64, "SHA-384": 128, "SHA-512": 128 }; + + var cases = [ + { hash: "SHA-256", length: 256, expectedBytes: 32 }, + { hash: "SHA-256", length: 128, expectedBytes: 16 }, + { hash: "SHA-1", length: 160, expectedBytes: 20 }, + { hash: "SHA-512", length: 1024, expectedBytes: 128 }, + { hash: "SHA-384", length: 512, expectedBytes: 64 }, + { hash: "SHA-256", length: undefined, expectedBytes: blockSizeBytes["SHA-256"] }, + { hash: "SHA-384", length: undefined, expectedBytes: blockSizeBytes["SHA-384"] } + ]; + + var done = assert.async( cases.length ); + + // Use a plain for-loop with a per-iteration helper instead of + // Array.prototype.forEach (not available on IE8) and capture each + // testCase in its own scope so the async callbacks see the right one. + function runCase( testCase ) { + + var algorithm = { name: "HMAC", hash: { name: testCase.hash } }; + if ( testCase.length !== undefined ) { + algorithm.length = testCase.length; + } + + subtle.generateKey( algorithm, true, [SIGN, VERIFY] ) + .then( function( key ) { + return subtle.exportKey( "raw", key ); + } ) + .then( function( raw ) { + // testShared.toArray is IE8/9-safe (no Uint8Array there). + var byteLength = testShared.toArray( raw ).length; + assert.equal( + byteLength, + testCase.expectedBytes, + testCase.hash + " length=" + + ( testCase.length === undefined ? "(default)" : testCase.length ) + + " => " + testCase.expectedBytes + " bytes" ); + done(); + } ) + // IE8 will not allow .catch() + // tslint:disable-next-line: no-string-literal + ["catch"]( function( error ) { + assert.ok( false, error ? error.toString() : "unexpected error" ); + done(); + } ); + } + + for ( var i = 0; i < cases.length; i++ ) { + runCase( cases[i] ); + } + } ); + QUnit.test( label + " verify native signature SHA-1 ", function( assert ) { ts.verifyNativeSignatureTest( hmacKeyAlg( "SHA-1" ), hmac.sign_verify.sha1, context( iterations, assert ) ); diff --git a/scripts/tests/Test.Pbkdf2.js b/test/Test.Pbkdf2.js similarity index 100% rename from scripts/tests/Test.Pbkdf2.js rename to test/Test.Pbkdf2.js diff --git a/scripts/tests/Test.Prng.js b/test/Test.Prng.js similarity index 100% rename from scripts/tests/Test.Prng.js rename to test/Test.Prng.js diff --git a/scripts/tests/Test.Promise.js b/test/Test.Promise.js similarity index 76% rename from scripts/tests/Test.Promise.js rename to test/Test.Promise.js index 124a412..8f5c51b 100644 --- a/scripts/tests/Test.Promise.js +++ b/test/Test.Promise.js @@ -514,3 +514,128 @@ QUnit.test( "Promise.reject", function( assert ) { } ); } ); + +/// ===== rejection propagation through handler-less then() ========= + +QUnit.test( "Promise.catch after then() chain with no rejection handlers (sync)", function( assert ) { + var done = assert.async(); /// + /// A rejection must propagate through then() calls that provide no rejection + /// handler and reach a trailing catch(). Regression test for a polyfill bug + /// that silently dropped such rejections. + /// + + new Promise( promiseTest.executorFailSync( 4 ) ) + .then( function( result ) { return result + 1; } ) + .then( function( result ) { return result + 1; } ) + ["catch"]( function( reason ) { + assert.equal( reason, 4 ); + done(); + } ); + +} ); + +QUnit.test( "Promise.catch after then() chain with no rejection handlers (async)", function( assert ) { + var done = assert.async(); + + new Promise( promiseTest.executorFailAsync( 4, 200 ) ) + .then( function( result ) { return result + 1; } ) + .then( function( result ) { return result + 1; } ) + ["catch"]( function( reason ) { + assert.equal( reason, 4 ); + done(); + } ); + +} ); + +QUnit.test( "Promise.then() rejection handler skips success handlers", function( assert ) { + var done = assert.async(); /// + /// When a promise rejects, intervening success handlers are skipped and the + /// next rejection handler (here the onRejected argument of then) receives the + /// reason. + /// + + new Promise( promiseTest.executorFailSync( 4 ) ) + .then( function() { assert.ok( false, "success handler should not run" ); } ) + .then( + function() { assert.ok( false, "success handler should not run" ); }, + function( reason ) { + assert.equal( reason, 4 ); + done(); + } ); + +} ); + +QUnit.test( "Promise throw inside then() routes to catch()", function( assert ) { + var done = assert.async(); /// + /// A synchronous throw inside a then() handler must reject the chained + /// promise so a downstream catch() receives the thrown error. + /// + + new Promise( promiseTest.executorSync( 1 ) ) + .then( function() { throw "inThen"; } ) + .then( function() { assert.ok( false, "success handler should not run" ); } ) + ["catch"]( function( reason ) { + assert.equal( reason, "inThen" ); + done(); + } ); + +} ); + +QUnit.test( "Promise throw inside catch() routes to next catch()", function( assert ) { + var done = assert.async(); /// + /// A throw inside a catch() handler rejects the chained promise rather than + /// being swallowed. + /// + + new Promise( promiseTest.executorFailSync( 1 ) ) + ["catch"]( function() { throw "inCatch"; } ) + ["catch"]( function( reason ) { + assert.equal( reason, "inCatch" ); + done(); + } ); + +} ); + +QUnit.test( "Promise fulfillment passes through catch() to then()", function( assert ) { + var done = assert.async(); /// + /// A fulfilled value passes through catch() (whose handler is skipped) and + /// reaches the following then(). + /// + + new Promise( promiseTest.executorSync( "ok" ) ) + ["catch"]( function() { return "shouldNotRun"; } ) + .then( function( result ) { + assert.equal( result, "ok" ); + done(); + } ); + +} ); + +QUnit.test( "Promise recovery: catch() returns a value then chain continues", function( assert ) { + var done = assert.async(); /// + /// After a rejection is handled by catch(), the returned value fulfills the + /// chained promise so a following then() runs. + /// + + new Promise( promiseTest.executorFailSync( 4 ) ) + .then( function( result ) { return result + 1; } ) + ["catch"]( function( reason ) { return reason + 10; } ) + .then( function( result ) { + assert.equal( result, 14 ); + done(); + } ); + +} ); + +QUnit.test( "Promise executor throw rejects the promise", function( assert ) { + var done = assert.async(); /// + /// A throw from the executor function rejects the promise. + /// + + new Promise( function() { throw "executorError"; } ) + ["catch"]( function( reason ) { + assert.equal( reason, "executorError" ); + done(); + } ); + +} ); diff --git a/scripts/tests/Test.Rsa.Es.js b/test/Test.Rsa.Es.js similarity index 100% rename from scripts/tests/Test.Rsa.Es.js rename to test/Test.Rsa.Es.js diff --git a/scripts/tests/Test.Rsa.Oaep.js b/test/Test.Rsa.Oaep.js similarity index 100% rename from scripts/tests/Test.Rsa.Oaep.js rename to test/Test.Rsa.Oaep.js diff --git a/scripts/tests/Test.Rsa.Pss.js b/test/Test.Rsa.Pss.js similarity index 100% rename from scripts/tests/Test.Rsa.Pss.js rename to test/Test.Rsa.Pss.js diff --git a/scripts/tests/Test.Rsa.Ssa.js b/test/Test.Rsa.Ssa.js similarity index 100% rename from scripts/tests/Test.Rsa.Ssa.js rename to test/Test.Rsa.Ssa.js diff --git a/scripts/tests/Test.Sha2.js b/test/Test.Sha2.js similarity index 100% rename from scripts/tests/Test.Sha2.js rename to test/Test.Sha2.js diff --git a/scripts/tests/Test.Shared.js b/test/Test.Shared.js similarity index 99% rename from scripts/tests/Test.Shared.js rename to test/Test.Shared.js index 150445f..90b39ad 100644 --- a/scripts/tests/Test.Shared.js +++ b/test/Test.Shared.js @@ -43,7 +43,7 @@ function slowTest() { } -// Microsoft Edges does not export key_ops or alg properties +// Microsoft Edge does not export key_ops or alg properties // unless keyImport included those properties // So, generateKey will be missing key_ops & alg // This will check if this is happening diff --git a/test/Test.WrapKey.js b/test/Test.WrapKey.js new file mode 100644 index 0000000..c5c30a6 --- /dev/null +++ b/test/Test.WrapKey.js @@ -0,0 +1,158 @@ +//******************************************************************************* +// +// Copyright 2020 Microsoft +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//******************************************************************************* + +"use strict"; + +QUnit.module("Wrap Key"); + +// Exercises subtle.wrapKey / subtle.unwrapKey as a round-trip: a freshly +// generated AES key is exported, wrapped with a wrapping key, unwrapped with +// the matching unwrapping key, and the recovered key material is compared to +// the original. A match proves wrap and unwrap are inverse operations for the +// given algorithm and key format. +function wrapUnwrapRoundTrip(assert, options) { + var done = assert.async(); + + var originalRaw; + var keyToWrap; + var wrappingKey; + var unwrappingKey; + + Promise.all([options.generateKeyToWrap(), options.generateWrappingKeys()]) + .then(function(results) { + keyToWrap = results[0]; + wrappingKey = results[1].wrappingKey; + unwrappingKey = results[1].unwrappingKey; + return subtle.exportKey("raw", keyToWrap); + }) + .then(function(raw) { + originalRaw = testShared.toArray(raw); + return subtle.wrapKey(options.format, keyToWrap, wrappingKey, options.wrapAlgorithm); + }) + .then(function(wrapped) { + // Pass the wrapped key through unchanged: native WebCrypto requires a + // BufferSource (ArrayBuffer/TypedArray) here, not a plain Array. + return subtle.unwrapKey(options.format, wrapped, unwrappingKey, + options.wrapAlgorithm, options.unwrappedKeyAlgorithm, true, options.unwrappedKeyUsages); + }) + .then(function(unwrappedKey) { + return subtle.exportKey("raw", unwrappedKey); + }) + .then(function(roundTrippedRaw) { + assert.deepEqual(testShared.toArray(roundTrippedRaw), originalRaw, + "unwrapped key material matches the original"); + done(); + }) + // IE8 will not allow .catch() + // tslint:disable-next-line: no-string-literal + ["catch"](function(err) { + assert.ok(false, "round-trip failed: " + (err && (err.name || err))); + done(); + }); +} + +// The key that gets wrapped in every test: an extractable AES-CBC key whose +// raw bytes can be compared before and after the round-trip. +function generateAesKeyToWrap() { + return subtle.generateKey({ name: "AES-CBC", length: 128 }, true, ["encrypt", "decrypt"]); +} + +// Builds a symmetric wrapping/unwrapping pair where the same key does both. +function symmetricWrappingKeys(algorithm) { + return function() { + return subtle.generateKey(algorithm, true, ["wrapKey", "unwrapKey"]).then(function(key) { + return { wrappingKey: key, unwrappingKey: key }; + }); + }; +} + +// Builds an RSA-OAEP key pair: the public key wraps, the private key unwraps. +function rsaWrappingKeys() { + // Native WebCrypto requires publicExponent as a Uint8Array; fall back to a + // plain Array where TypedArrays are unavailable (e.g. IE8 + msrCrypto). + var publicExponent = (typeof Uint8Array !== "undefined") + ? new Uint8Array([0x01, 0x00, 0x01]) + : [0x01, 0x00, 0x01]; + + return subtle.generateKey( + { name: "RSA-OAEP", modulusLength: 1024, publicExponent: publicExponent, hash: "SHA-256" }, + true, + ["wrapKey", "unwrapKey"]) + .then(function(keyPair) { + return { wrappingKey: keyPair.publicKey, unwrappingKey: keyPair.privateKey }; + }); +} + +var wrapIv = (typeof Uint8Array !== "undefined") + ? new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) + : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]; + +QUnit.test("AES-KW wraps and unwraps a raw AES key", function(assert) { + wrapUnwrapRoundTrip(assert, { + format: "raw", + wrapAlgorithm: { name: "AES-KW" }, + generateKeyToWrap: generateAesKeyToWrap, + generateWrappingKeys: symmetricWrappingKeys({ name: "AES-KW", length: 256 }), + unwrappedKeyAlgorithm: { name: "AES-CBC" }, + unwrappedKeyUsages: ["encrypt", "decrypt"] + }); +}); + +QUnit.test("AES-CBC wraps and unwraps a raw AES key", function(assert) { + wrapUnwrapRoundTrip(assert, { + format: "raw", + wrapAlgorithm: { name: "AES-CBC", iv: wrapIv }, + generateKeyToWrap: generateAesKeyToWrap, + generateWrappingKeys: symmetricWrappingKeys({ name: "AES-CBC", length: 256 }), + unwrappedKeyAlgorithm: { name: "AES-CBC" }, + unwrappedKeyUsages: ["encrypt", "decrypt"] + }); +}); + +QUnit.test("AES-GCM wraps and unwraps a raw AES key", function(assert) { + wrapUnwrapRoundTrip(assert, { + format: "raw", + wrapAlgorithm: { name: "AES-GCM", iv: wrapIv }, + generateKeyToWrap: generateAesKeyToWrap, + generateWrappingKeys: symmetricWrappingKeys({ name: "AES-GCM", length: 256 }), + unwrappedKeyAlgorithm: { name: "AES-CBC" }, + unwrappedKeyUsages: ["encrypt", "decrypt"] + }); +}); + +QUnit.test("AES-GCM wraps and unwraps a key in jwk format", function(assert) { + wrapUnwrapRoundTrip(assert, { + format: "jwk", + wrapAlgorithm: { name: "AES-GCM", iv: wrapIv }, + generateKeyToWrap: generateAesKeyToWrap, + generateWrappingKeys: symmetricWrappingKeys({ name: "AES-GCM", length: 256 }), + unwrappedKeyAlgorithm: { name: "AES-CBC" }, + unwrappedKeyUsages: ["encrypt", "decrypt"] + }); +}); + +QUnit.test("RSA-OAEP wraps and unwraps a raw AES key", function(assert) { + wrapUnwrapRoundTrip(assert, { + format: "raw", + wrapAlgorithm: { name: "RSA-OAEP" }, + generateKeyToWrap: generateAesKeyToWrap, + generateWrappingKeys: rsaWrappingKeys, + unwrappedKeyAlgorithm: { name: "AES-CBC" }, + unwrappedKeyUsages: ["encrypt", "decrypt"] + }); +}); diff --git a/scripts/testVectors/tv_aes_cbc.js b/test/vectors/tv_aes_cbc.js similarity index 100% rename from scripts/testVectors/tv_aes_cbc.js rename to test/vectors/tv_aes_cbc.js diff --git a/scripts/testVectors/tv_aes_gcm.js b/test/vectors/tv_aes_gcm.js similarity index 100% rename from scripts/testVectors/tv_aes_gcm.js rename to test/vectors/tv_aes_gcm.js diff --git a/scripts/testVectors/tv_aes_kw.js b/test/vectors/tv_aes_kw.js similarity index 100% rename from scripts/testVectors/tv_aes_kw.js rename to test/vectors/tv_aes_kw.js diff --git a/scripts/testVectors/tv_concatkdf.js b/test/vectors/tv_concatkdf.js similarity index 100% rename from scripts/testVectors/tv_concatkdf.js rename to test/vectors/tv_concatkdf.js diff --git a/scripts/testVectors/tv_ecdh.js b/test/vectors/tv_ecdh.js similarity index 99% rename from scripts/testVectors/tv_ecdh.js rename to test/vectors/tv_ecdh.js index a591f9b..4692e64 100644 --- a/scripts/testVectors/tv_ecdh.js +++ b/test/vectors/tv_ecdh.js @@ -224,6 +224,17 @@ ecdh.p256.jwk = { ] }; +ecdh.p256.jwkTrimmed = { + format: "jwk", + algorithm: { + name: "ECDH", + namedCurve: "P-256" + }, + elementLength: 32, + trimmedPrivateKey: { "crv": "P-256", "ext": true, "key_ops": ["deriveBits"], "kty": "EC", "x": "6lJdR85MW4WKPHeXbfrlgfd9DU993elUHdWwFqPz7Q0", "y": "jRndSKJUvL3OX56qp2jKDmAW-cmpF2GefeAxyWUvBIE", "d": "VG4DRmQquvHIABar_TOs3NbNlBuS0TG7TTPm0Jb6rg" }, + expectedPrivateKey: { "crv": "P-256", "ext": true, "key_ops": ["deriveBits"], "kty": "EC", "x": "6lJdR85MW4WKPHeXbfrlgfd9DU993elUHdWwFqPz7Q0", "y": "jRndSKJUvL3OX56qp2jKDmAW-cmpF2GefeAxyWUvBIE", "d": "AFRuA0ZkKrrxyAAWq_0zrNzWzZQbktExu00z5tCW-q4" } +}; + ecdh.p384.jwk = { format: "jwk", algorithm: { diff --git a/scripts/testVectors/tv_ecdsa.js b/test/vectors/tv_ecdsa.js similarity index 99% rename from scripts/testVectors/tv_ecdsa.js rename to test/vectors/tv_ecdsa.js index a3e0ebc..96bd759 100644 --- a/scripts/testVectors/tv_ecdsa.js +++ b/test/vectors/tv_ecdsa.js @@ -226,6 +226,23 @@ ecdsa.p256.jwk = { ] }; +// Interop regression vector for leading-zero handling on import. +// 'trimmedPrivateKey.d' is a valid P-256 private key whose top byte is 0x00, +// encoded with that leading zero removed (31 bytes instead of 32) as some +// non-conforming producers (e.g. older IE) emit. Importing must accept the +// short value and re-pad so the exported x/y/d are the full element length +// (32 bytes for P-256), matching 'expectedPrivateKey'. +ecdsa.p256.jwkTrimmed = { + format: "jwk", + algorithm: { + name: "ECDSA", + namedCurve: "P-256" + }, + elementLength: 32, + trimmedPrivateKey: { "crv": "P-256", "ext": true, "key_ops": ["sign"], "kty": "EC", "x": "83shLd6Ty7-buZMzqFGPq14rnyucOTafrxKfs8aDo1A", "y": "i0kIcFfMpF3okPRNm8Y3UaLjqHhpO6qkBo8e0HN-gKA", "d": "28b6bM8I4XcRdS8cfaHRcothIFaAVqtPy9U6oEKNOg" }, + expectedPrivateKey: { "crv": "P-256", "ext": true, "key_ops": ["sign"], "kty": "EC", "x": "83shLd6Ty7-buZMzqFGPq14rnyucOTafrxKfs8aDo1A", "y": "i0kIcFfMpF3okPRNm8Y3UaLjqHhpO6qkBo8e0HN-gKA", "d": "ANvG-mzPCOF3EXUvHH2h0XKLYSBWgFarT8vVOqBCjTo" } +}; + ecdsa.p384.jwk = { format: "jwk", algorithm: { diff --git a/scripts/testVectors/tv_hkdf.js b/test/vectors/tv_hkdf.js similarity index 100% rename from scripts/testVectors/tv_hkdf.js rename to test/vectors/tv_hkdf.js diff --git a/scripts/testVectors/tv_hkdfCtr.js b/test/vectors/tv_hkdfCtr.js similarity index 100% rename from scripts/testVectors/tv_hkdfCtr.js rename to test/vectors/tv_hkdfCtr.js diff --git a/scripts/testVectors/tv_hmac.js b/test/vectors/tv_hmac.js similarity index 100% rename from scripts/testVectors/tv_hmac.js rename to test/vectors/tv_hmac.js diff --git a/scripts/testVectors/tv_pbkdf2.js b/test/vectors/tv_pbkdf2.js similarity index 100% rename from scripts/testVectors/tv_pbkdf2.js rename to test/vectors/tv_pbkdf2.js diff --git a/scripts/testVectors/tv_prng.js b/test/vectors/tv_prng.js similarity index 100% rename from scripts/testVectors/tv_prng.js rename to test/vectors/tv_prng.js diff --git a/scripts/testVectors/tv_rsa_es.js b/test/vectors/tv_rsa_es.js similarity index 100% rename from scripts/testVectors/tv_rsa_es.js rename to test/vectors/tv_rsa_es.js diff --git a/scripts/testVectors/tv_rsa_oaep.js b/test/vectors/tv_rsa_oaep.js similarity index 100% rename from scripts/testVectors/tv_rsa_oaep.js rename to test/vectors/tv_rsa_oaep.js diff --git a/scripts/testVectors/tv_rsa_pss.js b/test/vectors/tv_rsa_pss.js similarity index 100% rename from scripts/testVectors/tv_rsa_pss.js rename to test/vectors/tv_rsa_pss.js diff --git a/scripts/testVectors/tv_rsa_ssa.js b/test/vectors/tv_rsa_ssa.js similarity index 100% rename from scripts/testVectors/tv_rsa_ssa.js rename to test/vectors/tv_rsa_ssa.js diff --git a/scripts/testVectors/tv_sha2.js b/test/vectors/tv_sha2.js similarity index 100% rename from scripts/testVectors/tv_sha2.js rename to test/vectors/tv_sha2.js diff --git a/test/vendor/README.md b/test/vendor/README.md new file mode 100644 index 0000000..31baff1 --- /dev/null +++ b/test/vendor/README.md @@ -0,0 +1,23 @@ +# Vendored test dependencies + +## QUnit 1.23.1 — pinned, do not upgrade + +`qunit-1.23.1.js` / `qunit-1.23.1.css` are vendored on purpose. + +**1.23.1 is the last QUnit release that supports Internet Explorer 8**, which +this library still targets. Newer QUnit versions drop IE8 (and older) support, +so upgrading would break the test harness on the very browsers we pin this +version for. + +These files are committed (rather than pulled from a CDN) so that: + +- the test suite runs offline and deterministically; +- there is no runtime dependency on third-party CDN availability or TLS that + IE8 cannot negotiate; +- the exact reviewed code is what executes. + +They are **not** published to npm — the package `files` allowlist only ships +`dist/`, `types/`, and the docs/license, so this folder adds nothing to the +installed package size. + +Used by [`../SubtleTests.html`](../SubtleTests.html). diff --git a/scripts/qunit/qunit-1.23.1.css b/test/vendor/qunit-1.23.1.css similarity index 100% rename from scripts/qunit/qunit-1.23.1.css rename to test/vendor/qunit-1.23.1.css diff --git a/scripts/qunit/qunit-1.23.1.js b/test/vendor/qunit-1.23.1.js similarity index 100% rename from scripts/qunit/qunit-1.23.1.js rename to test/vendor/qunit-1.23.1.js diff --git a/tests/CryptoECCTests.html b/tests/CryptoECCTests.html deleted file mode 100644 index e179af1..0000000 --- a/tests/CryptoECCTests.html +++ /dev/null @@ -1,59 +0,0 @@ - - - - - - - - - - - - - Crypto ECC Tests - - - - - - - - -
-
- - - - - - - - - - - - - - - - - - diff --git a/tests/CryptoMathTests.html b/tests/CryptoMathTests.html deleted file mode 100644 index 96cc096..0000000 --- a/tests/CryptoMathTests.html +++ /dev/null @@ -1,58 +0,0 @@ - - - - - - - - - - - - Crypto Math Tests - - - - - - -
-
- - - - - - - - - - - - - - - - - - - - diff --git a/tests/SubtleTests.html b/tests/SubtleTests.html deleted file mode 100644 index ffb4bd3..0000000 --- a/tests/SubtleTests.html +++ /dev/null @@ -1,87 +0,0 @@ - - - - - - - - - Subtle Tests - - - - - - -
-
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/types/IE11PromiseWrapper.d.ts b/types/IE11PromiseWrapper.d.ts new file mode 100644 index 0000000..5f3f1bd --- /dev/null +++ b/types/IE11PromiseWrapper.d.ts @@ -0,0 +1,4 @@ +declare module "IE11PromiseWrapper" { + var ie11PromiseWrapper: Crypto /*lib.d.ts*/; + export = ie11PromiseWrapper; +} \ No newline at end of file diff --git a/types/msrCrypto.d.ts b/types/msrCrypto.d.ts new file mode 100644 index 0000000..c22ab08 --- /dev/null +++ b/types/msrCrypto.d.ts @@ -0,0 +1,168 @@ +// Type definitions for @microsoft/msrcrypto. +// +// msrCrypto exposes a single object that mirrors the W3C Web Cryptography API +// (`crypto` / `crypto.subtle`) plus a handful of library-specific helpers. +// The shape is described directly here rather than by augmenting the global +// `Crypto` interface, so importing this module does not change the types of the +// platform's own `crypto` object. +// +// DOM types (CryptoKey, CryptoKeyPair, JsonWebKey, etc.) come from lib.dom.d.ts. + +export = msrCrypto; + +declare const msrCrypto: msrCrypto.MsrCrypto; + +declare namespace msrCrypto { + /** Anything msrCrypto accepts as a byte buffer: a plain array of byte values, an ArrayBuffer, or a typed-array view. */ + type ByteSource = ArrayLike | ArrayBuffer | ArrayBufferView; + + /** A hash may be given as a string ("SHA-256") or as an object ({ name: "SHA-256" }). */ + type HashAlgorithmIdentifier = string | { name: string }; + + /** + * An algorithm may be given as a string ("AES-GCM") or as an algorithm + * object ({ name: "AES-GCM", ... }), per the W3C AlgorithmIdentifier + * (object or DOMString). + */ + type MsrAlgorithmIdentifier = string | MsrAlgorithm; + + type KeyFormat = "raw" | "spki" | "pkcs8" | "jwk"; + + /** + * A permissive algorithm parameter object. msrCrypto accepts the standard + * WebCrypto algorithm fields, but byte-valued fields (iv, salt, ...) may be + * supplied as plain arrays or typed arrays in addition to ArrayBuffers. + */ + interface MsrAlgorithm { + name: string; + /** SHA / HMAC / RSA hash. */ + hash?: HashAlgorithmIdentifier; + /** Key or output length in bits (AES, HMAC, deriveBits, ...). */ + length?: number; + // AES-CBC / AES-GCM / AES-CTR + iv?: ByteSource; + counter?: ByteSource; + additionalData?: ByteSource; + tagLength?: number; + // RSA + modulusLength?: number; + publicExponent?: ByteSource; + saltLength?: number; + label?: ByteSource; + // Elliptic curve (ECDH / ECDSA) + namedCurve?: string; + /** ECDH peer public key (passed in the algorithm for deriveBits/deriveKey). */ + public?: CryptoKey; + // Key-derivation (PBKDF2 / HKDF / Concat) + salt?: ByteSource; + info?: ByteSource; + iterations?: number; + /** Request a streaming operation; the call resolves with a StreamObject. */ + stream?: boolean; + } + + /** + * Returned when a subtle operation is started in streaming mode (the data + * argument is omitted, or algorithm.stream is true). Feed data with + * `process`, then call `finish` to obtain the final result. + */ + interface StreamObject { + process(data: ByteSource): Promise; + finish(): Promise; + abort(): void; + } + + /** ASN.1 DER encoder/decoder exposed as `msrCrypto.asn1`. */ + interface Asn1Node { + type?: string; + header?: number; + length?: number; + contents?: number[]; + children?: Asn1Node[]; + [key: string]: unknown; + } + + interface Asn1 { + parse(bytes: ByteSource, force?: boolean): Asn1Node; + encode(node: Asn1Node | object): number[]; + toString(objTree: Asn1Node | object): string; + } + + /** The msrCrypto SubtleCrypto-like interface. */ + interface MsrSubtleCrypto { + encrypt(algorithm: MsrAlgorithmIdentifier, key: CryptoKey, data: ByteSource): Promise; + encrypt(algorithm: MsrAlgorithmIdentifier, key: CryptoKey): Promise; + + decrypt(algorithm: MsrAlgorithmIdentifier, key: CryptoKey, data: ByteSource): Promise; + decrypt(algorithm: MsrAlgorithmIdentifier, key: CryptoKey): Promise; + + sign(algorithm: MsrAlgorithmIdentifier, key: CryptoKey, data: ByteSource): Promise; + sign(algorithm: MsrAlgorithmIdentifier, key: CryptoKey): Promise; + + verify(algorithm: MsrAlgorithmIdentifier, key: CryptoKey, signature: ByteSource, data: ByteSource): Promise; + verify(algorithm: MsrAlgorithmIdentifier, key: CryptoKey, signature: ByteSource): Promise; + + digest(algorithm: MsrAlgorithmIdentifier, data: ByteSource): Promise; + digest(algorithm: MsrAlgorithmIdentifier): Promise; + + generateKey(algorithm: MsrAlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise; + + deriveKey(algorithm: MsrAlgorithmIdentifier, baseKey: CryptoKey, derivedKeyType: MsrAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): Promise; + + deriveBits(algorithm: MsrAlgorithmIdentifier, baseKey: CryptoKey, length: number): Promise; + + importKey(format: "jwk", keyData: JsonWebKey, algorithm: MsrAlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise; + importKey(format: "raw" | "spki" | "pkcs8", keyData: ByteSource, algorithm: MsrAlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise; + + exportKey(format: "jwk", key: CryptoKey): Promise; + exportKey(format: "raw" | "spki" | "pkcs8", key: CryptoKey): Promise; + + wrapKey(format: KeyFormat, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: MsrAlgorithmIdentifier): Promise; + + unwrapKey(format: KeyFormat, wrappedKey: ByteSource, unwrappingKey: CryptoKey, unwrapAlgorithm: MsrAlgorithmIdentifier, unwrappedKeyAlgorithm: MsrAlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise; + } + + /** The object returned when importing the library. */ + interface MsrCrypto { + /** The SubtleCrypto-like interface. */ + readonly subtle: MsrSubtleCrypto; + + /** The Web Crypto CryptoKey constructor (used for instanceof checks). */ + readonly CryptoKey: typeof CryptoKey; + + /** The Promise constructor msrCrypto uses (native Promise when available, otherwise the bundled polyfill). */ + readonly Promise: PromiseConstructor; + + /** Fill an array (or typed array) with cryptographically random values and return it. */ + getRandomValues(array: T): T; + getRandomValues(array: number[]): number[]; + + /** Seed or reseed the PRNG with additional entropy. */ + initPrng(entropyData: ArrayLike): void; + + /** Convert bytes to a Base64 (or Base64Url) string. */ + toBase64(data: ByteSource, base64Url?: boolean): string; + + /** Decode a Base64/Base64Url string to an array of byte values. */ + fromBase64(base64String: string): number[]; + + /** Encode UTF-8/ASCII text to an array of byte values. */ + textToBytes(text: string): number[]; + + /** Decode an array of bytes as UTF-8/ASCII text. */ + bytesToText(bytes: ByteSource): string; + + /** ASN.1 DER encoder/decoder. */ + readonly asn1: Asn1; + + /** URL of the loaded msrCrypto script (when determinable). */ + readonly url: string; + + /** Library version string. */ + readonly version: string; + + /** Enable or disable use of web workers (when supported by the host). */ + useWebWorkers(useWebWorkers: boolean): void; + } +} +