//*******************************************************************************

//

// 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);

}