otpauth
Version:
One Time Password (HOTP/TOTP) library for Node.js and browsers
2,695 lines • 79 kB
JavaScript
/*! otpauth v6.0.0 | (c) Héctor Molinero Fernández <hector@molinero.dev> | MIT | https://github.com/hectorm/otpauth */
/*! sjcl v1.0.8 | (c) bitwiseshiftleft | (BSD-2-Clause OR GPL-2.0-only) | https://github.com/bitwiseshiftleft/sjcl */
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = global || self, factory(global.OTPAuth = {}));
}(this, (function (exports) { 'use strict';
function _typeof(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function (obj) {
return typeof obj;
};
} else {
_typeof = function (obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
}
return _typeof(obj);
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(o);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
function _createForOfIteratorHelper(o, allowArrayLike) {
var it;
if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
if (it) o = it;
var i = 0;
var F = function () {};
return {
s: F,
n: function () {
if (i >= o.length) return {
done: true
};
return {
done: false,
value: o[i++]
};
},
e: function (e) {
throw e;
},
f: F
};
}
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
var normalCompletion = true,
didErr = false,
err;
return {
s: function () {
it = o[Symbol.iterator]();
},
n: function () {
var step = it.next();
normalCompletion = step.done;
return step;
},
e: function (e) {
didErr = true;
err = e;
},
f: function () {
try {
if (!normalCompletion && it.return != null) it.return();
} finally {
if (didErr) throw err;
}
}
};
}
/**
* An object containing some utilities.
* @type {Object}
*/
var Utils = {
/**
* UInt conversion.
* @type {Object}
*/
uint: {
/**
* Converts an ArrayBuffer to an integer.
* @param {ArrayBuffer} buf ArrayBuffer.
* @returns {number} Integer.
*/
fromBuf: function fromBuf(buf) {
var arr = new Uint8Array(buf);
var num = 0;
for (var i = 0; i < arr.length; i++) {
if (arr[i] !== 0) {
num *= 256;
num += arr[i];
}
}
return num;
},
/**
* Converts an integer to an ArrayBuffer.
* @param {number} num Integer.
* @returns {ArrayBuffer} ArrayBuffer.
*/
toBuf: function toBuf(num) {
var buf = new ArrayBuffer(8);
var arr = new Uint8Array(buf);
var acc = num;
for (var i = 7; i >= 0; i--) {
if (acc === 0) break;
arr[i] = acc & 255;
acc -= arr[i];
acc /= 256;
}
return buf;
}
},
/**
* Raw string conversion.
* @type {Object}
*/
raw: {
/**
* Converts an ArrayBuffer to a string.
* @param {ArrayBuffer} buf ArrayBuffer.
* @returns {string} String.
*/
fromBuf: function fromBuf(buf) {
var arr = new Uint8Array(buf);
var str = '';
for (var i = 0; i < arr.length; i++) {
str += String.fromCharCode(arr[i]);
}
return str;
},
/**
* Converts a string to an ArrayBuffer.
* @param {string} str String.
* @returns {ArrayBuffer} ArrayBuffer.
*/
toBuf: function toBuf(str) {
var buf = new ArrayBuffer(str.length);
var arr = new Uint8Array(buf);
for (var i = 0; i < str.length; i++) {
arr[i] = str.charCodeAt(i);
}
return buf;
}
},
/**
* Base32 string conversion.
* @type {Object}
*/
b32: {
/**
* RFC 4648 base32 alphabet without pad.
* @type {string}
*/
alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
/**
* Converts an ArrayBuffer to a base32 string (RFC 4648)
* (https://github.com/LinusU/base32-encode).
* @param {ArrayBuffer} buf ArrayBuffer.
* @returns {string} Base32 string.
*/
fromBuf: function fromBuf(buf) {
var arr = new Uint8Array(buf);
var bits = 0;
var value = 0;
var str = '';
for (var i = 0; i < arr.length; i++) {
value = value << 8 | arr[i];
bits += 8;
while (bits >= 5) {
str += Utils.b32.alphabet[value >>> bits - 5 & 31];
bits -= 5;
}
}
if (bits > 0) {
str += Utils.b32.alphabet[value << 5 - bits & 31];
}
return str;
},
/**
* Converts a base32 string to an ArrayBuffer (RFC 4648)
* (https://github.com/LinusU/base32-decode).
* @param {string} str Base32 string.
* @returns {ArrayBuffer} ArrayBuffer.
*/
toBuf: function toBuf(str) {
// Canonicalize to all upper case and remove padding if it exists.
str = str.toUpperCase().replace(/=+$/, '');
var buf = new ArrayBuffer(str.length * 5 / 8 | 0);
var arr = new Uint8Array(buf);
var bits = 0;
var value = 0;
var index = 0;
for (var i = 0; i < str.length; i++) {
var idx = Utils.b32.alphabet.indexOf(str[i]);
if (idx === -1) throw new TypeError("Invalid character found: ".concat(str[i]));
value = value << 5 | idx;
bits += 5;
if (bits >= 8) {
arr[index++] = value >>> bits - 8 & 255;
bits -= 8;
}
}
return buf;
}
},
/**
* Hexadecimal string conversion.
* @type {Object}
*/
hex: {
/**
* Converts an ArrayBuffer to a hexadecimal string.
* @param {ArrayBuffer} buf ArrayBuffer.
* @returns {string} Hexadecimal string.
*/
fromBuf: function fromBuf(buf) {
var arr = new Uint8Array(buf);
var str = '';
for (var i = 0; i < arr.length; i++) {
var hex = arr[i].toString(16);
str += hex.length === 2 ? hex : "0".concat(hex);
}
return str.toUpperCase();
},
/**
* Converts a hexadecimal string to an ArrayBuffer.
* @param {string} str Hexadecimal string.
* @returns {ArrayBuffer} ArrayBuffer.
*/
toBuf: function toBuf(str) {
var buf = new ArrayBuffer(str.length / 2);
var arr = new Uint8Array(buf);
for (var i = 0, j = 0; i < arr.length; i += 1, j += 2) {
arr[i] = parseInt(str.substr(j, 2), 16);
}
return buf;
}
},
/**
* Pads a number with leading zeros.
* @param {number|string} num Number.
* @param {number} digits Digits.
* @returns {string} Padded number.
*/
pad: function pad(num, digits) {
var prefix = '';
var repeat = digits - String(num).length;
while (repeat-- > 0) {
prefix += '0';
}
return "".concat(prefix).concat(num);
}
};
/**
* An object containing some utilities (for internal use only).
* @private
* @type {Object}
*/
var InternalUtils = {
/**
* "globalThis" ponyfill
* (https://mathiasbynens.be/notes/globalthis).
* @type {Object}
*/
get globalThis() {
var _globalThis;
/* eslint-disable no-extend-native, no-restricted-globals, no-undef */
if ((typeof globalThis === "undefined" ? "undefined" : _typeof(globalThis)) === 'object') {
_globalThis = globalThis;
} else {
Object.defineProperty(Object.prototype, '__magicalGlobalThis__', {
get: function get() {
return this;
},
configurable: true
});
try {
_globalThis = __magicalGlobalThis__;
} finally {
delete Object.prototype.__magicalGlobalThis__;
}
}
if (typeof _globalThis === 'undefined') {
// Still unable to determine "globalThis", fall back to a naive method.
if (typeof self !== 'undefined') {
_globalThis = self;
} else if (typeof window !== 'undefined') {
_globalThis = window;
} else if (typeof global !== 'undefined') {
_globalThis = global;
}
}
/* eslint-enable */
Object.defineProperty(this, 'globalThis', {
enumerable: true,
value: _globalThis
});
return this.globalThis;
},
/**
* "console" ponyfill.
* @type {Object}
*/
get console() {
var _console = {};
var methods = ['assert', 'clear', 'context', 'count', 'countReset', 'debug', 'dir', 'dirxml', 'error', 'exception', 'group', 'groupCollapsed', 'groupEnd', 'info', 'log', 'profile', 'profileEnd', 'table', 'time', 'timeEnd', 'timeLog', 'timeStamp', 'trace', 'warn'];
if (_typeof(InternalUtils.globalThis.console) === 'object') {
var _iterator = _createForOfIteratorHelper(methods),
_step;
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
var method = _step.value;
_console[method] = typeof InternalUtils.globalThis.console[method] === 'function' ? InternalUtils.globalThis.console[method] : function () {};
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
} else {
var _iterator2 = _createForOfIteratorHelper(methods),
_step2;
try {
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
var _method = _step2.value;
_console[_method] = function () {};
}
} catch (err) {
_iterator2.e(err);
} finally {
_iterator2.f();
}
}
Object.defineProperty(this, 'console', {
enumerable: true,
value: _console
});
return this.console;
},
/**
* Detect if running in "Node.js".
* @type {boolean}
*/
get isNode() {
var _isNode = Object.prototype.toString.call(InternalUtils.globalThis.process) === '[object process]';
Object.defineProperty(this, 'isNode', {
enumerable: true,
value: _isNode
});
return this.isNode;
},
/**
* Dynamically import "Node.js" modules.
* (`eval` is used to prevent bundlers from including the module,
* e.g., [webpack/webpack#8826](https://github.com/webpack/webpack/issues/8826))
* @type {Function}
*/
get nodeRequire() {
var _nodeRequire = InternalUtils.isNode // eslint-disable-next-line no-eval
? eval('require') : function () {};
Object.defineProperty(this, 'nodeRequire', {
enumerable: true,
value: _nodeRequire
});
return this.nodeRequire;
}
};
/** @fileOverview Javascript cryptography implementation.
*
* Crush to remove comments, shorten variable names and
* generally reduce transmission size.
*
* @author Emily Stark
* @author Mike Hamburg
* @author Dan Boneh
*/
/*jslint indent: 2, bitwise: false, nomen: false, plusplus: false, white: false, regexp: false */
/*global document, window, escape, unescape, module, require, Uint32Array */
/**
* The Stanford Javascript Crypto Library, top-level namespace.
* @namespace
*/
var sjcl = {
/**
* Symmetric ciphers.
* @namespace
*/
cipher: {},
/**
* Hash functions. Right now only SHA256 is implemented.
* @namespace
*/
hash: {},
/**
* Key exchange functions. Right now only SRP is implemented.
* @namespace
*/
keyexchange: {},
/**
* Cipher modes of operation.
* @namespace
*/
mode: {},
/**
* Miscellaneous. HMAC and PBKDF2.
* @namespace
*/
misc: {},
/**
* Bit array encoders and decoders.
* @namespace
*
* @description
* The members of this namespace are functions which translate between
* SJCL's bitArrays and other objects (usually strings). Because it
* isn't always clear which direction is encoding and which is decoding,
* the method names are "fromBits" and "toBits".
*/
codec: {},
/**
* Exceptions.
* @namespace
*/
exception: {
/**
* Ciphertext is corrupt.
* @constructor
*/
corrupt: function (message) {
this.toString = function () {
return "CORRUPT: " + this.message;
};
this.message = message;
},
/**
* Invalid parameter.
* @constructor
*/
invalid: function (message) {
this.toString = function () {
return "INVALID: " + this.message;
};
this.message = message;
},
/**
* Bug or missing feature in SJCL.
* @constructor
*/
bug: function (message) {
this.toString = function () {
return "BUG: " + this.message;
};
this.message = message;
},
/**
* Something isn't ready.
* @constructor
*/
notReady: function (message) {
this.toString = function () {
return "NOT READY: " + this.message;
};
this.message = message;
}
}
};
/** @fileOverview Arrays of bits, encoded as arrays of Numbers.
*
* @author Emily Stark
* @author Mike Hamburg
* @author Dan Boneh
*/
/**
* Arrays of bits, encoded as arrays of Numbers.
* @namespace
* @description
* <p>
* These objects are the currency accepted by SJCL's crypto functions.
* </p>
*
* <p>
* Most of our crypto primitives operate on arrays of 4-byte words internally,
* but many of them can take arguments that are not a multiple of 4 bytes.
* This library encodes arrays of bits (whose size need not be a multiple of 8
* bits) as arrays of 32-bit words. The bits are packed, big-endian, into an
* array of words, 32 bits at a time. Since the words are double-precision
* floating point numbers, they fit some extra data. We use this (in a private,
* possibly-changing manner) to encode the number of bits actually present
* in the last word of the array.
* </p>
*
* <p>
* Because bitwise ops clear this out-of-band data, these arrays can be passed
* to ciphers like AES which want arrays of words.
* </p>
*/
sjcl.bitArray = {
/**
* Array slices in units of bits.
* @param {bitArray} a The array to slice.
* @param {Number} bstart The offset to the start of the slice, in bits.
* @param {Number} bend The offset to the end of the slice, in bits. If this is undefined,
* slice until the end of the array.
* @return {bitArray} The requested slice.
*/
bitSlice: function (a, bstart, bend) {
a = sjcl.bitArray._shiftRight(a.slice(bstart / 32), 32 - (bstart & 31)).slice(1);
return bend === undefined ? a : sjcl.bitArray.clamp(a, bend - bstart);
},
/**
* Extract a number packed into a bit array.
* @param {bitArray} a The array to slice.
* @param {Number} bstart The offset to the start of the slice, in bits.
* @param {Number} blength The length of the number to extract.
* @return {Number} The requested slice.
*/
extract: function (a, bstart, blength) {
// FIXME: this Math.floor is not necessary at all, but for some reason
// seems to suppress a bug in the Chromium JIT.
var x,
sh = Math.floor(-bstart - blength & 31);
if ((bstart + blength - 1 ^ bstart) & -32) {
// it crosses a boundary
x = a[bstart / 32 | 0] << 32 - sh ^ a[bstart / 32 + 1 | 0] >>> sh;
} else {
// within a single word
x = a[bstart / 32 | 0] >>> sh;
}
return x & (1 << blength) - 1;
},
/**
* Concatenate two bit arrays.
* @param {bitArray} a1 The first array.
* @param {bitArray} a2 The second array.
* @return {bitArray} The concatenation of a1 and a2.
*/
concat: function (a1, a2) {
if (a1.length === 0 || a2.length === 0) {
return a1.concat(a2);
}
var last = a1[a1.length - 1],
shift = sjcl.bitArray.getPartial(last);
if (shift === 32) {
return a1.concat(a2);
} else {
return sjcl.bitArray._shiftRight(a2, shift, last | 0, a1.slice(0, a1.length - 1));
}
},
/**
* Find the length of an array of bits.
* @param {bitArray} a The array.
* @return {Number} The length of a, in bits.
*/
bitLength: function (a) {
var l = a.length,
x;
if (l === 0) {
return 0;
}
x = a[l - 1];
return (l - 1) * 32 + sjcl.bitArray.getPartial(x);
},
/**
* Truncate an array.
* @param {bitArray} a The array.
* @param {Number} len The length to truncate to, in bits.
* @return {bitArray} A new array, truncated to len bits.
*/
clamp: function (a, len) {
if (a.length * 32 < len) {
return a;
}
a = a.slice(0, Math.ceil(len / 32));
var l = a.length;
len = len & 31;
if (l > 0 && len) {
a[l - 1] = sjcl.bitArray.partial(len, a[l - 1] & 0x80000000 >> len - 1, 1);
}
return a;
},
/**
* Make a partial word for a bit array.
* @param {Number} len The number of bits in the word.
* @param {Number} x The bits.
* @param {Number} [_end=0] Pass 1 if x has already been shifted to the high side.
* @return {Number} The partial word.
*/
partial: function (len, x, _end) {
if (len === 32) {
return x;
}
return (_end ? x | 0 : x << 32 - len) + len * 0x10000000000;
},
/**
* Get the number of bits used by a partial word.
* @param {Number} x The partial word.
* @return {Number} The number of bits used by the partial word.
*/
getPartial: function (x) {
return Math.round(x / 0x10000000000) || 32;
},
/**
* Compare two arrays for equality in a predictable amount of time.
* @param {bitArray} a The first array.
* @param {bitArray} b The second array.
* @return {boolean} true if a == b; false otherwise.
*/
equal: function (a, b) {
if (sjcl.bitArray.bitLength(a) !== sjcl.bitArray.bitLength(b)) {
return false;
}
var x = 0,
i;
for (i = 0; i < a.length; i++) {
x |= a[i] ^ b[i];
}
return x === 0;
},
/** Shift an array right.
* @param {bitArray} a The array to shift.
* @param {Number} shift The number of bits to shift.
* @param {Number} [carry=0] A byte to carry in
* @param {bitArray} [out=[]] An array to prepend to the output.
* @private
*/
_shiftRight: function (a, shift, carry, out) {
var i,
last2 = 0,
shift2;
if (out === undefined) {
out = [];
}
for (; shift >= 32; shift -= 32) {
out.push(carry);
carry = 0;
}
if (shift === 0) {
return out.concat(a);
}
for (i = 0; i < a.length; i++) {
out.push(carry | a[i] >>> shift);
carry = a[i] << 32 - shift;
}
last2 = a.length ? a[a.length - 1] : 0;
shift2 = sjcl.bitArray.getPartial(last2);
out.push(sjcl.bitArray.partial(shift + shift2 & 31, shift + shift2 > 32 ? carry : out.pop(), 1));
return out;
},
/** xor a block of 4 words together.
* @private
*/
_xor4: function (x, y) {
return [x[0] ^ y[0], x[1] ^ y[1], x[2] ^ y[2], x[3] ^ y[3]];
},
/** byteswap a word array inplace.
* (does not handle partial words)
* @param {sjcl.bitArray} a word array
* @return {sjcl.bitArray} byteswapped array
*/
byteswapM: function (a) {
var i,
v,
m = 0xff00;
for (i = 0; i < a.length; ++i) {
v = a[i];
a[i] = v >>> 24 | v >>> 8 & m | (v & m) << 8 | v << 24;
}
return a;
}
};
/** @fileOverview Bit array codec implementations.
*
* @author Marco Munizaga
*/
//patch arraybuffers if they don't exist
if (typeof ArrayBuffer === 'undefined') {
(function (globals) {
globals.ArrayBuffer = function () {};
globals.DataView = function () {};
})(undefined);
}
/**
* ArrayBuffer
* @namespace
*/
sjcl.codec.arrayBuffer = {
/** Convert from a bitArray to an ArrayBuffer.
* Will default to 8byte padding if padding is undefined*/
fromBits: function (arr, padding, padding_count) {
var out, i, ol, tmp, smallest;
padding = padding == undefined ? true : padding;
padding_count = padding_count || 8;
if (arr.length === 0) {
return new ArrayBuffer(0);
}
ol = sjcl.bitArray.bitLength(arr) / 8; //check to make sure the bitLength is divisible by 8, if it isn't
//we can't do anything since arraybuffers work with bytes, not bits
if (sjcl.bitArray.bitLength(arr) % 8 !== 0) {
throw new sjcl.exception.invalid("Invalid bit size, must be divisble by 8 to fit in an arraybuffer correctly");
}
if (padding && ol % padding_count !== 0) {
ol += padding_count - ol % padding_count;
} //padded temp for easy copying
tmp = new DataView(new ArrayBuffer(arr.length * 4));
for (i = 0; i < arr.length; i++) {
tmp.setUint32(i * 4, arr[i] << 32); //get rid of the higher bits
} //now copy the final message if we are not going to 0 pad
out = new DataView(new ArrayBuffer(ol)); //save a step when the tmp and out bytelength are ===
if (out.byteLength === tmp.byteLength) {
return tmp.buffer;
}
smallest = tmp.byteLength < out.byteLength ? tmp.byteLength : out.byteLength;
for (i = 0; i < smallest; i++) {
out.setUint8(i, tmp.getUint8(i));
}
return out.buffer;
},
/** Convert from an ArrayBuffer to a bitArray. */
toBits: function (buffer) {
var i,
out = [],
len,
inView,
tmp;
if (buffer.byteLength === 0) {
return [];
}
inView = new DataView(buffer);
len = inView.byteLength - inView.byteLength % 4;
for (var i = 0; i < len; i += 4) {
out.push(inView.getUint32(i));
}
if (inView.byteLength % 4 != 0) {
tmp = new DataView(new ArrayBuffer(4));
for (var i = 0, l = inView.byteLength % 4; i < l; i++) {
//we want the data to the right, because partial slices off the starting bits
tmp.setUint8(i + 4 - l, inView.getUint8(len + i)); // big-endian,
}
out.push(sjcl.bitArray.partial(inView.byteLength % 4 * 8, tmp.getUint32(0)));
}
return out;
},
/** Prints a hex output of the buffer contents, akin to hexdump **/
hexDumpBuffer: function (buffer) {
var stringBufferView = new DataView(buffer);
var string = '';
var pad = function (n, width) {
n = n + '';
return n.length >= width ? n : new Array(width - n.length + 1).join('0') + n;
};
for (var i = 0; i < stringBufferView.byteLength; i += 2) {
if (i % 16 == 0) string += '\n' + i.toString(16) + '\t';
string += pad(stringBufferView.getUint16(i).toString(16), 4) + ' ';
}
if (typeof console === undefined) {
console = console || {
log: function () {}
}; //fix for IE
}
console.log(string.toUpperCase());
}
};
/** @fileOverview Javascript SHA-1 implementation.
*
* Based on the implementation in RFC 3174, method 1, and on the SJCL
* SHA-256 implementation.
*
* @author Quinn Slack
*/
/**
* Context for a SHA-1 operation in progress.
* @constructor
*/
sjcl.hash.sha1 = function (hash) {
if (hash) {
this._h = hash._h.slice(0);
this._buffer = hash._buffer.slice(0);
this._length = hash._length;
} else {
this.reset();
}
};
/**
* Hash a string or an array of words.
* @static
* @param {bitArray|String} data the data to hash.
* @return {bitArray} The hash value, an array of 5 big-endian words.
*/
sjcl.hash.sha1.hash = function (data) {
return new sjcl.hash.sha1().update(data).finalize();
};
sjcl.hash.sha1.prototype = {
/**
* The hash's block size, in bits.
* @constant
*/
blockSize: 512,
/**
* Reset the hash state.
* @return this
*/
reset: function () {
this._h = this._init.slice(0);
this._buffer = [];
this._length = 0;
return this;
},
/**
* Input several words to the hash.
* @param {bitArray|String} data the data to hash.
* @return this
*/
update: function (data) {
if (typeof data === "string") {
data = sjcl.codec.utf8String.toBits(data);
}
var i,
b = this._buffer = sjcl.bitArray.concat(this._buffer, data),
ol = this._length,
nl = this._length = ol + sjcl.bitArray.bitLength(data);
if (nl > 9007199254740991) {
throw new sjcl.exception.invalid("Cannot hash more than 2^53 - 1 bits");
}
if (typeof Uint32Array !== 'undefined') {
var c = new Uint32Array(b);
var j = 0;
for (i = this.blockSize + ol - (this.blockSize + ol & this.blockSize - 1); i <= nl; i += this.blockSize) {
this._block(c.subarray(16 * j, 16 * (j + 1)));
j += 1;
}
b.splice(0, 16 * j);
} else {
for (i = this.blockSize + ol - (this.blockSize + ol & this.blockSize - 1); i <= nl; i += this.blockSize) {
this._block(b.splice(0, 16));
}
}
return this;
},
/**
* Complete hashing and output the hash value.
* @return {bitArray} The hash value, an array of 5 big-endian words. TODO
*/
finalize: function () {
var i,
b = this._buffer,
h = this._h; // Round out and push the buffer
b = sjcl.bitArray.concat(b, [sjcl.bitArray.partial(1, 1)]); // Round out the buffer to a multiple of 16 words, less the 2 length words.
for (i = b.length + 2; i & 15; i++) {
b.push(0);
} // append the length
b.push(Math.floor(this._length / 0x100000000));
b.push(this._length | 0);
while (b.length) {
this._block(b.splice(0, 16));
}
this.reset();
return h;
},
/**
* The SHA-1 initialization vector.
* @private
*/
_init: [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0],
/**
* The SHA-1 hash key.
* @private
*/
_key: [0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6],
/**
* The SHA-1 logical functions f(0), f(1), ..., f(79).
* @private
*/
_f: function (t, b, c, d) {
if (t <= 19) {
return b & c | ~b & d;
} else if (t <= 39) {
return b ^ c ^ d;
} else if (t <= 59) {
return b & c | b & d | c & d;
} else if (t <= 79) {
return b ^ c ^ d;
}
},
/**
* Circular left-shift operator.
* @private
*/
_S: function (n, x) {
return x << n | x >>> 32 - n;
},
/**
* Perform one cycle of SHA-1.
* @param {Uint32Array|bitArray} words one block of words.
* @private
*/
_block: function (words) {
var t,
tmp,
a,
b,
c,
d,
e,
h = this._h;
var w;
if (typeof Uint32Array !== 'undefined') {
// When words is passed to _block, it has 16 elements. SHA1 _block
// function extends words with new elements (at the end there are 80 elements).
// The problem is that if we use Uint32Array instead of Array,
// the length of Uint32Array cannot be changed. Thus, we replace words with a
// normal Array here.
w = Array(80); // do not use Uint32Array here as the instantiation is slower
for (var j = 0; j < 16; j++) {
w[j] = words[j];
}
} else {
w = words;
}
a = h[0];
b = h[1];
c = h[2];
d = h[3];
e = h[4];
for (t = 0; t <= 79; t++) {
if (t >= 16) {
w[t] = this._S(1, w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16]);
}
tmp = this._S(5, a) + this._f(t, b, c, d) + e + w[t] + this._key[Math.floor(t / 20)] | 0;
e = d;
d = c;
c = this._S(30, b);
b = a;
a = tmp;
}
h[0] = h[0] + a | 0;
h[1] = h[1] + b | 0;
h[2] = h[2] + c | 0;
h[3] = h[3] + d | 0;
h[4] = h[4] + e | 0;
}
};
/** @fileOverview Javascript SHA-256 implementation.
*
* An older version of this implementation is available in the public
* domain, but this one is (c) Emily Stark, Mike Hamburg, Dan Boneh,
* Stanford University 2008-2010 and BSD-licensed for liability
* reasons.
*
* Special thanks to Aldo Cortesi for pointing out several bugs in
* this code.
*
* @author Emily Stark
* @author Mike Hamburg
* @author Dan Boneh
*/
/**
* Context for a SHA-256 operation in progress.
* @constructor
*/
sjcl.hash.sha256 = function (hash) {
if (!this._key[0]) {
this._precompute();
}
if (hash) {
this._h = hash._h.slice(0);
this._buffer = hash._buffer.slice(0);
this._length = hash._length;
} else {
this.reset();
}
};
/**
* Hash a string or an array of words.
* @static
* @param {bitArray|String} data the data to hash.
* @return {bitArray} The hash value, an array of 16 big-endian words.
*/
sjcl.hash.sha256.hash = function (data) {
return new sjcl.hash.sha256().update(data).finalize();
};
sjcl.hash.sha256.prototype = {
/**
* The hash's block size, in bits.
* @constant
*/
blockSize: 512,
/**
* Reset the hash state.
* @return this
*/
reset: function () {
this._h = this._init.slice(0);
this._buffer = [];
this._length = 0;
return this;
},
/**
* Input several words to the hash.
* @param {bitArray|String} data the data to hash.
* @return this
*/
update: function (data) {
if (typeof data === "string") {
data = sjcl.codec.utf8String.toBits(data);
}
var i,
b = this._buffer = sjcl.bitArray.concat(this._buffer, data),
ol = this._length,
nl = this._length = ol + sjcl.bitArray.bitLength(data);
if (nl > 9007199254740991) {
throw new sjcl.exception.invalid("Cannot hash more than 2^53 - 1 bits");
}
if (typeof Uint32Array !== 'undefined') {
var c = new Uint32Array(b);
var j = 0;
for (i = 512 + ol - (512 + ol & 511); i <= nl; i += 512) {
this._block(c.subarray(16 * j, 16 * (j + 1)));
j += 1;
}
b.splice(0, 16 * j);
} else {
for (i = 512 + ol - (512 + ol & 511); i <= nl; i += 512) {
this._block(b.splice(0, 16));
}
}
return this;
},
/**
* Complete hashing and output the hash value.
* @return {bitArray} The hash value, an array of 8 big-endian words.
*/
finalize: function () {
var i,
b = this._buffer,
h = this._h; // Round out and push the buffer
b = sjcl.bitArray.concat(b, [sjcl.bitArray.partial(1, 1)]); // Round out the buffer to a multiple of 16 words, less the 2 length words.
for (i = b.length + 2; i & 15; i++) {
b.push(0);
} // append the length
b.push(Math.floor(this._length / 0x100000000));
b.push(this._length | 0);
while (b.length) {
this._block(b.splice(0, 16));
}
this.reset();
return h;
},
/**
* The SHA-256 initialization vector, to be precomputed.
* @private
*/
_init: [],
/*
_init:[0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19],
*/
/**
* The SHA-256 hash key, to be precomputed.
* @private
*/
_key: [],
/*
_key:
[0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2],
*/
/**
* Function to precompute _init and _key.
* @private
*/
_precompute: function () {
var i = 0,
prime = 2,
factor,
isPrime;
function frac(x) {
return (x - Math.floor(x)) * 0x100000000 | 0;
}
for (; i < 64; prime++) {
isPrime = true;
for (factor = 2; factor * factor <= prime; factor++) {
if (prime % factor === 0) {
isPrime = false;
break;
}
}
if (isPrime) {
if (i < 8) {
this._init[i] = frac(Math.pow(prime, 1 / 2));
}
this._key[i] = frac(Math.pow(prime, 1 / 3));
i++;
}
}
},
/**
* Perform one cycle of SHA-256.
* @param {Uint32Array|bitArray} w one block of words.
* @private
*/
_block: function (w) {
var i,
tmp,
a,
b,
h = this._h,
k = this._key,
h0 = h[0],
h1 = h[1],
h2 = h[2],
h3 = h[3],
h4 = h[4],
h5 = h[5],
h6 = h[6],
h7 = h[7];
/* Rationale for placement of |0 :
* If a value can overflow is original 32 bits by a factor of more than a few
* million (2^23 ish), there is a possibility that it might overflow the
* 53-bit mantissa and lose precision.
*
* To avoid this, we clamp back to 32 bits by |'ing with 0 on any value that
* propagates around the loop, and on the hash state h[]. I don't believe
* that the clamps on h4 and on h0 are strictly necessary, but it's close
* (for h4 anyway), and better safe than sorry.
*
* The clamps on h[] are necessary for the output to be correct even in the
* common case and for short inputs.
*/
for (i = 0; i < 64; i++) {
// load up the input word for this round
if (i < 16) {
tmp = w[i];
} else {
a = w[i + 1 & 15];
b = w[i + 14 & 15];
tmp = w[i & 15] = (a >>> 7 ^ a >>> 18 ^ a >>> 3 ^ a << 25 ^ a << 14) + (b >>> 17 ^ b >>> 19 ^ b >>> 10 ^ b << 15 ^ b << 13) + w[i & 15] + w[i + 9 & 15] | 0;
}
tmp = tmp + h7 + (h4 >>> 6 ^ h4 >>> 11 ^ h4 >>> 25 ^ h4 << 26 ^ h4 << 21 ^ h4 << 7) + (h6 ^ h4 & (h5 ^ h6)) + k[i]; // | 0;
// shift register
h7 = h6;
h6 = h5;
h5 = h4;
h4 = h3 + tmp | 0;
h3 = h2;
h2 = h1;
h1 = h0;
h0 = tmp + (h1 & h2 ^ h3 & (h1 ^ h2)) + (h1 >>> 2 ^ h1 >>> 13 ^ h1 >>> 22 ^ h1 << 30 ^ h1 << 19 ^ h1 << 10) | 0;
}
h[0] = h[0] + h0 | 0;
h[1] = h[1] + h1 | 0;
h[2] = h[2] + h2 | 0;
h[3] = h[3] + h3 | 0;
h[4] = h[4] + h4 | 0;
h[5] = h[5] + h5 | 0;
h[6] = h[6] + h6 | 0;
h[7] = h[7] + h7 | 0;
}
};
/** @fileOverview Javascript SHA-512 implementation.
*
* This implementation was written for CryptoJS by Jeff Mott and adapted for
* SJCL by Stefan Thomas.
*
* CryptoJS (c) 2009–2012 by Jeff Mott. All rights reserved.
* Released with New BSD License
*
* @author Emily Stark
* @author Mike Hamburg
* @author Dan Boneh
* @author Jeff Mott
* @author Stefan Thomas
*/
/**
* Context for a SHA-512 operation in progress.
* @constructor
*/
sjcl.hash.sha512 = function (hash) {
if (!this._key[0]) {
this._precompute();
}
if (hash) {
this._h = hash._h.slice(0);
this._buffer = hash._buffer.slice(0);
this._length = hash._length;
} else {
this.reset();
}
};
/**
* Hash a string or an array of words.
* @static
* @param {bitArray|String} data the data to hash.
* @return {bitArray} The hash value, an array of 16 big-endian words.
*/
sjcl.hash.sha512.hash = function (data) {
return new sjcl.hash.sha512().update(data).finalize();
};
sjcl.hash.sha512.prototype = {
/**
* The hash's block size, in bits.
* @constant
*/
blockSize: 1024,
/**
* Reset the hash state.
* @return this
*/
reset: function () {
this._h = this._init.slice(0);
this._buffer = [];
this._length = 0;
return this;
},
/**
* Input several words to the hash.
* @param {bitArray|String} data the data to hash.
* @return this
*/
update: function (data) {
if (typeof data === "string") {
data = sjcl.codec.utf8String.toBits(data);
}
var i,
b = this._buffer = sjcl.bitArray.concat(this._buffer, data),
ol = this._length,
nl = this._length = ol + sjcl.bitArray.bitLength(data);
if (nl > 9007199254740991) {
throw new sjcl.exception.invalid("Cannot hash more than 2^53 - 1 bits");
}
if (typeof Uint32Array !== 'undefined') {
var c = new Uint32Array(b);
var j = 0;
for (i = 1024 + ol - (1024 + ol & 1023); i <= nl; i += 1024) {
this._block(c.subarray(32 * j, 32 * (j + 1)));
j += 1;
}
b.splice(0, 32 * j);
} else {
for (i = 1024 + ol - (1024 + ol & 1023); i <= nl; i += 1024) {
this._block(b.splice(0, 32));
}
}
return this;
},
/**
* Complete hashing and output the hash value.
* @return {bitArray} The hash value, an array of 16 big-endian words.
*/
finalize: function () {
var i,
b = this._buffer,
h = this._h; // Round out and push the buffer
b = sjcl.bitArray.concat(b, [sjcl.bitArray.partial(1, 1)]); // Round out the buffer to a multiple of 32 words, less the 4 length words.
for (i = b.length + 4; i & 31; i++) {
b.push(0);
} // append the length
b.push(0);
b.push(0);
b.push(Math.floor(this._length / 0x100000000));
b.push(this._length | 0);
while (b.length) {
this._block(b.splice(0, 32));
}
this.reset();
return h;
},
/**
* The SHA-512 initialization vector, to be precomputed.
* @private
*/
_init: [],
/**
* Least significant 24 bits of SHA512 initialization values.
*
* Javascript only has 53 bits of precision, so we compute the 40 most
* significant bits and add the remaining 24 bits as constants.
*
* @private
*/
_initr: [0xbcc908, 0xcaa73b, 0x94f82b, 0x1d36f1, 0xe682d1, 0x3e6c1f, 0x41bd6b, 0x7e2179],
/*
_init:
[0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,
0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179],
*/
/**
* The SHA-512 hash key, to be precomputed.
* @private
*/
_key: [],
/**
* Least significant 24 bits of SHA512 key values.
* @private
*/
_keyr: [0x28ae22, 0xef65cd, 0x4d3b2f, 0x89dbbc, 0x48b538, 0x05d019, 0x194f9b, 0x6d8118, 0x030242, 0x706fbe, 0xe4b28c, 0xffb4e2, 0x7b896f, 0x1696b1, 0xc71235, 0x692694, 0xf14ad2, 0x4f25e3, 0x8cd5b5, 0xac9c65, 0x2b0275, 0xa6e483, 0x41fbd4, 0x1153b5, 0x66dfab, 0xb43210, 0xfb213f, 0xef0ee4, 0xa88fc2, 0x0aa725, 0x03826f, 0x0e6e70, 0xd22ffc, 0x26c926, 0xc42aed, 0x95b3df, 0xaf63de, 0x77b2a8, 0xedaee6, 0x82353b, 0xf10364, 0x423001, 0xf89791, 0x54be30, 0xef5218, 0x65a910, 0x71202a, 0xbbd1b8, 0xd2d0c8, 0x41ab53, 0x8eeb99, 0x9b48a8, 0xc95a63, 0x418acb, 0x63e373, 0xb2b8a3, 0xefb2fc, 0x172f60, 0xf0ab72, 0x6439ec, 0x631e28, 0x82bde9, 0xc67915, 0x72532b, 0x26619c, 0xc0c207, 0xe0eb1e, 0x6ed178, 0x176fba, 0xc898a6, 0xf90dae, 0x1c471b, 0x047d84, 0xc72493, 0xc9bebc, 0x100d4c, 0x3e42b6, 0x657e2a, 0xd6faec, 0x475817],
/*
_key:
[0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817],
*/
/**
* Function to precompute _init and _key.
* @private
*/
_precompute: function () {
// XXX: This code is for precomputing the SHA256 constants, change for
// SHA512 and re-enable.
var i = 0,
prime = 2,
factor,
isPrime;
function frac(x) {
return (x - Math.floor(x)) * 0x100000000 | 0;
}
function frac2(x) {
return (x - Math.floor(x)) * 0x10000000000 & 0xff;
}
for (; i < 80; prime++) {
isPrime = true;
for (factor = 2; factor * factor <= prime; factor++) {
if (prime % factor === 0) {
isPrime = false;
break;
}
}
if (isPrime) {
if (i < 8) {
this._init[i * 2] = frac(Math.pow(prime, 1 / 2));
this._init[i * 2 + 1] = frac2(Math.pow(prime, 1 / 2)) << 24 | this._initr[i];
}
this._key[i * 2] = frac(Math.pow(prime, 1 / 3));
this._key[i * 2 + 1] = frac2(Math.pow(prime, 1 / 3)) << 24 | this._keyr[i];
i++;
}
}
},
/**
* Perform one cycle of SHA-512.
* @param {Uint32Array|bitArray} words one block of words.
* @private
*/
_block: function (words) {
var i,
wrh,
wrl,
h = this._h,
k = this._key,
h0h = h[0],
h0l = h[1],
h1h = h[2],
h1l = h[3],
h2h = h[4],
h2l = h[5],
h3h = h[6],
h3l = h[7],
h4h = h[8],
h4l = h[9],
h5h = h[10],
h5l = h[11],
h6h = h[12],
h6l = h[13],
h7h = h[14],
h7l = h[15];
var w;
if (typeof Uint32Array !== 'undefined') {
// When words is passed to _block, it has 32 elements. SHA512 _block
// function extends words with new elements (at the end there are 160 elements).
// The problem is that if we use Uint32Array instead of Array,
// the length of Uint32Array cannot be changed. Thus, we replace words with a
// normal Array here.
w = Array(160); // do not use Uint32Array here as the instantiation is slower
for (var j = 0; j < 32; j++) {
w[j] = words[j];
}
} else {
w = words;
} // Working variables
var ah = h0h,
al = h0l,
bh = h1h,
bl = h1l,
ch = h2h,
cl = h2l,
dh = h3h,
dl = h3l,
eh = h4h,
el = h4l,
fh = h5h,
fl = h5l,
gh = h6h,
gl = h6l,
hh = h7h,
hl = h7l;
for (i = 0; i < 80; i++) {
// load up the input word for this round
if (i < 16) {
wrh = w[i * 2];
wrl = w[i * 2 + 1];
} else {
// Gamma0
var gamma0xh = w[(i - 15) * 2];
var gamma0xl = w[(i - 15) * 2 + 1];
var gamma0h = (gamma0xl << 31 | gamma0xh >>> 1) ^ (gamma0xl << 24 | gamma0xh >>> 8) ^ gamma0xh >>> 7;
var gamma0l = (gamma0xh << 31 | gamma0xl >>> 1) ^ (gamma0xh << 24 | gamma0xl >>> 8) ^ (gamma0xh << 25 | gamma0xl >>> 7); // Gamma1
var gamma1xh = w[(i - 2) * 2];
var gamma1xl = w[(i - 2) * 2 + 1];
var gamma1h = (gamma1xl << 13 | gamma1xh >>> 19) ^ (gamma1xh << 3 | gamma1xl >>> 29) ^ gamma1xh >>> 6;
var gamma1l = (gamma1xh << 13 | gamma1xl >>> 19) ^ (gamma1xl << 3 | gamma1xh >>> 29) ^ (gamma1xh << 26 | gamma1xl >>> 6); // Shortcuts
var wr7h = w[(i - 7) * 2];
var wr7l = w[(i - 7) * 2 + 1];
var wr16h = w[(i - 16) * 2];
var wr16l = w[(i - 16) * 2 + 1]; // W(round) = gamma0 + W(round - 7) + gamma1 + W(round - 16)
wrl = gamma0l + wr7l;
wrh = gamma0h + wr7h + (wrl >>> 0 < gamma0l >>> 0 ? 1 : 0);
wrl += gamma1l;
wrh += gamma1h + (wrl >>> 0 < gamma1l >>> 0 ? 1 : 0);
wrl += wr16l;
wrh += wr16h + (wrl >>> 0 < wr16l >>> 0 ? 1 : 0);
}
w[i * 2] = wrh |= 0;
w[i * 2 + 1] = wrl |= 0; // Ch
var chh = eh & fh ^ ~eh & gh;
var chl = el & fl ^ ~el & gl; // Maj
var majh = ah & bh ^ ah & ch ^ bh & ch;
var majl = al & bl ^ al & cl ^ bl & cl; // Sigma0
var sigma0h = (al << 4 | ah >>> 28) ^ (ah << 30 | al >>> 2) ^ (ah << 25 | al >>> 7);
var sigma0l = (ah << 4 | al >>> 28) ^ (al << 30 | ah >>> 2) ^ (al << 25 | ah >>> 7); // Sigma1
var sigma1h = (el << 18 | eh >>> 14) ^ (el << 14 | eh >>> 18) ^ (eh << 23 | el >>> 9);
var sigma1l = (eh << 18 | el >>> 14) ^ (eh << 14 | el >>> 18) ^ (el << 23 | eh >>> 9); // K(round)
var krh = k[i * 2];
var krl = k[i * 2 + 1]; // t1 = h + sigma1 + ch + K(round) + W(round)
var t1l = hl + sigma1l;
var t1h = hh + sigma1h + (t1l >>> 0 < hl >>> 0 ? 1 : 0);
t1l += chl;
t1h += chh + (t1l >>> 0 < chl >>> 0 ? 1 : 0);
t1l += krl;
t1h += krh + (t1l >>> 0 < krl >>> 0 ? 1 : 0);
t1l = t1l + wrl | 0; // FF32..FF34 perf issue https://bugzilla.mozilla.org/show_bug.cgi?id=1054972
t1h += wrh + (t1l >>> 0 < wrl >>> 0 ? 1 : 0); // t2 = sigma0 + maj
var t2l = sigma0l + majl;
var t2h = sigma0h + majh + (t2l >>> 0 < sigma0l >>> 0 ? 1 : 0); // Update working variables
hh = gh;
hl = gl;
gh = fh;
gl = fl;
fh = eh;
fl = el;
el = dl + t1l | 0;
eh = dh + t1h + (el >>> 0 < dl >>> 0 ? 1 : 0) | 0;
dh = ch;
dl = cl;
ch = bh;
cl = bl;
bh = ah;
bl = al;
al = t1l + t2l | 0;
ah = t1h + t2h + (al >>> 0 < t1l >>> 0 ? 1 : 0) | 0;
} // Intermediate hash
h0l = h[1] = h0l + al | 0;
h[0] = h0h + ah + (h0l >>> 0 < al >>> 0 ? 1 : 0) | 0;
h1l = h[3] = h1l + bl | 0;
h[2] = h1h + bh + (h1l >>> 0 < bl >>> 0 ? 1 : 0) | 0;
h2l = h[5] = h2l + cl | 0;
h[4] = h2h + ch + (h2l >>> 0 < cl >>> 0 ? 1 : 0) | 0;
h3l = h[7] = h3l + dl | 0;
h[6] = h3h + dh + (h3l >>> 0 < dl >>> 0 ? 1 : 0) | 0;
h4l = h[9] = h4l + el | 0;
h[8] = h4h + eh + (h4l >>> 0 < el >>> 0 ? 1 : 0) | 0;
h5l = h[11] = h5l + fl | 0;
h[10] = h5h + fh + (h5l >>> 0 < fl >>> 0 ? 1 : 0) | 0;
h6l = h[13] = h6l + gl | 0;
h[12] = h6h + gh + (h6l >>> 0 < gl >>> 0 ? 1 : 0) | 0;
h7l = h[15] = h7l + hl | 0;
h[14] = h7h + hh + (h7l >>> 0 < hl >>> 0 ? 1 : 0) | 0;
}
};
/** @fileOverview HMAC implementation.
*
* @author Emily Stark
* @author Mike Hamburg
* @author Dan Boneh
*/
/** HMAC with the specified hash function.
* @constructor
* @param {bitArray} key the key for HMAC.
* @param {Object} [Hash=sjcl.hash.sha256] The hash function to use.
*/
sjcl.misc.hmac = function (key, Hash) {
this._hash = Hash = Hash || sjcl.hash.sha256;
var exKey = [[], []],
i,
bs = Hash.prototype.blockSize / 32;
this._baseHash = [new Hash(), new Hash()];
if (key.length > bs) {
key = Hash.hash(key);
}
for (i = 0; i < bs; i++) {
exKey[0][i] = key[i] ^ 0x36363636;
exKey[1][i] = key[i] ^ 0x5C5C5C5C;
}
this._baseHash[0].update(exKey[0]);
this._baseHash[1].update(exKey[1]);
this._resultHash = new Hash(this._baseHash[0]);
};
/** HMAC with the specified hash function. Also called encrypt since it's a prf.
* @param {bitArray|String} data The data to mac.
*/
sjcl.misc.hmac.prototype.encrypt = sjcl.misc.hmac.prototype.mac = function (data) {
if (!this._updated) {
this.update(data);
return this.digest(data);
} else {
throw new sjcl.exception.invalid("encrypt on already updated hmac called!");
}
};
sjcl.misc.hmac.prototype.reset = function () {
this._resultHash = new this._hash(this._baseHash[0]);
this._updated = false;
};
sjcl.misc.hmac.prototype.update = function (data) {
this._updated = true;
this._resultHash.update(data);
};
sjcl.misc.hmac.prototype.digest = function () {
var w = this._resultHash.finalize(),
result = new this._hash(this._baseHash[1]).update(w).finalize();
this.reset();
return result;
};
// eslint-disable-next-line import/no-extraneous-dependencies
var randomBytes;
var hmacDigest;
if (InternalUtils.isNode) {
var NodeBuffer = InternalUtils.globalThis.Buffer;
var NodeCrypto = InternalUtils.nodeRequire('crypto');
var nodeBufferFromArrayBuffer;
if (typeof NodeBuffer.from === 'function') {
nodeBufferFromArrayBuffer = NodeBuffer.from;
} else {
// Node.js < 5.10.0
nodeBufferFromArrayBuffer = function nodeBufferFromArrayBuffer(arrayBuffer) {
var nodeBuffer = new NodeBuffer(arrayBuffer.byteLength);
var uint8Array = new Uint8Array(arrayBuffer);
for (var i = 0; i < uint8Array.length; i++) {
nodeBuffer[i] = uint8Array[i];
}
return nodeBuffer;
};
}
var nodeBufferToArrayBuffer;
if (NodeBuffer.prototype instanceof Uint8Array) {
nodeBufferToArrayBuffer = function nodeBufferToArrayBuffer(nodeBuffer) {
return nodeBuffer.buffer;
};
} else {
// Node.js < 4.0.0
nodeBufferToArrayBuffer = function nodeBufferToArrayBuffer(nodeBuffer) {
var uint8Array = new Uint8Array(nodeBuffer.length);
for (var i = 0; i < uint8Array.length; i++) {
uint8Array[i] = nodeBuffer[i];
}
return uint8Array.buffer;
};
}
randomBytes = function randomBytes(size) {
var bytes = NodeCrypto.randomBytes(size);
return nodeBufferToArrayBuffer(bytes);
};
hmacDigest = function hmacDigest(algorithm, key, message) {
var hmac = NodeCrypto.createHmac(algorithm, nodeBufferFromArrayBuffer(key));
hmac.update(nodeBufferFromArrayBuffer(message));
return nodeBufferToArrayBuffer(hmac.digest());
};
} else {
var BrowserCrypto = InternalUtils.globalThis.crypto || InternalUtils.globalThis.msCrypto;
var getRandomValues;
if (typeof BrowserCrypto !== 'undefined' && typeof BrowserCrypto.getRandomValues === 'function') {
getRandomValues = function getRandomValues(array) {
BrowserCrypto.getRandomValues(array);
};
} else {
InternalUtils.console.warn('Cryptography API not available, falling back to \'Math.random\'...');
getRandomValues = function getRandomValues(array) {
for (var i = 0; i < array.length; i++) {
array[i] = Math.floor(Math.random() * 256);
}
};
}
randomBytes = function randomBytes(size) {
var bytes = new Uint8Array(size);
getRandomValues(bytes);
return bytes.buffer;
};
hmacDigest = function hmacDigest(algorithm, key, message) {
var hash = sjcl.hash[algorithm.toLowerCase()];
if (typeof hash === 'undefined') {
throw new TypeError('Unknown hash function');
} // eslint-disable-next-line new-cap
var hmac = new sjcl.misc.hmac(sjcl.codec.arrayBuffer.toBits(key), hash);
hmac.update(sjcl.codec.arrayBuffer.toBits(message));
return sjcl.codec.arrayBuffer.fromBits(hmac.digest(), false);
};
}
/**
* An object containing some cryptography functions with dirty workarounds for Node.js and browsers.
* @private
* @type {Object}
*/
var Crypto = {
/**
* Returns random bytes.
* @param {number} size Size.
* @returns {ArrayBuffer} Random bytes.
*/
randomBytes: randomBytes,
/**
* Calculates an HMAC digest.
* In Node.js, the command `openssl list -digest-algorithms` displays the available digest algorithms.
* @param {string} algorithm Algorithm.
* @param {ArrayBuffer} key Key.
* @param {ArrayBuffer} message Message.
* @returns {ArrayBuffer} Digest.
*/
hmacDigest: hmacDigest
};
/**
* Secret key object.
* @param {Object} [config] Configuration options.
* @param {ArrayBuffer} [config.buffer=Crypto.randomBytes] Secret key.
* @param {number} [config.size=20] Number of random bytes to generate, ignored if 'buffer' is provided.
*/
var Secret = /*#__PURE__*/function () {
function Secret() {
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
buffer = _ref.buffer,
_ref$size = _ref.size,
size = _ref$size === void 0 ? 20 : _ref$size;
_classCallCheck(this, Secret);
/**
* Secret key.
* @type {ArrayBuffer}
*/
this.buffer = typeof buffer === 'undefined' ? Crypto.randomBytes(size) : buffer;
}
/**
* Converts a raw string to a Secret object.
* @param {string} str Raw string.
* @returns {Secret} Secret object.
*/
_createClass(Secret, [{
key: "raw",
/**
* String representation of secret key.
* @type {string}
*/
get: function get() {
Object.defineProperty(this, 'raw', {
enumerable: true,
configurable: true,
writable: true,
value: Utils.raw.fromBuf(this.buffer)
});
return this.raw;
}
/**
* Base32 representation of secret key.
* @type {string}
*/
}, {
key: "b32",
get: function get() {
Object.defineProperty(this, 'b32', {
enumerable: true,
configurable: true,
writable: true,
value: Utils.b32.fromBuf(this.buffer)
});
return this.b32;
}
/**
* Hexadecimal representation of secret key.
* @type {string}
*/
}, {
key: "hex",
get: function get() {
Object.defineProperty(this, 'hex', {
enumerable: true,
configurable: true,
writable: true,
value: Utils.hex.fromBuf(this.buffer)
});
return this.hex;
}
}], [{
key: "fromRaw",
value: function fromRaw(str) {
return new Secret({
buffer: Utils.raw.toBuf(str)
});
}
/**
* Converts a base32 string to a Secret object.
* @param {string} str Base32 string.
* @returns {Secret} Secret object.
*/
}, {
key: "fromB32",
value: function fromB32(str) {
return new Secret({
buffer: Utils.b32.toBuf(str)
});
}
/**
* Converts a hexadecimal string to a Secret object.
* @param {string} str Hexadecimal string.
* @returns {Secret} Secret object.
*/
}, {
key: "fromHex",
value: function fromHex(str) {
return new Secret({
buffer: Utils.hex.toBuf(str)
});
}
}]);
return Secret;
}();
/**
* Default configuration.
* @private
* @type {Object}
*/
var defaults = {
issuer: '',
label: 'OTPAuth',
algorithm: 'SHA1',
digits: 6,
counter: 0,
period: 30,
window: 1
};
/**
* HOTP: An HMAC-based One-time Password Algorithm (RFC 4226)
* (https://tools.ietf.org/html/rfc4226).
* @param {Object} [config] Configuration options.
* @param {string} [config.issuer=''] Account provider.
* @param {string} [config.label='OTPAuth'] Account label.
* @param {Secret|string} [config.secret=Secret] Secret key.
* @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.
* @param {number} [config.digits=6] Token length.
* @param {number} [config.counter=0] Initial counter value.
*/
var HOTP = /*#__PURE__*/function () {
function HOTP() {
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref$issuer = _ref.issuer,
issuer = _ref$issuer === void 0 ? defaults.issuer : _ref$issuer,
_ref$label = _ref.label,
label = _ref$label === void 0 ? defaults.label : _ref$label,
_ref$secret = _ref.secret,
secret = _ref$secret === void 0 ? new Secret() : _ref$secret,
_ref$algorithm = _ref.algorithm,
algorithm = _ref$algorithm === void 0 ? defaults.algorithm : _ref$algorithm,
_ref$digits = _ref.digits,
digits = _ref$digits === void 0 ? defaults.digits : _ref$digits,
_ref$counter = _ref.counter,
counter = _ref$counter === void 0 ? defaults.counter : _ref$counter;
_classCallCheck(this, HOTP);
/**
* Account provider.
* @type {string}
*/
this.issuer = issuer;
/**
* Account label.
* @type {string}
*/
this.label = label;
/**
* Secret key.
* @type {Secret}
*/
this.secret = typeof secret === 'string' ? Secret.fromB32(secret) : secret;
/**
* HMAC hashing algorithm.
* @type {string}
*/
this.algorithm = algorithm;
/**
* Token length.
* @type {number}
*/
this.digits = digits;
/**
* Initial counter value.
* @type {number}
*/
this.counter = counter;
}
/**
* Generates an HOTP token.
* @param {Object} config Configuration options.
* @param {Secret} config.secret Secret key.
* @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.
* @param {number} [config.digits=6] Token length.
* @param {number} [config.counter=0] Counter value.
* @returns {string} Token.
*/
_createClass(HOTP, [{
key: "generate",
/**
* Generates an HOTP token.
* @param {Object} [config] Configuration options.
* @param {number} [config.counter=this.counter++] Counter value.
* @returns {string} Token.
*/
value: function generate() {
var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref2$counter = _ref2.counter,
counter = _ref2$counter === void 0 ? this.counter++ : _ref2$counter;
return HOTP.generate({
secret: this.secret,
algorithm: this.algorithm,
digits: this.digits,
counter: counter
});
}
/**
* Validates an HOTP token.
* @param {Object} config Configuration options.
* @param {string} config.token Token value.
* @param {Secret} config.secret Secret key.
* @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.
* @param {number} [config.counter=0] Counter value.
* @param {number} [config.window=1] Window of counter values to test.
* @returns {number|null} Token delta, or null if the token is not found.
*/
}, {
key: "validate",
/**
* Validates an HOTP token.
* @param {Object} config Configuration options.
* @param {string} config.token Token value.
* @param {number} [config.counter=this.counter] Counter value.
* @param {number} [config.window=1] Window of counter values to test.
* @returns {number|null} Token delta, or null if the token is not found.
*/
value: function validate(_ref3) {
var token = _ref3.token,
_ref3$counter = _ref3.counter,
counter = _ref3$counter === void 0 ? this.counter : _ref3$counter,
window = _ref3.window;
return HOTP.validate({
token: Utils.pad(token, this.digits),
secret: this.secret,
algorithm: this.algorithm,
counter: counter,
window: window
});
}
/**
* Returns a Google Authenticator key URI.
* @returns {string} URI.
*/
}, {
key: "toString",
value: function toString() {
var e = encodeURIComponent;
return 'otpauth://hotp/' + "".concat(this.issuer.length > 0 ? "".concat(e(this.issuer), ":").concat(e(this.label), "?issuer=").concat(e(this.issuer), "&") : "".concat(e(this.label), "?")) + "secret=".concat(e(this.secret.b32), "&") + "algorithm=".concat(e(this.algorithm), "&") + "digits=".concat(e(this.digits), "&") + "counter=".concat(e(this.counter));
}
}], [{
key: "generate",
value: function generate(_ref4) {
var secret = _ref4.secret,
_ref4$algorithm = _ref4.algorithm,
algorithm = _ref4$algorithm === void 0 ? defaults.algorithm : _ref4$algorithm,
_ref4$digits = _ref4.digits,
digits = _ref4$digits === void 0 ? defaults.digits : _ref4$digits,
_ref4$counter = _ref4.counter,
counter = _ref4$counter === void 0 ? defaults.counter : _ref4$counter;
var digest = new Uint8Array(Crypto.hmacDigest(algorithm, secret.buffer, Utils.uint.toBuf(counter)));
var offset = digest[digest.byteLength - 1] & 15;
var otp = ((digest[offset] & 127) << 24 | (digest[offset + 1] & 255) << 16 | (digest[offset + 2] & 255) << 8 | digest[offset + 3] & 255) % Math.pow(10, digits);
return Utils.pad(otp, digits);
}
}, {
key: "validate",
value: function validate(_ref5) {
var token = _ref5.token,
secret = _ref5.secret,
algorithm = _ref5.algorithm,
_ref5$counter = _ref5.counter,
counter = _ref5$counter === void 0 ? defaults.counter : _ref5$counter,
_ref5$window = _ref5.window,
window = _ref5$window === void 0 ? defaults.window : _ref5$window;
for (var i = counter - window; i <= counter + window; ++i) {
var generatedToken = HOTP.generate({
secret: secret,
algorithm: algorithm,
digits: token.length,
counter: i
});
if (token === generatedToken) {
return i - counter;
}
}
return null;
}
}]);
return HOTP;
}();
/**
* TOTP: Time-Based One-Time Password Algorithm (RFC 6238)
* (https://tools.ietf.org/html/rfc6238).
* @param {Object} [config] Configuration options.
* @param {string} [config.issuer=''] Account provider.
* @param {string} [config.label='OTPAuth'] Account label.
* @param {Secret|string} [config.secret=Secret] Secret key.
* @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.
* @param {number} [config.digits=6] Token length.
* @param {number} [config.period=30] Token time-step duration.
*/
var TOTP = /*#__PURE__*/function () {
function TOTP() {
var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref6$issuer = _ref6.issuer,
issuer = _ref6$issuer === void 0 ? defaults.issuer : _ref6$issuer,
_ref6$label = _ref6.label,
label = _ref6$label === void 0 ? defaults.label : _ref6$label,
_ref6$secret = _ref6.secret,
secret = _ref6$secret === void 0 ? new Secret() : _ref6$secret,
_ref6$algorithm = _ref6.algorithm,
algorithm = _ref6$algorithm === void 0 ? defaults.algorithm : _ref6$algorithm,
_ref6$digits = _ref6.digits,
digits = _ref6$digits === void 0 ? defaults.digits : _ref6$digits,
_ref6$period = _ref6.period,
period = _ref6$period === void 0 ? defaults.period : _ref6$period;
_classCallCheck(this, TOTP);
/**
* Account provider.
* @type {string}
*/
this.issuer = issuer;
/**
* Account label.
* @type {string}
*/
this.label = label;
/**
* Secret key.
* @type {Secret}
*/
this.secret = typeof secret === 'string' ? Secret.fromB32(secret) : secret;
/**
* HMAC hashing algorithm.
* @type {string}
*/
this.algorithm = algorithm;
/**
* Token length.
* @type {number}
*/
this.digits = digits;
/**
* Token time-step duration.
* @type {number}
*/
this.period = period;
}
/**
* Generates a TOTP token.
* @param {Object} config Configuration options.
* @param {Secret} config.secret Secret key.
* @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.
* @param {number} [config.digits=6] Token length.
* @param {number} [config.period=30] Token time-step duration.
* @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.
* @returns {string} Token.
*/
_createClass(TOTP, [{
key: "generate",
/**
* Generates a TOTP token.
* @param {Object} [config] Configuration options.
* @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.
* @returns {string} Token.
*/
value: function generate() {
var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref7$timestamp = _ref7.timestamp,
timestamp = _ref7$timestamp === void 0 ? Date.now() : _ref7$timestamp;
return TOTP.generate({
secret: this.secret,
algorithm: this.algorithm,
digits: this.digits,
period: this.period,
timestamp: timestamp
});
}
/**
* Validates a TOTP token.
* @param {Object} config Configuration options.
* @param {string} config.token Token value.
* @param {Secret} config.secret Secret key.
* @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.
* @param {number} [config.period=30] Token time-step duration.
* @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.
* @param {number} [config.window=1] Window of counter values to test.
* @returns {number|null} Token delta, or null if the token is not found.
*/
}, {
key: "validate",
/**
* Validates a TOTP token.
* @param {Object} config Configuration options.
* @param {string} config.token Token value.
* @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.
* @param {number} [config.window=1] Window of counter values to test.
* @returns {number|null} Token delta, or null if the token is not found.
*/
value: function validate(_ref8) {
var token = _ref8.token,
timestamp = _ref8.timestamp,
window = _ref8.window;
return TOTP.validate({
token: Utils.pad(token, this.digits),
secret: this.secret,
algorithm: this.algorithm,
period: this.period,
timestamp: timestamp,
window: window
});
}
/**
* Returns a Google Authenticator key URI.
* @returns {string} URI.
*/
}, {
key: "toString",
value: function toString() {
var e = encodeURIComponent;
return 'otpauth://totp/' + "".concat(this.issuer.length > 0 ? "".concat(e(this.issuer), ":").concat(e(this.label), "?issuer=").concat(e(this.issuer), "&") : "".concat(e(this.label), "?")) + "secret=".concat(e(this.secret.b32), "&") + "algorithm=".concat(e(this.algorithm), "&") + "digits=".concat(e(this.digits), "&") + "period=".concat(e(this.period));
}
}], [{
key: "generate",
value: function generate(_ref9) {
var secret = _ref9.secret,
algorithm = _ref9.algorithm,
digits = _ref9.digits,
_ref9$period = _ref9.period,
period = _ref9$period === void 0 ? defaults.period : _ref9$period,
_ref9$timestamp = _ref9.timestamp,
timestamp = _ref9$timestamp === void 0 ? Date.now() : _ref9$timestamp;
return HOTP.generate({
secret: secret,
algorithm: algorithm,
digits: digits,
counter: Math.floor(timestamp / 1000 / period)
});
}
}, {
key: "validate",
value: function validate(_ref10) {
var token = _ref10.token,
secret = _ref10.secret,
algorithm = _ref10.algorithm,
_ref10$period = _ref10.period,
period = _ref10$period === void 0 ? defaults.period : _ref10$period,
_ref10$timestamp = _ref10.timestamp,
timestamp = _ref10$timestamp === void 0 ? Date.now() : _ref10$timestamp,
window = _ref10.window;
return HOTP.validate({
token: token,
secret: secret,
algorithm: algorithm,
counter: Math.floor(timestamp / 1000 / period),
window: window
});
}
}]);
return TOTP;
}();
/**
* Valid key URI parameters.
* @private
* @type {Array}
*/
var OTPURI_PARAMS = ['issuer', 'secret', 'algorithm', 'digits', 'counter', 'period'];
/**
* Key URI regex.
* otpauth://TYPE/[ISSUER:]LABEL?PARAMETERS
* @private
* @type {RegExp}
*/
var OTPURI_REGEX = new RegExp("^otpauth:\\/\\/([ht]otp)\\/(.+)\\?((?:&?(?:".concat(OTPURI_PARAMS.join('|'), ")=[^&]+)+)$"), 'i');
/**
* RFC 4648 base32 alphabet with pad.
* @private
* @type {string}
*/
var SECRET_REGEX = /^[2-7A-Z]+=*$/i;
/**
* Regex for supported algorithms.
* @private
* @type {RegExp}
*/
var ALGORITHM_REGEX = /^SHA(?:1|256|512)$/i;
/**
* Integer regex.
* @private
* @type {RegExp}
*/
var INTEGER_REGEX = /^[+-]?\d+$/;
/**
* Positive integer regex.
* @private
* @type {RegExp}
*/
var POSITIVE_INTEGER_REGEX = /^\+?[1-9]\d*$/;
/**
* HOTP/TOTP object/string conversion
* (https://github.com/google/google-authenticator/wiki/Key-Uri-Format).
*/
var URI = /*#__PURE__*/function () {
function URI() {
_classCallCheck(this, URI);
}
_createClass(URI, null, [{
key: "parse",
/**
* Parses a Google Authenticator key URI and returns an HOTP/TOTP object.
* @param {string} uri Google Authenticator Key URI.
* @returns {HOTP|TOTP} HOTP/TOTP object.
*/
value: function parse(uri) {
var uriGroups;
try {
uriGroups = uri.match(OTPURI_REGEX);
} catch (error) {
/* Handled below */
}
if (!Array.isArray(uriGroups)) {
throw new URIError('Invalid URI format');
} // Extract URI groups.
var uriType = uriGroups[1].toLowerCase();
var uriLabel = uriGroups[2].split(/:(.+)/, 2).map(decodeURIComponent);
var uriParams = uriGroups[3].split('&').reduce(function (acc, cur) {
var pairArr = cur.split(/=(.+)/, 2).map(decodeURIComponent);
var pairKey = pairArr[0].toLowerCase();
var pairVal = pairArr[1];
var pairAcc = acc;
pairAcc[pairKey] = pairVal;
return pairAcc;
}, {}); // 'OTP' will be instantiated with 'config' argument.
var OTP;
var config = {};
if (uriType === 'hotp') {
OTP = HOTP; // Counter: required
if (typeof uriParams.counter !== 'undefined' && INTEGER_REGEX.test(uriParams.counter)) {
config.counter = parseInt(uriParams.counter, 10);
} else {
throw new TypeError('Missing or invalid \'counter\' parameter');
}
} else if (uriType === 'totp') {
OTP = TOTP; // Period: optional
if (typeof uriParams.period !== 'undefined') {
if (POSITIVE_INTEGER_REGEX.test(uriParams.period)) {
config.period = parseInt(uriParams.period, 10);
} else {
throw new TypeError('Invalid \'period\' parameter');
}
}
} else {
throw new TypeError('Unknown OTP type');
} // Label: required
// Issuer: optional
if (uriLabel.length === 2) {
config.label = uriLabel[1];
if (typeof uriParams.issuer === 'undefined') {
config.issuer = uriLabel[0];
} else if (uriParams.issuer === uriLabel[0]) {
config.issuer = uriParams.issuer;
} else {
throw new TypeError('Invalid \'issuer\' parameter');
}
} else {
config.label = uriLabel[0];
if (typeof uriParams.issuer !== 'undefined') {
config.issuer = uriParams.issuer;
}
} // Secret: required
if (typeof uriParams.secret !== 'undefined' && SECRET_REGEX.test(uriParams.secret)) {
config.secret = new Secret({
buffer: Utils.b32.toBuf(uriParams.secret)
});
} else {
throw new TypeError('Missing or invalid \'secret\' parameter');
} // Algorithm: optional
if (typeof uriParams.algorithm !== 'undefined') {
if (ALGORITHM_REGEX.test(uriParams.algorithm)) {
config.algorithm = uriParams.algorithm;
} else {
throw new TypeError('Invalid \'algorithm\' parameter');
}
} // Digits: optional
if (typeof uriParams.digits !== 'undefined') {
if (POSITIVE_INTEGER_REGEX.test(uriParams.digits)) {
config.digits = parseInt(uriParams.digits, 10);
} else {
throw new TypeError('Invalid \'digits\' parameter');
}
}
return new OTP(config);
}
/**
* Converts an HOTP/TOTP object to a Google Authenticator key URI.
* @param {HOTP|TOTP} otp HOTP/TOTP object.
* @param {Object} [config] Configuration options.
* @returns {string} Google Authenticator Key URI.
*/
}, {
key: "stringify",
value: function stringify(otp) {
if (otp instanceof HOTP || otp instanceof TOTP) {
return otp.toString();
}
throw new TypeError('Invalid \'HOTP/TOTP\' object');
}
}]);
return URI;
}();
/**
* Library version.
* @type {string}
*/
var version = '6.0.0';
exports.HOTP = HOTP;
exports.Secret = Secret;
exports.TOTP = TOTP;
exports.URI = URI;
exports.Utils = Utils;
exports.version = version;
Object.defineProperty(exports, '__esModule', { value: true });
})));