logos-messaging/lab.waku.org
1
0
Fork 0
mirror of https://github.com/logos-messaging/lab.waku.org.git synced 2026-02-04 05:53:11 +00:00
Code Issues Packages Projects Releases Wiki Activity
lab.waku.org/examples/flush-notes/.next/server/vendor-chunks/node-forge.js

255 lines
1.5 MiB
JavaScript
Raw Normal View History

chore: update waku deps, add notes example, move other examples to experimental (#58)
2024-04-23 22:23:47 -07:00
"use strict";
/*
* ATTENTION: An "eval-source-map" devtool has been used.
* This devtool is neither made for production nor for readable output files.
* It uses "eval()" calls to create a separate source file with attached SourceMaps in the browser devtools.
* If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
* or disable the default devtool with "devtool: false".
* If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
*/
exports.id = "vendor-chunks/node-forge";
exports.ids = ["vendor-chunks/node-forge"];
exports.modules = {
/***/ "(ssr)/./node_modules/node-forge/lib/aes.js":
/*!********************************************!*\
!*** ./node_modules/node-forge/lib/aes.js ***!
\********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Advanced Encryption Standard (AES) implementation.\n *\n * This implementation is based on the public domain library 'jscrypto' which\n * was written by:\n *\n * Emily Stark (estark@stanford.edu)\n * Mike Hamburg (mhamburg@stanford.edu)\n * Dan Boneh (dabo@cs.stanford.edu)\n *\n * Parts of this code are based on the OpenSSL implementation of AES:\n * http://www.openssl.org\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2014 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./cipher */ \"(ssr)/./node_modules/node-forge/lib/cipher.js\");\n__webpack_require__(/*! ./cipherModes */ \"(ssr)/./node_modules/node-forge/lib/cipherModes.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\n/* AES API */ module.exports = forge.aes = forge.aes || {};\n/**\n * Deprecated. Instead, use:\n *\n * var cipher = forge.cipher.createCipher('AES-<mode>', key);\n * cipher.start({iv: iv});\n *\n * Creates an AES cipher object to encrypt data using the given symmetric key.\n * The output will be stored in the 'output' member of the returned cipher.\n *\n * The key and iv may be given as a string of bytes, an array of bytes,\n * a byte buffer, or an array of 32-bit words.\n *\n * @param key the symmetric key to use.\n * @param iv the initialization vector to use.\n * @param output the buffer to write to, null to create one.\n * @param mode the cipher mode to use (default: 'CBC').\n *\n * @return the cipher.\n */ forge.aes.startEncrypting = function(key, iv, output, mode) {\n var cipher = _createCipher({\n key: key,\n output: output,\n decrypt: false,\n mode: mode\n });\n cipher.start(iv);\n return cipher;\n};\n/**\n * Deprecated. Instead, use:\n *\n * var cipher = forge.cipher.createCipher('AES-<mode>', key);\n *\n * Creates an AES cipher object to encrypt data using the given symmetric key.\n *\n * The key may be given as a string of bytes, an array of bytes, a\n * byte buffer, or an array of 32-bit words.\n *\n * @param key the symmetric key to use.\n * @param mode the cipher mode to use (default: 'CBC').\n *\n * @return the cipher.\n */ forge.aes.createEncryptionCipher = function(key, mode) {\n return _createCipher({\n key: key,\n output: null,\n decrypt: false,\n mode: mode\n });\n};\n/**\n * Deprecated. Instead, use:\n *\n * var decipher = forge.cipher.createDecipher('AES-<mode>', key);\n * decipher.start({iv: iv});\n *\n * Creates an AES cipher object to decrypt data using the given symmetric key.\n * The output will be stored in the 'output' member of the returned cipher.\n *\n * The key and iv may be given as a string of bytes, an array of bytes,\n * a byte buffer, or an array of 32-bit words.\n *\n * @param key the symmetric key to use.\n * @param iv the initialization vector to use.\n * @param output the buffer to write to, null to create one.\n * @param mode the cipher mode to use (default: 'CBC').\n *\n * @return the cipher.\n */ forge.aes.startDecrypting = function(key, iv, output, mode) {\n var cipher = _createCipher({\n key: key,\n output: output,\n decrypt: true,\n mode: mode\n });\n cipher.start(iv);\n return cipher;\n};\n/**\n * Deprecated. Instead, use:\n *\n * var decipher = forge.cipher.createDecipher('AES-<mode>', key);\n *\n * Creates an AES cipher object to decrypt data using the given symmetric key.\n *\n * The key may be given as a string of bytes, an array of bytes, a\n * byte buffer, or an array of 32-bit words.\n *\n * @param key the symmetric key to use.\n * @param mode the cipher mode to use (default: 'CBC').\n *\n * @return the cipher.\n */ forge.aes.createDecryptionCipher = function(key, mode) {\n return _createCipher({\n key: key,\n output: null,\n decrypt: true,\n mode: mode\n });\n};\n/**\n * Creates a new AES cipher algorithm object.\n *\n * @param name the name of the algorithm.\n * @param mode the mode
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/asn1.js":
/*!*********************************************!*\
!*** ./node_modules/node-forge/lib/asn1.js ***!
\*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Javascript implementation of Abstract Syntax Notation Number One.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2015 Digital Bazaar, Inc.\n *\n * An API for storing data using the Abstract Syntax Notation Number One\n * format using DER (Distinguished Encoding Rules) encoding. This encoding is\n * commonly used to store data for PKI, i.e. X.509 Certificates, and this\n * implementation exists for that purpose.\n *\n * Abstract Syntax Notation Number One (ASN.1) is used to define the abstract\n * syntax of information without restricting the way the information is encoded\n * for transmission. It provides a standard that allows for open systems\n * communication. ASN.1 defines the syntax of information data and a number of\n * simple data types as well as a notation for describing them and specifying\n * values for them.\n *\n * The RSA algorithm creates public and private keys that are often stored in\n * X.509 or PKCS#X formats -- which use ASN.1 (encoded in DER format). This\n * class provides the most basic functionality required to store and load DSA\n * keys that are encoded according to ASN.1.\n *\n * The most common binary encodings for ASN.1 are BER (Basic Encoding Rules)\n * and DER (Distinguished Encoding Rules). DER is just a subset of BER that\n * has stricter requirements for how data must be encoded.\n *\n * Each ASN.1 structure has a tag (a byte identifying the ASN.1 structure type)\n * and a byte array for the value of this ASN1 structure which may be data or a\n * list of ASN.1 structures.\n *\n * Each ASN.1 structure using BER is (Tag-Length-Value):\n *\n * | byte 0 | bytes X | bytes Y |\n * |--------|---------|----------\n * | tag | length | value |\n *\n * ASN.1 allows for tags to be of \"High-tag-number form\" which allows a tag to\n * be two or more octets, but that is not supported by this class. A tag is\n * only 1 byte. Bits 1-5 give the tag number (ie the data type within a\n * particular 'class'), 6 indicates whether or not the ASN.1 value is\n * constructed from other ASN.1 values, and bits 7 and 8 give the 'class'. If\n * bits 7 and 8 are both zero, the class is UNIVERSAL. If only bit 7 is set,\n * then the class is APPLICATION. If only bit 8 is set, then the class is\n * CONTEXT_SPECIFIC. If both bits 7 and 8 are set, then the class is PRIVATE.\n * The tag numbers for the data types for the class UNIVERSAL are listed below:\n *\n * UNIVERSAL 0 Reserved for use by the encoding rules\n * UNIVERSAL 1 Boolean type\n * UNIVERSAL 2 Integer type\n * UNIVERSAL 3 Bitstring type\n * UNIVERSAL 4 Octetstring type\n * UNIVERSAL 5 Null type\n * UNIVERSAL 6 Object identifier type\n * UNIVERSAL 7 Object descriptor type\n * UNIVERSAL 8 External type and Instance-of type\n * UNIVERSAL 9 Real type\n * UNIVERSAL 10 Enumerated type\n * UNIVERSAL 11 Embedded-pdv type\n * UNIVERSAL 12 UTF8String type\n * UNIVERSAL 13 Relative object identifier type\n * UNIVERSAL 14-15 Reserved for future editions\n * UNIVERSAL 16 Sequence and Sequence-of types\n * UNIVERSAL 17 Set and Set-of types\n * UNIVERSAL 18-22, 25-30 Character string types\n * UNIVERSAL 23-24 Time types\n *\n * The length of an ASN.1 structure is specified after the tag identifier.\n * There is a definite form and an indefinite form. The indefinite form may\n * be used if the encoding is constructed and not all immediately available.\n * The indefinite form is encoded using a length byte with only the 8th bit\n * set. The end of the constructed object is marked using end-of-contents\n * octets (two zero bytes).\n *\n * The definite form looks like this:\n *\n * The length may take up 1 or more bytes, it depends on the length of the\n * value of the ASN.1 structure. DER encoding requires that if the ASN.1\n * structure has a value that has a length greater than 127, more than 1 byte\n * will be used to store its length, otherwise just one byte will be used.\n * This is strict.\n *\n * In the case that the length of the ASN.1 value is less than 127, 1 octet\n * (byte) is used to store the \"short form\" length. The 8th bit has a
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/baseN.js":
/*!**********************************************!*\
!*** ./node_modules/node-forge/lib/baseN.js ***!
\**********************************************/
/***/ ((module) => {
eval("/**\n * Base-N/Base-X encoding/decoding functions.\n *\n * Original implementation from base-x:\n * https://github.com/cryptocoinjs/base-x\n *\n * Which is MIT licensed:\n *\n * The MIT License (MIT)\n *\n * Copyright base-x contributors (c) 2016\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */ \nvar api = {};\nmodule.exports = api;\n// baseN alphabet indexes\nvar _reverseAlphabets = {};\n/**\n * BaseN-encodes a Uint8Array using the given alphabet.\n *\n * @param input the Uint8Array to encode.\n * @param maxline the maximum number of encoded characters per line to use,\n * defaults to none.\n *\n * @return the baseN-encoded output string.\n */ api.encode = function(input, alphabet, maxline) {\n if (typeof alphabet !== \"string\") {\n throw new TypeError('\"alphabet\" must be a string.');\n }\n if (maxline !== undefined && typeof maxline !== \"number\") {\n throw new TypeError('\"maxline\" must be a number.');\n }\n var output = \"\";\n if (!(input instanceof Uint8Array)) {\n // assume forge byte buffer\n output = _encodeWithByteBuffer(input, alphabet);\n } else {\n var i = 0;\n var base = alphabet.length;\n var first = alphabet.charAt(0);\n var digits = [\n 0\n ];\n for(i = 0; i < input.length; ++i){\n for(var j = 0, carry = input[i]; j < digits.length; ++j){\n carry += digits[j] << 8;\n digits[j] = carry % base;\n carry = carry / base | 0;\n }\n while(carry > 0){\n digits.push(carry % base);\n carry = carry / base | 0;\n }\n }\n // deal with leading zeros\n for(i = 0; input[i] === 0 && i < input.length - 1; ++i){\n output += first;\n }\n // convert digits to a string\n for(i = digits.length - 1; i >= 0; --i){\n output += alphabet[digits[i]];\n }\n }\n if (maxline) {\n var regex = new RegExp(\".{1,\" + maxline + \"}\", \"g\");\n output = output.match(regex).join(\"\\r\\n\");\n }\n return output;\n};\n/**\n * Decodes a baseN-encoded (using the given alphabet) string to a\n * Uint8Array.\n *\n * @param input the baseN-encoded input string.\n *\n * @return the Uint8Array.\n */ api.decode = function(input, alphabet) {\n if (typeof input !== \"string\") {\n throw new TypeError('\"input\" must be a string.');\n }\n if (typeof alphabet !== \"string\") {\n throw new TypeError('\"alphabet\" must be a string.');\n }\n var table = _reverseAlphabets[alphabet];\n if (!table) {\n // compute reverse alphabet\n table = _reverseAlphabets[alphabet] = [];\n for(var i = 0; i < alphabet.length; ++i){\n table[alphabet.charCodeAt(i)] = i;\n }\n }\n // remove whitespace characters\n input = input.replace(/\\s/g, \"\");\n var base = alphabet.length;\n var first = alphabet.charAt(0);\n var bytes =
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/cipher.js":
/*!***********************************************!*\
!*** ./node_modules/node-forge/lib/cipher.js ***!
\***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Cipher base API.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2014 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\nmodule.exports = forge.cipher = forge.cipher || {};\n// registered algorithms\nforge.cipher.algorithms = forge.cipher.algorithms || {};\n/**\n * Creates a cipher object that can be used to encrypt data using the given\n * algorithm and key. The algorithm may be provided as a string value for a\n * previously registered algorithm or it may be given as a cipher algorithm\n * API object.\n *\n * @param algorithm the algorithm to use, either a string or an algorithm API\n * object.\n * @param key the key to use, as a binary-encoded string of bytes or a\n * byte buffer.\n *\n * @return the cipher.\n */ forge.cipher.createCipher = function(algorithm, key) {\n var api = algorithm;\n if (typeof api === \"string\") {\n api = forge.cipher.getAlgorithm(api);\n if (api) {\n api = api();\n }\n }\n if (!api) {\n throw new Error(\"Unsupported algorithm: \" + algorithm);\n }\n // assume block cipher\n return new forge.cipher.BlockCipher({\n algorithm: api,\n key: key,\n decrypt: false\n });\n};\n/**\n * Creates a decipher object that can be used to decrypt data using the given\n * algorithm and key. The algorithm may be provided as a string value for a\n * previously registered algorithm or it may be given as a cipher algorithm\n * API object.\n *\n * @param algorithm the algorithm to use, either a string or an algorithm API\n * object.\n * @param key the key to use, as a binary-encoded string of bytes or a\n * byte buffer.\n *\n * @return the cipher.\n */ forge.cipher.createDecipher = function(algorithm, key) {\n var api = algorithm;\n if (typeof api === \"string\") {\n api = forge.cipher.getAlgorithm(api);\n if (api) {\n api = api();\n }\n }\n if (!api) {\n throw new Error(\"Unsupported algorithm: \" + algorithm);\n }\n // assume block cipher\n return new forge.cipher.BlockCipher({\n algorithm: api,\n key: key,\n decrypt: true\n });\n};\n/**\n * Registers an algorithm by name. If the name was already registered, the\n * algorithm API object will be overwritten.\n *\n * @param name the name of the algorithm.\n * @param algorithm the algorithm API object.\n */ forge.cipher.registerAlgorithm = function(name, algorithm) {\n name = name.toUpperCase();\n forge.cipher.algorithms[name] = algorithm;\n};\n/**\n * Gets a registered algorithm by name.\n *\n * @param name the name of the algorithm.\n *\n * @return the algorithm, if found, null if not.\n */ forge.cipher.getAlgorithm = function(name) {\n name = name.toUpperCase();\n if (name in forge.cipher.algorithms) {\n return forge.cipher.algorithms[name];\n }\n return null;\n};\nvar BlockCipher = forge.cipher.BlockCipher = function(options) {\n this.algorithm = options.algorithm;\n this.mode = this.algorithm.mode;\n this.blockSize = this.mode.blockSize;\n this._finish = false;\n this._input = null;\n this.output = null;\n this._op = options.decrypt ? this.mode.decrypt : this.mode.encrypt;\n this._decrypt = options.decrypt;\n this.algorithm.initialize(options);\n};\n/**\n * Starts or restarts the encryption or decryption process, whichever\n * was previously configured.\n *\n * For non-GCM mode, the IV may be a binary-encoded string of bytes, an array\n * of bytes, a byte buffer, or an array of 32-bit integers. If the IV is in\n * bytes, then it must be Nb (16) bytes in length. If the IV is given in as\n * 32-bit integers, then it must be 4 integers long.\n *\n * Note: an IV is not required or used in ECB mode.\n *\n * For GCM-mode, the IV must be given as a binary-encoded string of bytes or\n * a byte buffer. The number of bytes should be 12 (9
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/cipherModes.js":
/*!****************************************************!*\
!*** ./node_modules/node-forge/lib/cipherModes.js ***!
\****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Supported cipher modes.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2014 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\nforge.cipher = forge.cipher || {};\n// supported cipher modes\nvar modes = module.exports = forge.cipher.modes = forge.cipher.modes || {};\n/** Electronic codebook (ECB) (Don't use this; it's not secure) **/ modes.ecb = function(options) {\n options = options || {};\n this.name = \"ECB\";\n this.cipher = options.cipher;\n this.blockSize = options.blockSize || 16;\n this._ints = this.blockSize / 4;\n this._inBlock = new Array(this._ints);\n this._outBlock = new Array(this._ints);\n};\nmodes.ecb.prototype.start = function(options) {};\nmodes.ecb.prototype.encrypt = function(input, output, finish) {\n // not enough input to encrypt\n if (input.length() < this.blockSize && !(finish && input.length() > 0)) {\n return true;\n }\n // get next block\n for(var i = 0; i < this._ints; ++i){\n this._inBlock[i] = input.getInt32();\n }\n // encrypt block\n this.cipher.encrypt(this._inBlock, this._outBlock);\n // write output\n for(var i = 0; i < this._ints; ++i){\n output.putInt32(this._outBlock[i]);\n }\n};\nmodes.ecb.prototype.decrypt = function(input, output, finish) {\n // not enough input to decrypt\n if (input.length() < this.blockSize && !(finish && input.length() > 0)) {\n return true;\n }\n // get next block\n for(var i = 0; i < this._ints; ++i){\n this._inBlock[i] = input.getInt32();\n }\n // decrypt block\n this.cipher.decrypt(this._inBlock, this._outBlock);\n // write output\n for(var i = 0; i < this._ints; ++i){\n output.putInt32(this._outBlock[i]);\n }\n};\nmodes.ecb.prototype.pad = function(input, options) {\n // add PKCS#7 padding to block (each pad byte is the\n // value of the number of pad bytes)\n var padding = input.length() === this.blockSize ? this.blockSize : this.blockSize - input.length();\n input.fillWithByte(padding, padding);\n return true;\n};\nmodes.ecb.prototype.unpad = function(output, options) {\n // check for error: input data not a multiple of blockSize\n if (options.overflow > 0) {\n return false;\n }\n // ensure padding byte count is valid\n var len = output.length();\n var count = output.at(len - 1);\n if (count > this.blockSize << 2) {\n return false;\n }\n // trim off padding bytes\n output.truncate(count);\n return true;\n};\n/** Cipher-block Chaining (CBC) **/ modes.cbc = function(options) {\n options = options || {};\n this.name = \"CBC\";\n this.cipher = options.cipher;\n this.blockSize = options.blockSize || 16;\n this._ints = this.blockSize / 4;\n this._inBlock = new Array(this._ints);\n this._outBlock = new Array(this._ints);\n};\nmodes.cbc.prototype.start = function(options) {\n // Note: legacy support for using IV residue (has security flaws)\n // if IV is null, reuse block from previous processing\n if (options.iv === null) {\n // must have a previous block\n if (!this._prev) {\n throw new Error(\"Invalid IV parameter.\");\n }\n this._iv = this._prev.slice(0);\n } else if (!(\"iv\" in options)) {\n throw new Error(\"Invalid IV parameter.\");\n } else {\n // save IV as \"previous\" block\n this._iv = transformIV(options.iv, this.blockSize);\n this._prev = this._iv.slice(0);\n }\n};\nmodes.cbc.prototype.encrypt = function(input, output, finish) {\n // not enough input to encrypt\n if (input.length() < this.blockSize && !(finish && input.length() > 0)) {\n return true;\n }\n // get next block\n // CBC XOR's IV (or previous block) with plaintext\n for(var i = 0; i < this._ints; ++i){\n this._inBlock[i] = this._prev[i] ^ input.getInt32();\n }\n // encrypt
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/des.js":
/*!********************************************!*\
!*** ./node_modules/node-forge/lib/des.js ***!
\********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * DES (Data Encryption Standard) implementation.\n *\n * This implementation supports DES as well as 3DES-EDE in ECB and CBC mode.\n * It is based on the BSD-licensed implementation by Paul Tero:\n *\n * Paul Tero, July 2001\n * http://www.tero.co.uk/des/\n *\n * Optimised for performance with large blocks by\n * Michael Hayworth, November 2001\n * http://www.netdealing.com\n *\n * THIS SOFTWARE IS PROVIDED \"AS IS\" AND\n * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\n * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n * SUCH DAMAGE.\n *\n * @author Stefan Siegl\n * @author Dave Longley\n *\n * Copyright (c) 2012 Stefan Siegl <stesie@brokenpipe.de>\n * Copyright (c) 2012-2014 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./cipher */ \"(ssr)/./node_modules/node-forge/lib/cipher.js\");\n__webpack_require__(/*! ./cipherModes */ \"(ssr)/./node_modules/node-forge/lib/cipherModes.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\n/* DES API */ module.exports = forge.des = forge.des || {};\n/**\n * Deprecated. Instead, use:\n *\n * var cipher = forge.cipher.createCipher('DES-<mode>', key);\n * cipher.start({iv: iv});\n *\n * Creates an DES cipher object to encrypt data using the given symmetric key.\n * The output will be stored in the 'output' member of the returned cipher.\n *\n * The key and iv may be given as binary-encoded strings of bytes or\n * byte buffers.\n *\n * @param key the symmetric key to use (64 or 192 bits).\n * @param iv the initialization vector to use.\n * @param output the buffer to write to, null to create one.\n * @param mode the cipher mode to use (default: 'CBC' if IV is\n * given, 'ECB' if null).\n *\n * @return the cipher.\n */ forge.des.startEncrypting = function(key, iv, output, mode) {\n var cipher = _createCipher({\n key: key,\n output: output,\n decrypt: false,\n mode: mode || (iv === null ? \"ECB\" : \"CBC\")\n });\n cipher.start(iv);\n return cipher;\n};\n/**\n * Deprecated. Instead, use:\n *\n * var cipher = forge.cipher.createCipher('DES-<mode>', key);\n *\n * Creates an DES cipher object to encrypt data using the given symmetric key.\n *\n * The key may be given as a binary-encoded string of bytes or a byte buffer.\n *\n * @param key the symmetric key to use (64 or 192 bits).\n * @param mode the cipher mode to use (default: 'CBC').\n *\n * @return the cipher.\n */ forge.des.createEncryptionCipher = function(key, mode) {\n return _createCipher({\n key: key,\n output: null,\n decrypt: false,\n mode: mode\n });\n};\n/**\n * Deprecated. Instead, use:\n *\n * var decipher = forge.cipher.createDecipher('DES-<mode>', key);\n * decipher.start({iv: iv});\n *\n * Creates an DES cipher object to decrypt data using the given symmetric key.\n * The output will be stored in the 'output' member of the returned cipher.\n *\n * The key and iv may be given as binary-encoded strings of bytes or\n * byte buffers.\n *\n * @param key the symmetric key to use (64 or 192 bits).\n * @param iv the initialization vector to use.\n * @param output the buffer to write to, null to create one.\n * @param mode the cipher mode to use (default: 'CBC' if IV is\n * given, 'ECB' if null).\n *\n * @return the cipher.\n */ forge.des.startDecrypting = function(key, iv, output, mode) {\n var cipher =
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/forge.js":
/*!**********************************************!*\
!*** ./node_modules/node-forge/lib/forge.js ***!
\**********************************************/
/***/ ((module) => {
eval("/**\n * Node.js module for Forge.\n *\n * @author Dave Longley\n *\n * Copyright 2011-2016 Digital Bazaar, Inc.\n */ \nmodule.exports = {\n // default options\n options: {\n usePureJavaScript: false\n }\n};\n//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiKHNzcikvLi9ub2RlX21vZHVsZXMvbm9kZS1mb3JnZS9saWIvZm9yZ2UuanMiLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztDQU1DO0FBQ0RBLE9BQU9DLE9BQU8sR0FBRztJQUNmLGtCQUFrQjtJQUNsQkMsU0FBUztRQUNQQyxtQkFBbUI7SUFDckI7QUFDRiIsInNvdXJjZXMiOlsid2VicGFjazovL2ZsdXNoLW5vdGVzLy4vbm9kZV9tb2R1bGVzL25vZGUtZm9yZ2UvbGliL2ZvcmdlLmpzPzA0MGUiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBOb2RlLmpzIG1vZHVsZSBmb3IgRm9yZ2UuXG4gKlxuICogQGF1dGhvciBEYXZlIExvbmdsZXlcbiAqXG4gKiBDb3B5cmlnaHQgMjAxMS0yMDE2IERpZ2l0YWwgQmF6YWFyLCBJbmMuXG4gKi9cbm1vZHVsZS5leHBvcnRzID0ge1xuICAvLyBkZWZhdWx0IG9wdGlvbnNcbiAgb3B0aW9uczoge1xuICAgIHVzZVB1cmVKYXZhU2NyaXB0OiBmYWxzZVxuICB9XG59O1xuIl0sIm5hbWVzIjpbIm1vZHVsZSIsImV4cG9ydHMiLCJvcHRpb25zIiwidXNlUHVyZUphdmFTY3JpcHQiXSwic291cmNlUm9vdCI6IiJ9\n//# sourceURL=webpack-internal:///(ssr)/./node_modules/node-forge/lib/forge.js\n");
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/hmac.js":
/*!*********************************************!*\
!*** ./node_modules/node-forge/lib/hmac.js ***!
\*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Hash-based Message Authentication Code implementation. Requires a message\n * digest object that can be obtained, for example, from forge.md.sha1 or\n * forge.md.md5.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2012 Digital Bazaar, Inc. All rights reserved.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./md */ \"(ssr)/./node_modules/node-forge/lib/md.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\n/* HMAC API */ var hmac = module.exports = forge.hmac = forge.hmac || {};\n/**\n * Creates an HMAC object that uses the given message digest object.\n *\n * @return an HMAC object.\n */ hmac.create = function() {\n // the hmac key to use\n var _key = null;\n // the message digest to use\n var _md = null;\n // the inner padding\n var _ipadding = null;\n // the outer padding\n var _opadding = null;\n // hmac context\n var ctx = {};\n /**\n * Starts or restarts the HMAC with the given key and message digest.\n *\n * @param md the message digest to use, null to reuse the previous one,\n * a string to use builtin 'sha1', 'md5', 'sha256'.\n * @param key the key to use as a string, array of bytes, byte buffer,\n * or null to reuse the previous key.\n */ ctx.start = function(md, key) {\n if (md !== null) {\n if (typeof md === \"string\") {\n // create builtin message digest\n md = md.toLowerCase();\n if (md in forge.md.algorithms) {\n _md = forge.md.algorithms[md].create();\n } else {\n throw new Error('Unknown hash algorithm \"' + md + '\"');\n }\n } else {\n // store message digest\n _md = md;\n }\n }\n if (key === null) {\n // reuse previous key\n key = _key;\n } else {\n if (typeof key === \"string\") {\n // convert string into byte buffer\n key = forge.util.createBuffer(key);\n } else if (forge.util.isArray(key)) {\n // convert byte array into byte buffer\n var tmp = key;\n key = forge.util.createBuffer();\n for(var i = 0; i < tmp.length; ++i){\n key.putByte(tmp[i]);\n }\n }\n // if key is longer than blocksize, hash it\n var keylen = key.length();\n if (keylen > _md.blockLength) {\n _md.start();\n _md.update(key.bytes());\n key = _md.digest();\n }\n // mix key into inner and outer padding\n // ipadding = [0x36 * blocksize] ^ key\n // opadding = [0x5C * blocksize] ^ key\n _ipadding = forge.util.createBuffer();\n _opadding = forge.util.createBuffer();\n keylen = key.length();\n for(var i = 0; i < keylen; ++i){\n var tmp = key.at(i);\n _ipadding.putByte(0x36 ^ tmp);\n _opadding.putByte(0x5C ^ tmp);\n }\n // if key is shorter than blocksize, add additional padding\n if (keylen < _md.blockLength) {\n var tmp = _md.blockLength - keylen;\n for(var i = 0; i < tmp; ++i){\n _ipadding.putByte(0x36);\n _opadding.putByte(0x5C);\n }\n }\n _key = key;\n _ipadding = _ipadding.bytes();\n _opadding = _opadding.bytes();\n }\n // digest is done like so: hash(opadding | hash(ipadding | message))\n // prepare to do inner hash\n // hash(ipadding | message)\n _md.start();\n _md.update(_ipadding);\n };\n /**\n * Updates the HMAC with the given message bytes.\n *\n * @param bytes the bytes to update with.\n */ ctx.update = function(bytes) {\n
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/jsbn.js":
/*!*********************************************!*\
!*** ./node_modules/node-forge/lib/jsbn.js ***!
\*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("// Copyright (c) 2005 Tom Wu\n// All Rights Reserved.\n// See \"LICENSE\" for details.\n// Basic JavaScript BN library - subset useful for RSA encryption.\n/*\nLicensing (LICENSE)\n-------------------\n\nThis software is covered under the following copyright:\n*/ /*\n * Copyright (c) 2003-2005 Tom Wu\n * All Rights Reserved.\n *\n * Permission is hereby granted, free of charge, to any person obtaining\n * a copy of this software and associated documentation files (the\n * \"Software\"), to deal in the Software without restriction, including\n * without limitation the rights to use, copy, modify, merge, publish,\n * distribute, sublicense, and/or sell copies of the Software, and to\n * permit persons to whom the Software is furnished to do so, subject to\n * the following conditions:\n *\n * The above copyright notice and this permission notice shall be\n * included in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS-IS\" AND WITHOUT WARRANTY OF ANY KIND,\n * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY\n * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.\n *\n * IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,\n * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER\n * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF\n * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT\n * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n *\n * In addition, the following condition applies:\n *\n * All redistributions must retain an intact copy of this copyright notice\n * and disclaimer.\n */ /*\nAddress all questions regarding this license to:\n\n Tom Wu\n tjw@cs.Stanford.EDU\n*/ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\nmodule.exports = forge.jsbn = forge.jsbn || {};\n// Bits per digit\nvar dbits;\n// JavaScript engine analysis\nvar canary = 0xdeadbeefcafe;\nvar j_lm = (canary & 0xffffff) == 0xefcafe;\n// (public) Constructor\nfunction BigInteger(a, b, c) {\n this.data = [];\n if (a != null) if (\"number\" == typeof a) this.fromNumber(a, b, c);\n else if (b == null && \"string\" != typeof a) this.fromString(a, 256);\n else this.fromString(a, b);\n}\nforge.jsbn.BigInteger = BigInteger;\n// return new, unset BigInteger\nfunction nbi() {\n return new BigInteger(null);\n}\n// am: Compute w_j += (x*this_i), propagate carries,\n// c is initial carry, returns final carry.\n// c < 3*dvalue, x < 2*dvalue, this_i < dvalue\n// We need to select the fastest one that works in this environment.\n// am1: use a single mult and divide to get the high bits,\n// max digit bits should be 26 because\n// max internal value = 2*dvalue^2-2*dvalue (< 2^53)\nfunction am1(i, x, w, j, c, n) {\n while(--n >= 0){\n var v = x * this.data[i++] + w.data[j] + c;\n c = Math.floor(v / 0x4000000);\n w.data[j++] = v & 0x3ffffff;\n }\n return c;\n}\n// am2 avoids a big mult-and-extract completely.\n// Max digit bits should be <= 30 because we do bitwise ops\n// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)\nfunction am2(i, x, w, j, c, n) {\n var xl = x & 0x7fff, xh = x >> 15;\n while(--n >= 0){\n var l = this.data[i] & 0x7fff;\n var h = this.data[i++] >> 15;\n var m = xh * l + h * xl;\n l = xl * l + ((m & 0x7fff) << 15) + w.data[j] + (c & 0x3fffffff);\n c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30);\n w.data[j++] = l & 0x3fffffff;\n }\n return c;\n}\n// Alternately, set max digit bits to 28 since some\n// browsers slow down when dealing with 32-bit numbers.\nfunction am3(i, x, w, j, c, n) {\n var xl = x & 0x3fff, xh = x >> 14;\n while(--n >= 0){\n var l = this.data[i] & 0x3fff;\n var h = this.data[i++] >> 14;\n var m = xh * l + h * xl;\n l = xl * l + ((m & 0x3fff) << 14) + w.data[j] + c;\n c = (l >> 28) + (m >> 14) + xh * h;\n w.data[j++] = l & 0xfffffff;\n }\n return c;\n}\n//
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/md.js":
/*!*******************************************!*\
!*** ./node_modules/node-forge/lib/md.js ***!
\*******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Node.js module for Forge message digests.\n *\n * @author Dave Longley\n *\n * Copyright 2011-2017 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\nmodule.exports = forge.md = forge.md || {};\nforge.md.algorithms = forge.md.algorithms || {};\n//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiKHNzcikvLi9ub2RlX21vZHVsZXMvbm9kZS1mb3JnZS9saWIvbWQuanMiLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztDQU1DO0FBQ0QsSUFBSUEsUUFBUUMsbUJBQU9BLENBQUM7QUFFcEJDLE9BQU9DLE9BQU8sR0FBR0gsTUFBTUksRUFBRSxHQUFHSixNQUFNSSxFQUFFLElBQUksQ0FBQztBQUN6Q0osTUFBTUksRUFBRSxDQUFDQyxVQUFVLEdBQUdMLE1BQU1JLEVBQUUsQ0FBQ0MsVUFBVSxJQUFJLENBQUMiLCJzb3VyY2VzIjpbIndlYnBhY2s6Ly9mbHVzaC1ub3Rlcy8uL25vZGVfbW9kdWxlcy9ub2RlLWZvcmdlL2xpYi9tZC5qcz8yMDQ4Il0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogTm9kZS5qcyBtb2R1bGUgZm9yIEZvcmdlIG1lc3NhZ2UgZGlnZXN0cy5cbiAqXG4gKiBAYXV0aG9yIERhdmUgTG9uZ2xleVxuICpcbiAqIENvcHlyaWdodCAyMDExLTIwMTcgRGlnaXRhbCBCYXphYXIsIEluYy5cbiAqL1xudmFyIGZvcmdlID0gcmVxdWlyZSgnLi9mb3JnZScpO1xuXG5tb2R1bGUuZXhwb3J0cyA9IGZvcmdlLm1kID0gZm9yZ2UubWQgfHwge307XG5mb3JnZS5tZC5hbGdvcml0aG1zID0gZm9yZ2UubWQuYWxnb3JpdGhtcyB8fCB7fTtcbiJdLCJuYW1lcyI6WyJmb3JnZSIsInJlcXVpcmUiLCJtb2R1bGUiLCJleHBvcnRzIiwibWQiLCJhbGdvcml0aG1zIl0sInNvdXJjZVJvb3QiOiIifQ==\n//# sourceURL=webpack-internal:///(ssr)/./node_modules/node-forge/lib/md.js\n");
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/oids.js":
/*!*********************************************!*\
!*** ./node_modules/node-forge/lib/oids.js ***!
\*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Object IDs for ASN.1.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2013 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\nforge.pki = forge.pki || {};\nvar oids = module.exports = forge.pki.oids = forge.oids = forge.oids || {};\n// set id to name mapping and name to id mapping\nfunction _IN(id, name) {\n oids[id] = name;\n oids[name] = id;\n}\n// set id to name mapping only\nfunction _I_(id, name) {\n oids[id] = name;\n}\n// algorithm OIDs\n_IN(\"1.2.840.113549.1.1.1\", \"rsaEncryption\");\n// Note: md2 & md4 not implemented\n//_IN('1.2.840.113549.1.1.2', 'md2WithRSAEncryption');\n//_IN('1.2.840.113549.1.1.3', 'md4WithRSAEncryption');\n_IN(\"1.2.840.113549.1.1.4\", \"md5WithRSAEncryption\");\n_IN(\"1.2.840.113549.1.1.5\", \"sha1WithRSAEncryption\");\n_IN(\"1.2.840.113549.1.1.7\", \"RSAES-OAEP\");\n_IN(\"1.2.840.113549.1.1.8\", \"mgf1\");\n_IN(\"1.2.840.113549.1.1.9\", \"pSpecified\");\n_IN(\"1.2.840.113549.1.1.10\", \"RSASSA-PSS\");\n_IN(\"1.2.840.113549.1.1.11\", \"sha256WithRSAEncryption\");\n_IN(\"1.2.840.113549.1.1.12\", \"sha384WithRSAEncryption\");\n_IN(\"1.2.840.113549.1.1.13\", \"sha512WithRSAEncryption\");\n// Edwards-curve Digital Signature Algorithm (EdDSA) Ed25519\n_IN(\"1.3.101.112\", \"EdDSA25519\");\n_IN(\"1.2.840.10040.4.3\", \"dsa-with-sha1\");\n_IN(\"1.3.14.3.2.7\", \"desCBC\");\n_IN(\"1.3.14.3.2.26\", \"sha1\");\n// Deprecated equivalent of sha1WithRSAEncryption\n_IN(\"1.3.14.3.2.29\", \"sha1WithRSASignature\");\n_IN(\"2.16.840.1.101.3.4.2.1\", \"sha256\");\n_IN(\"2.16.840.1.101.3.4.2.2\", \"sha384\");\n_IN(\"2.16.840.1.101.3.4.2.3\", \"sha512\");\n_IN(\"2.16.840.1.101.3.4.2.4\", \"sha224\");\n_IN(\"2.16.840.1.101.3.4.2.5\", \"sha512-224\");\n_IN(\"2.16.840.1.101.3.4.2.6\", \"sha512-256\");\n_IN(\"1.2.840.113549.2.2\", \"md2\");\n_IN(\"1.2.840.113549.2.5\", \"md5\");\n// pkcs#7 content types\n_IN(\"1.2.840.113549.1.7.1\", \"data\");\n_IN(\"1.2.840.113549.1.7.2\", \"signedData\");\n_IN(\"1.2.840.113549.1.7.3\", \"envelopedData\");\n_IN(\"1.2.840.113549.1.7.4\", \"signedAndEnvelopedData\");\n_IN(\"1.2.840.113549.1.7.5\", \"digestedData\");\n_IN(\"1.2.840.113549.1.7.6\", \"encryptedData\");\n// pkcs#9 oids\n_IN(\"1.2.840.113549.1.9.1\", \"emailAddress\");\n_IN(\"1.2.840.113549.1.9.2\", \"unstructuredName\");\n_IN(\"1.2.840.113549.1.9.3\", \"contentType\");\n_IN(\"1.2.840.113549.1.9.4\", \"messageDigest\");\n_IN(\"1.2.840.113549.1.9.5\", \"signingTime\");\n_IN(\"1.2.840.113549.1.9.6\", \"counterSignature\");\n_IN(\"1.2.840.113549.1.9.7\", \"challengePassword\");\n_IN(\"1.2.840.113549.1.9.8\", \"unstructuredAddress\");\n_IN(\"1.2.840.113549.1.9.14\", \"extensionRequest\");\n_IN(\"1.2.840.113549.1.9.20\", \"friendlyName\");\n_IN(\"1.2.840.113549.1.9.21\", \"localKeyId\");\n_IN(\"1.2.840.113549.1.9.22.1\", \"x509Certificate\");\n// pkcs#12 safe bags\n_IN(\"1.2.840.113549.1.12.10.1.1\", \"keyBag\");\n_IN(\"1.2.840.113549.1.12.10.1.2\", \"pkcs8ShroudedKeyBag\");\n_IN(\"1.2.840.113549.1.12.10.1.3\", \"certBag\");\n_IN(\"1.2.840.113549.1.12.10.1.4\", \"crlBag\");\n_IN(\"1.2.840.113549.1.12.10.1.5\", \"secretBag\");\n_IN(\"1.2.840.113549.1.12.10.1.6\", \"safeContentsBag\");\n// password-based-encryption for pkcs#12\n_IN(\"1.2.840.113549.1.5.13\", \"pkcs5PBES2\");\n_IN(\"1.2.840.113549.1.5.12\", \"pkcs5PBKDF2\");\n_IN(\"1.2.840.113549.1.12.1.1\", \"pbeWithSHAAnd128BitRC4\");\n_IN(\"1.2.840.113549.1.12.1.2\", \"pbeWithSHAAnd40BitRC4\");\n_IN(\"1.2.840.113549.1.12.1.3\", \"pbeWithSHAAnd3-KeyTripleDES-CBC\");\n_IN(\"1.2.840.113549.1.12.1.4\", \"pbeWithSHAAnd2-KeyTripleDES-CBC\");\n_IN(\"1.2.840.113549.1.12.1.5\", \"pbeWithSHAAnd128BitRC2-CBC\");\n_IN(\"1.2.840.113549.1.12.1.6\", \"pbewithSHAAnd40BitRC2-CBC\");\n// hmac OIDs\n_IN(\"1.2.840.113549.2.7\", \"hmacWithSHA1\");\n_IN(\"1.2.840.113549.2.8\", \"hmacWithSHA224\");\n_IN(\"1.2.840.113549.2.9\", \"hmacWithSHA256\");\n_IN(\"1.2.840.113549.2.10\", \"hmacWithSHA384\");\n_IN(\"1.2.840.113549.2.11\", \"hmacWithSHA512\");\n// symmetric key algorithm oids\n_IN(\
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/pbe.js":
/*!********************************************!*\
!*** ./node_modules/node-forge/lib/pbe.js ***!
\********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Password-based encryption functions.\n *\n * @author Dave Longley\n * @author Stefan Siegl <stesie@brokenpipe.de>\n *\n * Copyright (c) 2010-2013 Digital Bazaar, Inc.\n * Copyright (c) 2012 Stefan Siegl <stesie@brokenpipe.de>\n *\n * An EncryptedPrivateKeyInfo:\n *\n * EncryptedPrivateKeyInfo ::= SEQUENCE {\n * encryptionAlgorithm EncryptionAlgorithmIdentifier,\n * encryptedData EncryptedData }\n *\n * EncryptionAlgorithmIdentifier ::= AlgorithmIdentifier\n *\n * EncryptedData ::= OCTET STRING\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./aes */ \"(ssr)/./node_modules/node-forge/lib/aes.js\");\n__webpack_require__(/*! ./asn1 */ \"(ssr)/./node_modules/node-forge/lib/asn1.js\");\n__webpack_require__(/*! ./des */ \"(ssr)/./node_modules/node-forge/lib/des.js\");\n__webpack_require__(/*! ./md */ \"(ssr)/./node_modules/node-forge/lib/md.js\");\n__webpack_require__(/*! ./oids */ \"(ssr)/./node_modules/node-forge/lib/oids.js\");\n__webpack_require__(/*! ./pbkdf2 */ \"(ssr)/./node_modules/node-forge/lib/pbkdf2.js\");\n__webpack_require__(/*! ./pem */ \"(ssr)/./node_modules/node-forge/lib/pem.js\");\n__webpack_require__(/*! ./random */ \"(ssr)/./node_modules/node-forge/lib/random.js\");\n__webpack_require__(/*! ./rc2 */ \"(ssr)/./node_modules/node-forge/lib/rc2.js\");\n__webpack_require__(/*! ./rsa */ \"(ssr)/./node_modules/node-forge/lib/rsa.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\nif (typeof BigInteger === \"undefined\") {\n var BigInteger = forge.jsbn.BigInteger;\n}\n// shortcut for asn.1 API\nvar asn1 = forge.asn1;\n/* Password-based encryption implementation. */ var pki = forge.pki = forge.pki || {};\nmodule.exports = pki.pbe = forge.pbe = forge.pbe || {};\nvar oids = pki.oids;\n// validator for an EncryptedPrivateKeyInfo structure\n// Note: Currently only works w/algorithm params\nvar encryptedPrivateKeyValidator = {\n name: \"EncryptedPrivateKeyInfo\",\n tagClass: asn1.Class.UNIVERSAL,\n type: asn1.Type.SEQUENCE,\n constructed: true,\n value: [\n {\n name: \"EncryptedPrivateKeyInfo.encryptionAlgorithm\",\n tagClass: asn1.Class.UNIVERSAL,\n type: asn1.Type.SEQUENCE,\n constructed: true,\n value: [\n {\n name: \"AlgorithmIdentifier.algorithm\",\n tagClass: asn1.Class.UNIVERSAL,\n type: asn1.Type.OID,\n constructed: false,\n capture: \"encryptionOid\"\n },\n {\n name: \"AlgorithmIdentifier.parameters\",\n tagClass: asn1.Class.UNIVERSAL,\n type: asn1.Type.SEQUENCE,\n constructed: true,\n captureAsn1: \"encryptionParams\"\n }\n ]\n },\n {\n // encryptedData\n name: \"EncryptedPrivateKeyInfo.encryptedData\",\n tagClass: asn1.Class.UNIVERSAL,\n type: asn1.Type.OCTETSTRING,\n constructed: false,\n capture: \"encryptedData\"\n }\n ]\n};\n// validator for a PBES2Algorithms structure\n// Note: Currently only works w/PBKDF2 + AES encryption schemes\nvar PBES2AlgorithmsValidator = {\n name: \"PBES2Algorithms\",\n tagClass: asn1.Class.UNIVERSAL,\n type: asn1.Type.SEQUENCE,\n constructed: true,\n value: [\n {\n name: \"PBES2Algorithms.keyDerivationFunc\",\n tagClass: asn1.Class.UNIVERSAL,\n type: asn1.Type.SEQUENCE,\n constructed: true,\n value: [\n {\n name: \"PBES2Algorithms.keyDerivationFunc.oid\",\n tagClass: asn1.Class.UNIVERSAL,\n type: asn1.Type.OID,\n constructed: false,\n capture: \"kdfOid\"\n },\n {\n name: \"PBE
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/pbkdf2.js":
/*!***********************************************!*\
!*** ./node_modules/node-forge/lib/pbkdf2.js ***!
\***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Password-Based Key-Derivation Function #2 implementation.\n *\n * See RFC 2898 for details.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2013 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./hmac */ \"(ssr)/./node_modules/node-forge/lib/hmac.js\");\n__webpack_require__(/*! ./md */ \"(ssr)/./node_modules/node-forge/lib/md.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\nvar pkcs5 = forge.pkcs5 = forge.pkcs5 || {};\nvar crypto;\nif (forge.util.isNodejs && !forge.options.usePureJavaScript) {\n crypto = __webpack_require__(/*! crypto */ \"crypto\");\n}\n/**\n * Derives a key from a password.\n *\n * @param p the password as a binary-encoded string of bytes.\n * @param s the salt as a binary-encoded string of bytes.\n * @param c the iteration count, a positive integer.\n * @param dkLen the intended length, in bytes, of the derived key,\n * (max: 2^32 - 1) * hash length of the PRF.\n * @param [md] the message digest (or algorithm identifier as a string) to use\n * in the PRF, defaults to SHA-1.\n * @param [callback(err, key)] presence triggers asynchronous version, called\n * once the operation completes.\n *\n * @return the derived key, as a binary-encoded string of bytes, for the\n * synchronous version (if no callback is specified).\n */ module.exports = forge.pbkdf2 = pkcs5.pbkdf2 = function(p, s, c, dkLen, md, callback) {\n if (typeof md === \"function\") {\n callback = md;\n md = null;\n }\n // use native implementation if possible and not disabled, note that\n // some node versions only support SHA-1, others allow digest to be changed\n if (forge.util.isNodejs && !forge.options.usePureJavaScript && crypto.pbkdf2 && (md === null || typeof md !== \"object\") && (crypto.pbkdf2Sync.length > 4 || !md || md === \"sha1\")) {\n if (typeof md !== \"string\") {\n // default prf to SHA-1\n md = \"sha1\";\n }\n p = Buffer.from(p, \"binary\");\n s = Buffer.from(s, \"binary\");\n if (!callback) {\n if (crypto.pbkdf2Sync.length === 4) {\n return crypto.pbkdf2Sync(p, s, c, dkLen).toString(\"binary\");\n }\n return crypto.pbkdf2Sync(p, s, c, dkLen, md).toString(\"binary\");\n }\n if (crypto.pbkdf2Sync.length === 4) {\n return crypto.pbkdf2(p, s, c, dkLen, function(err, key) {\n if (err) {\n return callback(err);\n }\n callback(null, key.toString(\"binary\"));\n });\n }\n return crypto.pbkdf2(p, s, c, dkLen, md, function(err, key) {\n if (err) {\n return callback(err);\n }\n callback(null, key.toString(\"binary\"));\n });\n }\n if (typeof md === \"undefined\" || md === null) {\n // default prf to SHA-1\n md = \"sha1\";\n }\n if (typeof md === \"string\") {\n if (!(md in forge.md.algorithms)) {\n throw new Error(\"Unknown hash algorithm: \" + md);\n }\n md = forge.md[md].create();\n }\n var hLen = md.digestLength;\n /* 1. If dkLen > (2^32 - 1) * hLen, output \"derived key too long\" and\n stop. */ if (dkLen > 0xFFFFFFFF * hLen) {\n var err = new Error(\"Derived key is too long.\");\n if (callback) {\n return callback(err);\n }\n throw err;\n }\n /* 2. Let len be the number of hLen-octet blocks in the derived key,\n rounding up, and let r be the number of octets in the last\n block:\n\n len = CEIL(dkLen / hLen),\n r = dkLen - (len - 1) * hLen. */ var len = Math.ceil(dkLen / hLen);\n var r = dkLen - (len - 1) * hLen;\n /* 3. For each block of the derived key apply the function F defined\n below to the password P, the salt S, the iteration count c, and\n the block index to compute the block:\n\n
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/pem.js":
/*!********************************************!*\
!*** ./node_modules/node-forge/lib/pem.js ***!
\********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Javascript implementation of basic PEM (Privacy Enhanced Mail) algorithms.\n *\n * See: RFC 1421.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2013-2014 Digital Bazaar, Inc.\n *\n * A Forge PEM object has the following fields:\n *\n * type: identifies the type of message (eg: \"RSA PRIVATE KEY\").\n *\n * procType: identifies the type of processing performed on the message,\n * it has two subfields: version and type, eg: 4,ENCRYPTED.\n *\n * contentDomain: identifies the type of content in the message, typically\n * only uses the value: \"RFC822\".\n *\n * dekInfo: identifies the message encryption algorithm and mode and includes\n * any parameters for the algorithm, it has two subfields: algorithm and\n * parameters, eg: DES-CBC,F8143EDE5960C597.\n *\n * headers: contains all other PEM encapsulated headers -- where order is\n * significant (for pairing data like recipient ID + key info).\n *\n * body: the binary-encoded body.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\n// shortcut for pem API\nvar pem = module.exports = forge.pem = forge.pem || {};\n/**\n * Encodes (serializes) the given PEM object.\n *\n * @param msg the PEM message object to encode.\n * @param options the options to use:\n * maxline the maximum characters per line for the body, (default: 64).\n *\n * @return the PEM-formatted string.\n */ pem.encode = function(msg, options) {\n options = options || {};\n var rval = \"-----BEGIN \" + msg.type + \"-----\\r\\n\";\n // encode special headers\n var header;\n if (msg.procType) {\n header = {\n name: \"Proc-Type\",\n values: [\n String(msg.procType.version),\n msg.procType.type\n ]\n };\n rval += foldHeader(header);\n }\n if (msg.contentDomain) {\n header = {\n name: \"Content-Domain\",\n values: [\n msg.contentDomain\n ]\n };\n rval += foldHeader(header);\n }\n if (msg.dekInfo) {\n header = {\n name: \"DEK-Info\",\n values: [\n msg.dekInfo.algorithm\n ]\n };\n if (msg.dekInfo.parameters) {\n header.values.push(msg.dekInfo.parameters);\n }\n rval += foldHeader(header);\n }\n if (msg.headers) {\n // encode all other headers\n for(var i = 0; i < msg.headers.length; ++i){\n rval += foldHeader(msg.headers[i]);\n }\n }\n // terminate header\n if (msg.procType) {\n rval += \"\\r\\n\";\n }\n // add body\n rval += forge.util.encode64(msg.body, options.maxline || 64) + \"\\r\\n\";\n rval += \"-----END \" + msg.type + \"-----\\r\\n\";\n return rval;\n};\n/**\n * Decodes (deserializes) all PEM messages found in the given string.\n *\n * @param str the PEM-formatted string to decode.\n *\n * @return the PEM message objects in an array.\n */ pem.decode = function(str) {\n var rval = [];\n // split string into PEM messages (be lenient w/EOF on BEGIN line)\n var rMessage = /\\s*-----BEGIN ([A-Z0-9- ]+)-----\\r?\\n?([\\x21-\\x7e\\s]+?(?:\\r?\\n\\r?\\n))?([:A-Za-z0-9+\\/=\\s]+?)-----END \\1-----/g;\n var rHeader = /([\\x21-\\x7e]+):\\s*([\\x21-\\x7e\\s^:]+)/;\n var rCRLF = /\\r?\\n/;\n var match;\n while(true){\n match = rMessage.exec(str);\n if (!match) {\n break;\n }\n // accept \"NEW CERTIFICATE REQUEST\" as \"CERTIFICATE REQUEST\"\n // https://datatracker.ietf.org/doc/html/rfc7468#section-7\n var type = match[1];\n if (type === \"NEW CERTIFICATE REQUEST\") {\n type = \"CERTIFICATE REQUEST\";\n }\n var msg = {\n type: type,\n procType: null,\n contentDomain: null,\n dekInfo: null,\n headers: [],\n body: forge.util.decode64(match[3])\
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/pkcs1.js":
/*!**********************************************!*\
!*** ./node_modules/node-forge/lib/pkcs1.js ***!
\**********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Partial implementation of PKCS#1 v2.2: RSA-OEAP\n *\n * Modified but based on the following MIT and BSD licensed code:\n *\n * https://github.com/kjur/jsjws/blob/master/rsa.js:\n *\n * The 'jsjws'(JSON Web Signature JavaScript Library) License\n *\n * Copyright (c) 2012 Kenji Urushima\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n *\n * http://webrsa.cvs.sourceforge.net/viewvc/webrsa/Client/RSAES-OAEP.js?content-type=text%2Fplain:\n *\n * RSAES-OAEP.js\n * $Id: RSAES-OAEP.js,v 1.1.1.1 2003/03/19 15:37:20 ellispritchard Exp $\n * JavaScript Implementation of PKCS #1 v2.1 RSA CRYPTOGRAPHY STANDARD (RSA Laboratories, June 14, 2002)\n * Copyright (C) Ellis Pritchard, Guardian Unlimited 2003.\n * Contact: ellis@nukinetics.com\n * Distributed under the BSD License.\n *\n * Official documentation: http://www.rsa.com/rsalabs/node.asp?id=2125\n *\n * @author Evan Jones (http://evanjones.ca/)\n * @author Dave Longley\n *\n * Copyright (c) 2013-2014 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\n__webpack_require__(/*! ./random */ \"(ssr)/./node_modules/node-forge/lib/random.js\");\n__webpack_require__(/*! ./sha1 */ \"(ssr)/./node_modules/node-forge/lib/sha1.js\");\n// shortcut for PKCS#1 API\nvar pkcs1 = module.exports = forge.pkcs1 = forge.pkcs1 || {};\n/**\n * Encode the given RSAES-OAEP message (M) using key, with optional label (L)\n * and seed.\n *\n * This method does not perform RSA encryption, it only encodes the message\n * using RSAES-OAEP.\n *\n * @param key the RSA key to use.\n * @param message the message to encode.\n * @param options the options to use:\n * label an optional label to use.\n * seed the seed to use.\n * md the message digest object to use, undefined for SHA-1.\n * mgf1 optional mgf1 parameters:\n * md the message digest object to use for MGF1.\n *\n * @return the encoded message bytes.\n */ pkcs1.encode_rsa_oaep = function(key, message, options) {\n // parse arguments\n var label;\n var seed;\n var md;\n var mgf1Md;\n // legacy args (label, seed, md)\n if (typeof options === \"string\") {\n label = options;\n seed = arguments[3] || undefined;\n md = arguments[4] || undefined;\n } else if (options) {\n label = options.label || undefined;\n seed = options.seed || undefined;\n md = options.md || undefined;\n if (options.mgf1 && options.mgf1.md) {\n mgf1Md = options.mgf1.md;\n }\n }\n // default OAEP to SHA-1 message digest\n if (!md) {\n md = forge.md.sha1.create();\n } else {\n md.start();\n }\n // default MGF-1 to same as OAEP\n if (!mgf1Md) {\n mgf1Md = md;\n }\n // compute length in bytes and check output\n var keyLength = Math.ceil(key.n.bitLength() / 8);\n var maxLength = keyLength - 2 * md.digestLengt
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/prime.js":
/*!**********************************************!*\
!*** ./node_modules/node-forge/lib/prime.js ***!
\**********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Prime number generation API.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2014 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\n__webpack_require__(/*! ./jsbn */ \"(ssr)/./node_modules/node-forge/lib/jsbn.js\");\n__webpack_require__(/*! ./random */ \"(ssr)/./node_modules/node-forge/lib/random.js\");\n(function() {\n // forge.prime already defined\n if (forge.prime) {\n module.exports = forge.prime;\n return;\n }\n /* PRIME API */ var prime = module.exports = forge.prime = forge.prime || {};\n var BigInteger = forge.jsbn.BigInteger;\n // primes are 30k+i for i = 1, 7, 11, 13, 17, 19, 23, 29\n var GCD_30_DELTA = [\n 6,\n 4,\n 2,\n 4,\n 2,\n 4,\n 6,\n 2\n ];\n var THIRTY = new BigInteger(null);\n THIRTY.fromInt(30);\n var op_or = function(x, y) {\n return x | y;\n };\n /**\n * Generates a random probable prime with the given number of bits.\n *\n * Alternative algorithms can be specified by name as a string or as an\n * object with custom options like so:\n *\n * {\n * name: 'PRIMEINC',\n * options: {\n * maxBlockTime: <the maximum amount of time to block the main\n * thread before allowing I/O other JS to run>,\n * millerRabinTests: <the number of miller-rabin tests to run>,\n * workerScript: <the worker script URL>,\n * workers: <the number of web workers (if supported) to use,\n * -1 to use estimated cores minus one>.\n * workLoad: the size of the work load, ie: number of possible prime\n * numbers for each web worker to check per work assignment,\n * (default: 100).\n * }\n * }\n *\n * @param bits the number of bits for the prime number.\n * @param options the options to use.\n * [algorithm] the algorithm to use (default: 'PRIMEINC').\n * [prng] a custom crypto-secure pseudo-random number generator to use,\n * that must define \"getBytesSync\".\n *\n * @return callback(err, num) called once the operation completes.\n */ prime.generateProbablePrime = function(bits, options, callback) {\n if (typeof options === \"function\") {\n callback = options;\n options = {};\n }\n options = options || {};\n // default to PRIMEINC algorithm\n var algorithm = options.algorithm || \"PRIMEINC\";\n if (typeof algorithm === \"string\") {\n algorithm = {\n name: algorithm\n };\n }\n algorithm.options = algorithm.options || {};\n // create prng with api that matches BigInteger secure random\n var prng = options.prng || forge.random;\n var rng = {\n // x is an array to fill with bytes\n nextBytes: function(x) {\n var b = prng.getBytesSync(x.length);\n for(var i = 0; i < x.length; ++i){\n x[i] = b.charCodeAt(i);\n }\n }\n };\n if (algorithm.name === \"PRIMEINC\") {\n return primeincFindPrime(bits, rng, algorithm.options, callback);\n }\n throw new Error(\"Invalid prime generation algorithm: \" + algorithm.name);\n };\n function primeincFindPrime(bits, rng, options, callback) {\n if (\"workers\" in options) {\n return primeincFindPrimeWithWorkers(bits, rng, options, callback);\n }\n return primeincFindPrimeWithoutWorkers(bits, rng, options, callback);\n }\n function primeincFindPrimeWithoutWorkers(bits, rng, options, callback) {\n // initialize random number\n var num = generateRandom(bits, rng);\n /* Note: All primes are of the form 30k+i for i < 30 and gcd(30, i)=1. The\n number we are given is always aligned at 30k + 1. Each time the number is\n determined not to be prime we add to get to the next 'i', eg: if the number\n was at 30k +
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/prng.js":
/*!*********************************************!*\
!*** ./node_modules/node-forge/lib/prng.js ***!
\*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * A javascript implementation of a cryptographically-secure\n * Pseudo Random Number Generator (PRNG). The Fortuna algorithm is followed\n * here though the use of SHA-256 is not enforced; when generating an\n * a PRNG context, the hashing algorithm and block cipher used for\n * the generator are specified via a plugin.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2014 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\nvar _crypto = null;\nif (forge.util.isNodejs && !forge.options.usePureJavaScript && !process.versions[\"node-webkit\"]) {\n _crypto = __webpack_require__(/*! crypto */ \"crypto\");\n}\n/* PRNG API */ var prng = module.exports = forge.prng = forge.prng || {};\n/**\n * Creates a new PRNG context.\n *\n * A PRNG plugin must be passed in that will provide:\n *\n * 1. A function that initializes the key and seed of a PRNG context. It\n * will be given a 16 byte key and a 16 byte seed. Any key expansion\n * or transformation of the seed from a byte string into an array of\n * integers (or similar) should be performed.\n * 2. The cryptographic function used by the generator. It takes a key and\n * a seed.\n * 3. A seed increment function. It takes the seed and returns seed + 1.\n * 4. An api to create a message digest.\n *\n * For an example, see random.js.\n *\n * @param plugin the PRNG plugin to use.\n */ prng.create = function(plugin) {\n var ctx = {\n plugin: plugin,\n key: null,\n seed: null,\n time: null,\n // number of reseeds so far\n reseeds: 0,\n // amount of data generated so far\n generated: 0,\n // no initial key bytes\n keyBytes: \"\"\n };\n // create 32 entropy pools (each is a message digest)\n var md = plugin.md;\n var pools = new Array(32);\n for(var i = 0; i < 32; ++i){\n pools[i] = md.create();\n }\n ctx.pools = pools;\n // entropy pools are written to cyclically, starting at index 0\n ctx.pool = 0;\n /**\n * Generates random bytes. The bytes may be generated synchronously or\n * asynchronously. Web workers must use the asynchronous interface or\n * else the behavior is undefined.\n *\n * @param count the number of random bytes to generate.\n * @param [callback(err, bytes)] called once the operation completes.\n *\n * @return count random bytes as a string.\n */ ctx.generate = function(count, callback) {\n // do synchronously\n if (!callback) {\n return ctx.generateSync(count);\n }\n // simple generator using counter-based CBC\n var cipher = ctx.plugin.cipher;\n var increment = ctx.plugin.increment;\n var formatKey = ctx.plugin.formatKey;\n var formatSeed = ctx.plugin.formatSeed;\n var b = forge.util.createBuffer();\n // paranoid deviation from Fortuna:\n // reset key for every request to protect previously\n // generated random bytes should the key be discovered;\n // there is no 100ms based reseeding because of this\n // forced reseed for every `generate` call\n ctx.key = null;\n generate();\n function generate(err) {\n if (err) {\n return callback(err);\n }\n // sufficient bytes generated\n if (b.length() >= count) {\n return callback(null, b.getBytes(count));\n }\n // if amount of data generated is greater than 1 MiB, trigger reseed\n if (ctx.generated > 0xfffff) {\n ctx.key = null;\n }\n if (ctx.key === null) {\n // prevent stack overflow\n return forge.util.nextTick(function() {\n _reseed(generate);\n });\n }\n // generate the random bytes\n var bytes = cipher(ctx.key, ctx.seed);\n ctx.generated
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/random.js":
/*!***********************************************!*\
!*** ./node_modules/node-forge/lib/random.js ***!
\***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * An API for getting cryptographically-secure random bytes. The bytes are\n * generated using the Fortuna algorithm devised by Bruce Schneier and\n * Niels Ferguson.\n *\n * Getting strong random bytes is not yet easy to do in javascript. The only\n * truish random entropy that can be collected is from the mouse, keyboard, or\n * from timing with respect to page loads, etc. This generator makes a poor\n * attempt at providing random bytes when those sources haven't yet provided\n * enough entropy to initially seed or to reseed the PRNG.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2009-2014 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./aes */ \"(ssr)/./node_modules/node-forge/lib/aes.js\");\n__webpack_require__(/*! ./sha256 */ \"(ssr)/./node_modules/node-forge/lib/sha256.js\");\n__webpack_require__(/*! ./prng */ \"(ssr)/./node_modules/node-forge/lib/prng.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\n(function() {\n // forge.random already defined\n if (forge.random && forge.random.getBytes) {\n module.exports = forge.random;\n return;\n }\n (function(jQuery1) {\n // the default prng plugin, uses AES-128\n var prng_aes = {};\n var _prng_aes_output = new Array(4);\n var _prng_aes_buffer = forge.util.createBuffer();\n prng_aes.formatKey = function(key) {\n // convert the key into 32-bit integers\n var tmp = forge.util.createBuffer(key);\n key = new Array(4);\n key[0] = tmp.getInt32();\n key[1] = tmp.getInt32();\n key[2] = tmp.getInt32();\n key[3] = tmp.getInt32();\n // return the expanded key\n return forge.aes._expandKey(key, false);\n };\n prng_aes.formatSeed = function(seed) {\n // convert seed into 32-bit integers\n var tmp = forge.util.createBuffer(seed);\n seed = new Array(4);\n seed[0] = tmp.getInt32();\n seed[1] = tmp.getInt32();\n seed[2] = tmp.getInt32();\n seed[3] = tmp.getInt32();\n return seed;\n };\n prng_aes.cipher = function(key, seed) {\n forge.aes._updateBlock(key, seed, _prng_aes_output, false);\n _prng_aes_buffer.putInt32(_prng_aes_output[0]);\n _prng_aes_buffer.putInt32(_prng_aes_output[1]);\n _prng_aes_buffer.putInt32(_prng_aes_output[2]);\n _prng_aes_buffer.putInt32(_prng_aes_output[3]);\n return _prng_aes_buffer.getBytes();\n };\n prng_aes.increment = function(seed) {\n // FIXME: do we care about carry or signed issues?\n ++seed[3];\n return seed;\n };\n prng_aes.md = forge.md.sha256;\n /**\n * Creates a new PRNG.\n */ function spawnPrng() {\n var ctx = forge.prng.create(prng_aes);\n /**\n * Gets random bytes. If a native secure crypto API is unavailable, this\n * method tries to make the bytes more unpredictable by drawing from data that\n * can be collected from the user of the browser, eg: mouse movement.\n *\n * If a callback is given, this method will be called asynchronously.\n *\n * @param count the number of random bytes to get.\n * @param [callback(err, bytes)] called once the operation completes.\n *\n * @return the random bytes in a string.\n */ ctx.getBytes = function(count, callback) {\n return ctx.generate(count, callback);\n };\n /**\n * Gets random bytes asynchronously. If a native secure crypto API is\n * unavailable, this method tries to make the bytes more unpredictable by\n * drawing from data that can be collected from the user of the browser,\n * eg: mouse movement.\n *\n * @param count the number of random bytes to get.\n *\n * @return the random bytes in a string.\n */ ctx.getBytesSync = function(count) {\n
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/rc2.js":
/*!********************************************!*\
!*** ./node_modules/node-forge/lib/rc2.js ***!
\********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * RC2 implementation.\n *\n * @author Stefan Siegl\n *\n * Copyright (c) 2012 Stefan Siegl <stesie@brokenpipe.de>\n *\n * Information on the RC2 cipher is available from RFC #2268,\n * http://www.ietf.org/rfc/rfc2268.txt\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\nvar piTable = [\n 0xd9,\n 0x78,\n 0xf9,\n 0xc4,\n 0x19,\n 0xdd,\n 0xb5,\n 0xed,\n 0x28,\n 0xe9,\n 0xfd,\n 0x79,\n 0x4a,\n 0xa0,\n 0xd8,\n 0x9d,\n 0xc6,\n 0x7e,\n 0x37,\n 0x83,\n 0x2b,\n 0x76,\n 0x53,\n 0x8e,\n 0x62,\n 0x4c,\n 0x64,\n 0x88,\n 0x44,\n 0x8b,\n 0xfb,\n 0xa2,\n 0x17,\n 0x9a,\n 0x59,\n 0xf5,\n 0x87,\n 0xb3,\n 0x4f,\n 0x13,\n 0x61,\n 0x45,\n 0x6d,\n 0x8d,\n 0x09,\n 0x81,\n 0x7d,\n 0x32,\n 0xbd,\n 0x8f,\n 0x40,\n 0xeb,\n 0x86,\n 0xb7,\n 0x7b,\n 0x0b,\n 0xf0,\n 0x95,\n 0x21,\n 0x22,\n 0x5c,\n 0x6b,\n 0x4e,\n 0x82,\n 0x54,\n 0xd6,\n 0x65,\n 0x93,\n 0xce,\n 0x60,\n 0xb2,\n 0x1c,\n 0x73,\n 0x56,\n 0xc0,\n 0x14,\n 0xa7,\n 0x8c,\n 0xf1,\n 0xdc,\n 0x12,\n 0x75,\n 0xca,\n 0x1f,\n 0x3b,\n 0xbe,\n 0xe4,\n 0xd1,\n 0x42,\n 0x3d,\n 0xd4,\n 0x30,\n 0xa3,\n 0x3c,\n 0xb6,\n 0x26,\n 0x6f,\n 0xbf,\n 0x0e,\n 0xda,\n 0x46,\n 0x69,\n 0x07,\n 0x57,\n 0x27,\n 0xf2,\n 0x1d,\n 0x9b,\n 0xbc,\n 0x94,\n 0x43,\n 0x03,\n 0xf8,\n 0x11,\n 0xc7,\n 0xf6,\n 0x90,\n 0xef,\n 0x3e,\n 0xe7,\n 0x06,\n 0xc3,\n 0xd5,\n 0x2f,\n 0xc8,\n 0x66,\n 0x1e,\n 0xd7,\n 0x08,\n 0xe8,\n 0xea,\n 0xde,\n 0x80,\n 0x52,\n 0xee,\n 0xf7,\n 0x84,\n 0xaa,\n 0x72,\n 0xac,\n 0x35,\n 0x4d,\n 0x6a,\n 0x2a,\n 0x96,\n 0x1a,\n 0xd2,\n 0x71,\n 0x5a,\n 0x15,\n 0x49,\n 0x74,\n 0x4b,\n 0x9f,\n 0xd0,\n 0x5e,\n 0x04,\n 0x18,\n 0xa4,\n 0xec,\n 0xc2,\n 0xe0,\n 0x41,\n 0x6e,\n 0x0f,\n 0x51,\n 0xcb,\n 0xcc,\n 0x24,\n 0x91,\n 0xaf,\n 0x50,\n 0xa1,\n 0xf4,\n 0x70,\n 0x39,\n 0x99,\n 0x7c,\n 0x3a,\n 0x85,\n 0x23,\n 0xb8,\n 0xb4,\n 0x7a,\n 0xfc,\n 0x02,\n 0x36,\n 0x5b,\n 0x25,\n 0x55,\n 0x97,\n 0x31,\n 0x2d,\n 0x5d,\n 0xfa,\n 0x98,\n 0xe3,\n 0x8a,\n 0x92,\n 0xae,\n 0x05,\n 0xdf,\n 0x29,\n 0x10,\n 0x67,\n 0x6c,\n 0xba,\n 0xc9,\n 0xd3,\n 0x00,\n 0xe6,\n 0xcf,\n 0xe1,\n 0x9e,\n 0xa8,\n 0x2c,\n 0x63,\n 0x16,\n 0x01,\n 0x3f,\n 0x58,\n 0xe2,\n 0x89,\n 0xa9,\n 0x0d,\n 0x38,\n 0x34,\n 0x1b,\n 0xab,\n 0x33,\n 0xff,\n 0xb0,\n 0xbb,\n 0x48,\n 0x0c,\n 0x5f,\n 0xb9,\n 0xb1,\n 0xcd,\n 0x2e,\n 0xc5,\n 0xf3,\n 0xdb,\n 0x47,\n 0xe5,\n 0xa5,\n 0x9c,\n 0x77,\n 0x0a,\n 0xa6,\n 0x20,\n 0x68,\n 0xfe,\n 0x7f,\n 0xc1,\n 0xad\n];\nvar s = [\n 1,\n 2,\n 3,\n 5\n];\n/**\n * Rotate a word left by given number of bits.\n *\n * Bits that are shifted out on the left are put back in on the right\n * hand side.\n *\n * @param word The word to shift left.\n * @param bits The number of bits to shift by.\n * @return The rotated word.\n */ var rol = function(word, bits) {\n return word << bits & 0xffff | (word & 0xffff) >> 16 - bits;\n};\n/**\n * Rotate a word right by given number of bits.\n *\n * Bits that are shifted out on the right are put back in on the left\n * hand side.\n *\n * @param word The word to shift right.\n * @param bits The number of bits to shift by.\n * @return The rotated word.\n */ var ror = function(word, bits) {\n return (word & 0xffff) >> bits | word << 16 - bits & 0xffff;\n};\n/* RC2 API */ module.exports = forge.rc2
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/rsa.js":
/*!********************************************!*\
!*** ./node_modules/node-forge/lib/rsa.js ***!
\********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Javascript implementation of basic RSA algorithms.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2014 Digital Bazaar, Inc.\n *\n * The only algorithm currently supported for PKI is RSA.\n *\n * An RSA key is often stored in ASN.1 DER format. The SubjectPublicKeyInfo\n * ASN.1 structure is composed of an algorithm of type AlgorithmIdentifier\n * and a subjectPublicKey of type bit string.\n *\n * The AlgorithmIdentifier contains an Object Identifier (OID) and parameters\n * for the algorithm, if any. In the case of RSA, there aren't any.\n *\n * SubjectPublicKeyInfo ::= SEQUENCE {\n * algorithm AlgorithmIdentifier,\n * subjectPublicKey BIT STRING\n * }\n *\n * AlgorithmIdentifer ::= SEQUENCE {\n * algorithm OBJECT IDENTIFIER,\n * parameters ANY DEFINED BY algorithm OPTIONAL\n * }\n *\n * For an RSA public key, the subjectPublicKey is:\n *\n * RSAPublicKey ::= SEQUENCE {\n * modulus INTEGER, -- n\n * publicExponent INTEGER -- e\n * }\n *\n * PrivateKeyInfo ::= SEQUENCE {\n * version Version,\n * privateKeyAlgorithm PrivateKeyAlgorithmIdentifier,\n * privateKey PrivateKey,\n * attributes [0] IMPLICIT Attributes OPTIONAL\n * }\n *\n * Version ::= INTEGER\n * PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier\n * PrivateKey ::= OCTET STRING\n * Attributes ::= SET OF Attribute\n *\n * An RSA private key as the following structure:\n *\n * RSAPrivateKey ::= SEQUENCE {\n * version Version,\n * modulus INTEGER, -- n\n * publicExponent INTEGER, -- e\n * privateExponent INTEGER, -- d\n * prime1 INTEGER, -- p\n * prime2 INTEGER, -- q\n * exponent1 INTEGER, -- d mod (p-1)\n * exponent2 INTEGER, -- d mod (q-1)\n * coefficient INTEGER -- (inverse of q) mod p\n * }\n *\n * Version ::= INTEGER\n *\n * The OID for the RSA key algorithm is: 1.2.840.113549.1.1.1\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./asn1 */ \"(ssr)/./node_modules/node-forge/lib/asn1.js\");\n__webpack_require__(/*! ./jsbn */ \"(ssr)/./node_modules/node-forge/lib/jsbn.js\");\n__webpack_require__(/*! ./oids */ \"(ssr)/./node_modules/node-forge/lib/oids.js\");\n__webpack_require__(/*! ./pkcs1 */ \"(ssr)/./node_modules/node-forge/lib/pkcs1.js\");\n__webpack_require__(/*! ./prime */ \"(ssr)/./node_modules/node-forge/lib/prime.js\");\n__webpack_require__(/*! ./random */ \"(ssr)/./node_modules/node-forge/lib/random.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\nif (typeof BigInteger === \"undefined\") {\n var BigInteger = forge.jsbn.BigInteger;\n}\nvar _crypto = forge.util.isNodejs ? __webpack_require__(/*! crypto */ \"crypto\") : null;\n// shortcut for asn.1 API\nvar asn1 = forge.asn1;\n// shortcut for util API\nvar util = forge.util;\n/*\n * RSA encryption and decryption, see RFC 2313.\n */ forge.pki = forge.pki || {};\nmodule.exports = forge.pki.rsa = forge.rsa = forge.rsa || {};\nvar pki = forge.pki;\n// for finding primes, which are 30k+i for i = 1, 7, 11, 13, 17, 19, 23, 29\nvar GCD_30_DELTA = [\n 6,\n 4,\n 2,\n 4,\n 2,\n 4,\n 6,\n 2\n];\n// validator for a PrivateKeyInfo structure\nvar privateKeyValidator = {\n // PrivateKeyInfo\n name: \"PrivateKeyInfo\",\n tagClass: asn1.Class.UNIVERSAL,\n type: asn1.Type.SEQUENCE,\n constructed: true,\n value: [\n {\n // Version (INTEGER)\n name: \"PrivateKeyInfo.version\",\n tagClass: asn1.Class.UNIVERSAL,\n type: asn1.Type.INTEGER,\n constructed: false,\n capture: \"privateKeyVersion\"\n },\n {\n // privateKeyAlgorithm\n name: \"PrivateKeyInfo.privateKeyAlgorithm\",\n tagClass: asn1.Class.UNIVERSAL,\n type: asn1.Type.SEQUENCE,\n constructed: true,\n value: [\n {\n name: \"AlgorithmIdentifier.algorithm\",\n tagClass: as
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/sha1.js":
/*!*********************************************!*\
!*** ./node_modules/node-forge/lib/sha1.js ***!
\*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Secure Hash Algorithm with 160-bit digest (SHA-1) implementation.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2015 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./md */ \"(ssr)/./node_modules/node-forge/lib/md.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\nvar sha1 = module.exports = forge.sha1 = forge.sha1 || {};\nforge.md.sha1 = forge.md.algorithms.sha1 = sha1;\n/**\n * Creates a SHA-1 message digest object.\n *\n * @return a message digest object.\n */ sha1.create = function() {\n // do initialization as necessary\n if (!_initialized) {\n _init();\n }\n // SHA-1 state contains five 32-bit integers\n var _state = null;\n // input buffer\n var _input = forge.util.createBuffer();\n // used for word storage\n var _w = new Array(80);\n // message digest object\n var md = {\n algorithm: \"sha1\",\n blockLength: 64,\n digestLength: 20,\n // 56-bit length of message so far (does not including padding)\n messageLength: 0,\n // true message length\n fullMessageLength: null,\n // size of message length in bytes\n messageLengthSize: 8\n };\n /**\n * Starts the digest.\n *\n * @return this digest object.\n */ md.start = function() {\n // up to 56-bit message length for convenience\n md.messageLength = 0;\n // full message length (set md.messageLength64 for backwards-compatibility)\n md.fullMessageLength = md.messageLength64 = [];\n var int32s = md.messageLengthSize / 4;\n for(var i = 0; i < int32s; ++i){\n md.fullMessageLength.push(0);\n }\n _input = forge.util.createBuffer();\n _state = {\n h0: 0x67452301,\n h1: 0xEFCDAB89,\n h2: 0x98BADCFE,\n h3: 0x10325476,\n h4: 0xC3D2E1F0\n };\n return md;\n };\n // start digest automatically for first time\n md.start();\n /**\n * Updates the digest with the given message input. The given input can\n * treated as raw input (no encoding will be applied) or an encoding of\n * 'utf8' maybe given to encode the input using UTF-8.\n *\n * @param msg the message input to update with.\n * @param encoding the encoding to use (default: 'raw', other: 'utf8').\n *\n * @return this digest object.\n */ md.update = function(msg, encoding) {\n if (encoding === \"utf8\") {\n msg = forge.util.encodeUtf8(msg);\n }\n // update message length\n var len = msg.length;\n md.messageLength += len;\n len = [\n len / 0x100000000 >>> 0,\n len >>> 0\n ];\n for(var i = md.fullMessageLength.length - 1; i >= 0; --i){\n md.fullMessageLength[i] += len[1];\n len[1] = len[0] + (md.fullMessageLength[i] / 0x100000000 >>> 0);\n md.fullMessageLength[i] = md.fullMessageLength[i] >>> 0;\n len[0] = len[1] / 0x100000000 >>> 0;\n }\n // add bytes to input buffer\n _input.putBytes(msg);\n // process bytes\n _update(_state, _w, _input);\n // compact input buffer every 2K or if empty\n if (_input.read > 2048 || _input.length() === 0) {\n _input.compact();\n }\n return md;\n };\n /**\n * Produces the digest.\n *\n * @return a byte buffer containing the digest value.\n */ md.digest = function() {\n /* Note: Here we copy the remaining bytes in the input buffer and\n add the appropriate SHA-1 padding. Then we do the final update\n on a copy of the state so that if the user wants to get\n intermediate digests they can do so. */ /* Determine the number of bytes that must be added to the message\n to ensure its length is congruent to 448 mod 512. In other words,\n the data to be digested must be a multiple of 512 bits (or 128 bytes).\n This data i
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/sha256.js":
/*!***********************************************!*\
!*** ./node_modules/node-forge/lib/sha256.js ***!
\***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Secure Hash Algorithm with 256-bit digest (SHA-256) implementation.\n *\n * See FIPS 180-2 for details.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2015 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./md */ \"(ssr)/./node_modules/node-forge/lib/md.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\nvar sha256 = module.exports = forge.sha256 = forge.sha256 || {};\nforge.md.sha256 = forge.md.algorithms.sha256 = sha256;\n/**\n * Creates a SHA-256 message digest object.\n *\n * @return a message digest object.\n */ sha256.create = function() {\n // do initialization as necessary\n if (!_initialized) {\n _init();\n }\n // SHA-256 state contains eight 32-bit integers\n var _state = null;\n // input buffer\n var _input = forge.util.createBuffer();\n // used for word storage\n var _w = new Array(64);\n // message digest object\n var md = {\n algorithm: \"sha256\",\n blockLength: 64,\n digestLength: 32,\n // 56-bit length of message so far (does not including padding)\n messageLength: 0,\n // true message length\n fullMessageLength: null,\n // size of message length in bytes\n messageLengthSize: 8\n };\n /**\n * Starts the digest.\n *\n * @return this digest object.\n */ md.start = function() {\n // up to 56-bit message length for convenience\n md.messageLength = 0;\n // full message length (set md.messageLength64 for backwards-compatibility)\n md.fullMessageLength = md.messageLength64 = [];\n var int32s = md.messageLengthSize / 4;\n for(var i = 0; i < int32s; ++i){\n md.fullMessageLength.push(0);\n }\n _input = forge.util.createBuffer();\n _state = {\n h0: 0x6A09E667,\n h1: 0xBB67AE85,\n h2: 0x3C6EF372,\n h3: 0xA54FF53A,\n h4: 0x510E527F,\n h5: 0x9B05688C,\n h6: 0x1F83D9AB,\n h7: 0x5BE0CD19\n };\n return md;\n };\n // start digest automatically for first time\n md.start();\n /**\n * Updates the digest with the given message input. The given input can\n * treated as raw input (no encoding will be applied) or an encoding of\n * 'utf8' maybe given to encode the input using UTF-8.\n *\n * @param msg the message input to update with.\n * @param encoding the encoding to use (default: 'raw', other: 'utf8').\n *\n * @return this digest object.\n */ md.update = function(msg, encoding) {\n if (encoding === \"utf8\") {\n msg = forge.util.encodeUtf8(msg);\n }\n // update message length\n var len = msg.length;\n md.messageLength += len;\n len = [\n len / 0x100000000 >>> 0,\n len >>> 0\n ];\n for(var i = md.fullMessageLength.length - 1; i >= 0; --i){\n md.fullMessageLength[i] += len[1];\n len[1] = len[0] + (md.fullMessageLength[i] / 0x100000000 >>> 0);\n md.fullMessageLength[i] = md.fullMessageLength[i] >>> 0;\n len[0] = len[1] / 0x100000000 >>> 0;\n }\n // add bytes to input buffer\n _input.putBytes(msg);\n // process bytes\n _update(_state, _w, _input);\n // compact input buffer every 2K or if empty\n if (_input.read > 2048 || _input.length() === 0) {\n _input.compact();\n }\n return md;\n };\n /**\n * Produces the digest.\n *\n * @return a byte buffer containing the digest value.\n */ md.digest = function() {\n /* Note: Here we copy the remaining bytes in the input buffer and\n add the appropriate SHA-256 padding. Then we do the final update\n on a copy of the state so that if the user wants to get\n intermediate digests they can do so. */ /* Determine the number of bytes that must be added to the message\n to ensure
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/sha512.js":
/*!***********************************************!*\
!*** ./node_modules/node-forge/lib/sha512.js ***!
\***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Secure Hash Algorithm with a 1024-bit block size implementation.\n *\n * This includes: SHA-512, SHA-384, SHA-512/224, and SHA-512/256. For\n * SHA-256 (block size 512 bits), see sha256.js.\n *\n * See FIPS 180-4 for details.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2014-2015 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\n__webpack_require__(/*! ./md */ \"(ssr)/./node_modules/node-forge/lib/md.js\");\n__webpack_require__(/*! ./util */ \"(ssr)/./node_modules/node-forge/lib/util.js\");\nvar sha512 = module.exports = forge.sha512 = forge.sha512 || {};\n// SHA-512\nforge.md.sha512 = forge.md.algorithms.sha512 = sha512;\n// SHA-384\nvar sha384 = forge.sha384 = forge.sha512.sha384 = forge.sha512.sha384 || {};\nsha384.create = function() {\n return sha512.create(\"SHA-384\");\n};\nforge.md.sha384 = forge.md.algorithms.sha384 = sha384;\n// SHA-512/256\nforge.sha512.sha256 = forge.sha512.sha256 || {\n create: function() {\n return sha512.create(\"SHA-512/256\");\n }\n};\nforge.md[\"sha512/256\"] = forge.md.algorithms[\"sha512/256\"] = forge.sha512.sha256;\n// SHA-512/224\nforge.sha512.sha224 = forge.sha512.sha224 || {\n create: function() {\n return sha512.create(\"SHA-512/224\");\n }\n};\nforge.md[\"sha512/224\"] = forge.md.algorithms[\"sha512/224\"] = forge.sha512.sha224;\n/**\n * Creates a SHA-2 message digest object.\n *\n * @param algorithm the algorithm to use (SHA-512, SHA-384, SHA-512/224,\n * SHA-512/256).\n *\n * @return a message digest object.\n */ sha512.create = function(algorithm) {\n // do initialization as necessary\n if (!_initialized) {\n _init();\n }\n if (typeof algorithm === \"undefined\") {\n algorithm = \"SHA-512\";\n }\n if (!(algorithm in _states)) {\n throw new Error(\"Invalid SHA-512 algorithm: \" + algorithm);\n }\n // SHA-512 state contains eight 64-bit integers (each as two 32-bit ints)\n var _state = _states[algorithm];\n var _h = null;\n // input buffer\n var _input = forge.util.createBuffer();\n // used for 64-bit word storage\n var _w = new Array(80);\n for(var wi = 0; wi < 80; ++wi){\n _w[wi] = new Array(2);\n }\n // determine digest length by algorithm name (default)\n var digestLength = 64;\n switch(algorithm){\n case \"SHA-384\":\n digestLength = 48;\n break;\n case \"SHA-512/256\":\n digestLength = 32;\n break;\n case \"SHA-512/224\":\n digestLength = 28;\n break;\n }\n // message digest object\n var md = {\n // SHA-512 => sha512\n algorithm: algorithm.replace(\"-\", \"\").toLowerCase(),\n blockLength: 128,\n digestLength: digestLength,\n // 56-bit length of message so far (does not including padding)\n messageLength: 0,\n // true message length\n fullMessageLength: null,\n // size of message length in bytes\n messageLengthSize: 16\n };\n /**\n * Starts the digest.\n *\n * @return this digest object.\n */ md.start = function() {\n // up to 56-bit message length for convenience\n md.messageLength = 0;\n // full message length (set md.messageLength128 for backwards-compatibility)\n md.fullMessageLength = md.messageLength128 = [];\n var int32s = md.messageLengthSize / 4;\n for(var i = 0; i < int32s; ++i){\n md.fullMessageLength.push(0);\n }\n _input = forge.util.createBuffer();\n _h = new Array(_state.length);\n for(var i = 0; i < _state.length; ++i){\n _h[i] = _state[i].slice(0);\n }\n return md;\n };\n // start digest automatically for first time\n md.start();\n /**\n * Updates the digest with the given message input. The given input can\n * treated as raw input (no encoding will be applied) or an encoding of\n * 'utf8' maybe given to encode the input using UTF-8.\n *
/***/ }),
/***/ "(ssr)/./node_modules/node-forge/lib/util.js":
/*!*********************************************!*\
!*** ./node_modules/node-forge/lib/util.js ***!
\*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
eval("/**\n * Utility functions for web applications.\n *\n * @author Dave Longley\n *\n * Copyright (c) 2010-2018 Digital Bazaar, Inc.\n */ \nvar forge = __webpack_require__(/*! ./forge */ \"(ssr)/./node_modules/node-forge/lib/forge.js\");\nvar baseN = __webpack_require__(/*! ./baseN */ \"(ssr)/./node_modules/node-forge/lib/baseN.js\");\n/* Utilities API */ var util = module.exports = forge.util = forge.util || {};\n// define setImmediate and nextTick\n(function() {\n // use native nextTick (unless we're in webpack)\n // webpack (or better node-libs-browser polyfill) sets process.browser.\n // this way we can detect webpack properly\n if (typeof process !== \"undefined\" && process.nextTick && !false) {\n util.nextTick = process.nextTick;\n if (typeof setImmediate === \"function\") {\n util.setImmediate = setImmediate;\n } else {\n // polyfill setImmediate with nextTick, older versions of node\n // (those w/o setImmediate) won't totally starve IO\n util.setImmediate = util.nextTick;\n }\n return;\n }\n // polyfill nextTick with native setImmediate\n if (typeof setImmediate === \"function\") {\n util.setImmediate = function() {\n return setImmediate.apply(undefined, arguments);\n };\n util.nextTick = function(callback) {\n return setImmediate(callback);\n };\n return;\n }\n /* Note: A polyfill upgrade pattern is used here to allow combining\n polyfills. For example, MutationObserver is fast, but blocks UI updates,\n so it needs to allow UI updates periodically, so it falls back on\n postMessage or setTimeout. */ // polyfill with setTimeout\n util.setImmediate = function(callback) {\n setTimeout(callback, 0);\n };\n // upgrade polyfill to use postMessage\n if (false) { var callbacks, msg; }\n // upgrade polyfill to use MutationObserver\n if (typeof MutationObserver !== \"undefined\") {\n // polyfill with MutationObserver\n var now = Date.now();\n var attr = true;\n var div = document.createElement(\"div\");\n var callbacks = [];\n new MutationObserver(function() {\n var copy = callbacks.slice();\n callbacks.length = 0;\n copy.forEach(function(callback) {\n callback();\n });\n }).observe(div, {\n attributes: true\n });\n var oldSetImmediate = util.setImmediate;\n util.setImmediate = function(callback) {\n if (Date.now() - now > 15) {\n now = Date.now();\n oldSetImmediate(callback);\n } else {\n callbacks.push(callback);\n // only trigger observer when it hasn't been triggered in\n // the current turn of the event loop\n if (callbacks.length === 1) {\n div.setAttribute(\"a\", attr = !attr);\n }\n }\n };\n }\n util.nextTick = util.setImmediate;\n})();\n// check if running under Node.js\nutil.isNodejs = typeof process !== \"undefined\" && process.versions && process.versions.node;\n// 'self' will also work in Web Workers (instance of WorkerGlobalScope) while\n// it will point to `window` in the main thread.\n// To remain compatible with older browsers, we fall back to 'window' if 'self'\n// is not available.\nutil.globalScope = function() {\n if (util.isNodejs) {\n return global;\n }\n return typeof self === \"undefined\" ? window : self;\n}();\n// define isArray\nutil.isArray = Array.isArray || function(x) {\n return Object.prototype.toString.call(x) === \"[object Array]\";\n};\n// define isArrayBuffer\nutil.isArrayBuffer = function(x) {\n return typeof ArrayBuffer !== \"undefined\" && x instanceof ArrayBuffer;\n};\n// define isArrayBufferView\nutil.isArrayBufferView = function(x) {\n return x && util.isArrayBuffer(x.buffer) && x.byteLength !== undefined;\n};\n/**\n * Ensure a bits param is 8, 16, 24, or 32.
/***/ })
};
;
Reference in New Issue Copy Permalink