You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
796 lines
26 KiB
796 lines
26 KiB
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.aesDecrypter = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
/**
|
|
* @file aes.js
|
|
*
|
|
* This file contains an adaptation of the AES decryption algorithm
|
|
* from the Standford Javascript Cryptography Library. That work is
|
|
* covered by the following copyright and permissions notice:
|
|
*
|
|
* Copyright 2009-2010 Emily Stark, Mike Hamburg, Dan Boneh.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* The views and conclusions contained in the software and documentation
|
|
* are those of the authors and should not be interpreted as representing
|
|
* official policies, either expressed or implied, of the authors.
|
|
*/
|
|
|
|
/**
|
|
* Expand the S-box tables.
|
|
*
|
|
* @private
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = (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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
var precompute = function precompute() {
|
|
var tables = [[[], [], [], [], []], [[], [], [], [], []]];
|
|
var encTable = tables[0];
|
|
var decTable = tables[1];
|
|
var sbox = encTable[4];
|
|
var sboxInv = decTable[4];
|
|
var i = undefined;
|
|
var x = undefined;
|
|
var xInv = undefined;
|
|
var d = [];
|
|
var th = [];
|
|
var x2 = undefined;
|
|
var x4 = undefined;
|
|
var x8 = undefined;
|
|
var s = undefined;
|
|
var tEnc = undefined;
|
|
var tDec = undefined;
|
|
|
|
// Compute double and third tables
|
|
for (i = 0; i < 256; i++) {
|
|
th[(d[i] = i << 1 ^ (i >> 7) * 283) ^ i] = i;
|
|
}
|
|
|
|
for (x = xInv = 0; !sbox[x]; x ^= x2 || 1, xInv = th[xInv] || 1) {
|
|
// Compute sbox
|
|
s = xInv ^ xInv << 1 ^ xInv << 2 ^ xInv << 3 ^ xInv << 4;
|
|
s = s >> 8 ^ s & 255 ^ 99;
|
|
sbox[x] = s;
|
|
sboxInv[s] = x;
|
|
|
|
// Compute MixColumns
|
|
x8 = d[x4 = d[x2 = d[x]]];
|
|
tDec = x8 * 0x1010101 ^ x4 * 0x10001 ^ x2 * 0x101 ^ x * 0x1010100;
|
|
tEnc = d[s] * 0x101 ^ s * 0x1010100;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
encTable[i][x] = tEnc = tEnc << 24 ^ tEnc >>> 8;
|
|
decTable[i][s] = tDec = tDec << 24 ^ tDec >>> 8;
|
|
}
|
|
}
|
|
|
|
// Compactify. Considerable speedup on Firefox.
|
|
for (i = 0; i < 5; i++) {
|
|
encTable[i] = encTable[i].slice(0);
|
|
decTable[i] = decTable[i].slice(0);
|
|
}
|
|
return tables;
|
|
};
|
|
var aesTables = null;
|
|
|
|
/**
|
|
* Schedule out an AES key for both encryption and decryption. This
|
|
* is a low-level class. Use a cipher mode to do bulk encryption.
|
|
*
|
|
* @class AES
|
|
* @param key {Array} The key as an array of 4, 6 or 8 words.
|
|
*/
|
|
|
|
var AES = (function () {
|
|
function AES(key) {
|
|
_classCallCheck(this, AES);
|
|
|
|
/**
|
|
* The expanded S-box and inverse S-box tables. These will be computed
|
|
* on the client so that we don't have to send them down the wire.
|
|
*
|
|
* There are two tables, _tables[0] is for encryption and
|
|
* _tables[1] is for decryption.
|
|
*
|
|
* The first 4 sub-tables are the expanded S-box with MixColumns. The
|
|
* last (_tables[01][4]) is the S-box itself.
|
|
*
|
|
* @private
|
|
*/
|
|
// if we have yet to precompute the S-box tables
|
|
// do so now
|
|
if (!aesTables) {
|
|
aesTables = precompute();
|
|
}
|
|
// then make a copy of that object for use
|
|
this._tables = [[aesTables[0][0].slice(), aesTables[0][1].slice(), aesTables[0][2].slice(), aesTables[0][3].slice(), aesTables[0][4].slice()], [aesTables[1][0].slice(), aesTables[1][1].slice(), aesTables[1][2].slice(), aesTables[1][3].slice(), aesTables[1][4].slice()]];
|
|
var i = undefined;
|
|
var j = undefined;
|
|
var tmp = undefined;
|
|
var encKey = undefined;
|
|
var decKey = undefined;
|
|
var sbox = this._tables[0][4];
|
|
var decTable = this._tables[1];
|
|
var keyLen = key.length;
|
|
var rcon = 1;
|
|
|
|
if (keyLen !== 4 && keyLen !== 6 && keyLen !== 8) {
|
|
throw new Error('Invalid aes key size');
|
|
}
|
|
|
|
encKey = key.slice(0);
|
|
decKey = [];
|
|
this._key = [encKey, decKey];
|
|
|
|
// schedule encryption keys
|
|
for (i = keyLen; i < 4 * keyLen + 28; i++) {
|
|
tmp = encKey[i - 1];
|
|
|
|
// apply sbox
|
|
if (i % keyLen === 0 || keyLen === 8 && i % keyLen === 4) {
|
|
tmp = sbox[tmp >>> 24] << 24 ^ sbox[tmp >> 16 & 255] << 16 ^ sbox[tmp >> 8 & 255] << 8 ^ sbox[tmp & 255];
|
|
|
|
// shift rows and add rcon
|
|
if (i % keyLen === 0) {
|
|
tmp = tmp << 8 ^ tmp >>> 24 ^ rcon << 24;
|
|
rcon = rcon << 1 ^ (rcon >> 7) * 283;
|
|
}
|
|
}
|
|
|
|
encKey[i] = encKey[i - keyLen] ^ tmp;
|
|
}
|
|
|
|
// schedule decryption keys
|
|
for (j = 0; i; j++, i--) {
|
|
tmp = encKey[j & 3 ? i : i - 4];
|
|
if (i <= 4 || j < 4) {
|
|
decKey[j] = tmp;
|
|
} else {
|
|
decKey[j] = decTable[0][sbox[tmp >>> 24]] ^ decTable[1][sbox[tmp >> 16 & 255]] ^ decTable[2][sbox[tmp >> 8 & 255]] ^ decTable[3][sbox[tmp & 255]];
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Decrypt 16 bytes, specified as four 32-bit words.
|
|
*
|
|
* @param {Number} encrypted0 the first word to decrypt
|
|
* @param {Number} encrypted1 the second word to decrypt
|
|
* @param {Number} encrypted2 the third word to decrypt
|
|
* @param {Number} encrypted3 the fourth word to decrypt
|
|
* @param {Int32Array} out the array to write the decrypted words
|
|
* into
|
|
* @param {Number} offset the offset into the output array to start
|
|
* writing results
|
|
* @return {Array} The plaintext.
|
|
*/
|
|
|
|
_createClass(AES, [{
|
|
key: 'decrypt',
|
|
value: function decrypt(encrypted0, encrypted1, encrypted2, encrypted3, out, offset) {
|
|
var key = this._key[1];
|
|
// state variables a,b,c,d are loaded with pre-whitened data
|
|
var a = encrypted0 ^ key[0];
|
|
var b = encrypted3 ^ key[1];
|
|
var c = encrypted2 ^ key[2];
|
|
var d = encrypted1 ^ key[3];
|
|
var a2 = undefined;
|
|
var b2 = undefined;
|
|
var c2 = undefined;
|
|
|
|
// key.length === 2 ?
|
|
var nInnerRounds = key.length / 4 - 2;
|
|
var i = undefined;
|
|
var kIndex = 4;
|
|
var table = this._tables[1];
|
|
|
|
// load up the tables
|
|
var table0 = table[0];
|
|
var table1 = table[1];
|
|
var table2 = table[2];
|
|
var table3 = table[3];
|
|
var sbox = table[4];
|
|
|
|
// Inner rounds. Cribbed from OpenSSL.
|
|
for (i = 0; i < nInnerRounds; i++) {
|
|
a2 = table0[a >>> 24] ^ table1[b >> 16 & 255] ^ table2[c >> 8 & 255] ^ table3[d & 255] ^ key[kIndex];
|
|
b2 = table0[b >>> 24] ^ table1[c >> 16 & 255] ^ table2[d >> 8 & 255] ^ table3[a & 255] ^ key[kIndex + 1];
|
|
c2 = table0[c >>> 24] ^ table1[d >> 16 & 255] ^ table2[a >> 8 & 255] ^ table3[b & 255] ^ key[kIndex + 2];
|
|
d = table0[d >>> 24] ^ table1[a >> 16 & 255] ^ table2[b >> 8 & 255] ^ table3[c & 255] ^ key[kIndex + 3];
|
|
kIndex += 4;
|
|
a = a2;b = b2;c = c2;
|
|
}
|
|
|
|
// Last round.
|
|
for (i = 0; i < 4; i++) {
|
|
out[(3 & -i) + offset] = sbox[a >>> 24] << 24 ^ sbox[b >> 16 & 255] << 16 ^ sbox[c >> 8 & 255] << 8 ^ sbox[d & 255] ^ key[kIndex++];
|
|
a2 = a;a = b;b = c;c = d;d = a2;
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return AES;
|
|
})();
|
|
|
|
exports['default'] = AES;
|
|
module.exports = exports['default'];
|
|
},{}],2:[function(require,module,exports){
|
|
/**
|
|
* @file async-stream.js
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = (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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
|
|
|
|
var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var _stream = require('./stream');
|
|
|
|
var _stream2 = _interopRequireDefault(_stream);
|
|
|
|
/**
|
|
* A wrapper around the Stream class to use setTiemout
|
|
* and run stream "jobs" Asynchronously
|
|
*
|
|
* @class AsyncStream
|
|
* @extends Stream
|
|
*/
|
|
|
|
var AsyncStream = (function (_Stream) {
|
|
_inherits(AsyncStream, _Stream);
|
|
|
|
function AsyncStream() {
|
|
_classCallCheck(this, AsyncStream);
|
|
|
|
_get(Object.getPrototypeOf(AsyncStream.prototype), 'constructor', this).call(this, _stream2['default']);
|
|
this.jobs = [];
|
|
this.delay = 1;
|
|
this.timeout_ = null;
|
|
}
|
|
|
|
/**
|
|
* process an async job
|
|
*
|
|
* @private
|
|
*/
|
|
|
|
_createClass(AsyncStream, [{
|
|
key: 'processJob_',
|
|
value: function processJob_() {
|
|
this.jobs.shift()();
|
|
if (this.jobs.length) {
|
|
this.timeout_ = setTimeout(this.processJob_.bind(this), this.delay);
|
|
} else {
|
|
this.timeout_ = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* push a job into the stream
|
|
*
|
|
* @param {Function} job the job to push into the stream
|
|
*/
|
|
}, {
|
|
key: 'push',
|
|
value: function push(job) {
|
|
this.jobs.push(job);
|
|
if (!this.timeout_) {
|
|
this.timeout_ = setTimeout(this.processJob_.bind(this), this.delay);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return AsyncStream;
|
|
})(_stream2['default']);
|
|
|
|
exports['default'] = AsyncStream;
|
|
module.exports = exports['default'];
|
|
},{"./stream":4}],3:[function(require,module,exports){
|
|
/**
|
|
* @file decrypter.js
|
|
*
|
|
* An asynchronous implementation of AES-128 CBC decryption with
|
|
* PKCS#7 padding.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = (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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
var _aes = require('./aes');
|
|
|
|
var _aes2 = _interopRequireDefault(_aes);
|
|
|
|
var _asyncStream = require('./async-stream');
|
|
|
|
var _asyncStream2 = _interopRequireDefault(_asyncStream);
|
|
|
|
var _pkcs7 = require('pkcs7');
|
|
|
|
/**
|
|
* Convert network-order (big-endian) bytes into their little-endian
|
|
* representation.
|
|
*/
|
|
var ntoh = function ntoh(word) {
|
|
return word << 24 | (word & 0xff00) << 8 | (word & 0xff0000) >> 8 | word >>> 24;
|
|
};
|
|
|
|
/**
|
|
* Decrypt bytes using AES-128 with CBC and PKCS#7 padding.
|
|
*
|
|
* @param {Uint8Array} encrypted the encrypted bytes
|
|
* @param {Uint32Array} key the bytes of the decryption key
|
|
* @param {Uint32Array} initVector the initialization vector (IV) to
|
|
* use for the first round of CBC.
|
|
* @return {Uint8Array} the decrypted bytes
|
|
*
|
|
* @see http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
|
|
* @see http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher_Block_Chaining_.28CBC.29
|
|
* @see https://tools.ietf.org/html/rfc2315
|
|
*/
|
|
var decrypt = function decrypt(encrypted, key, initVector) {
|
|
// word-level access to the encrypted bytes
|
|
var encrypted32 = new Int32Array(encrypted.buffer, encrypted.byteOffset, encrypted.byteLength >> 2);
|
|
|
|
var decipher = new _aes2['default'](Array.prototype.slice.call(key));
|
|
|
|
// byte and word-level access for the decrypted output
|
|
var decrypted = new Uint8Array(encrypted.byteLength);
|
|
var decrypted32 = new Int32Array(decrypted.buffer);
|
|
|
|
// temporary variables for working with the IV, encrypted, and
|
|
// decrypted data
|
|
var init0 = undefined;
|
|
var init1 = undefined;
|
|
var init2 = undefined;
|
|
var init3 = undefined;
|
|
var encrypted0 = undefined;
|
|
var encrypted1 = undefined;
|
|
var encrypted2 = undefined;
|
|
var encrypted3 = undefined;
|
|
|
|
// iteration variable
|
|
var wordIx = undefined;
|
|
|
|
// pull out the words of the IV to ensure we don't modify the
|
|
// passed-in reference and easier access
|
|
init0 = initVector[0];
|
|
init1 = initVector[1];
|
|
init2 = initVector[2];
|
|
init3 = initVector[3];
|
|
|
|
// decrypt four word sequences, applying cipher-block chaining (CBC)
|
|
// to each decrypted block
|
|
for (wordIx = 0; wordIx < encrypted32.length; wordIx += 4) {
|
|
// convert big-endian (network order) words into little-endian
|
|
// (javascript order)
|
|
encrypted0 = ntoh(encrypted32[wordIx]);
|
|
encrypted1 = ntoh(encrypted32[wordIx + 1]);
|
|
encrypted2 = ntoh(encrypted32[wordIx + 2]);
|
|
encrypted3 = ntoh(encrypted32[wordIx + 3]);
|
|
|
|
// decrypt the block
|
|
decipher.decrypt(encrypted0, encrypted1, encrypted2, encrypted3, decrypted32, wordIx);
|
|
|
|
// XOR with the IV, and restore network byte-order to obtain the
|
|
// plaintext
|
|
decrypted32[wordIx] = ntoh(decrypted32[wordIx] ^ init0);
|
|
decrypted32[wordIx + 1] = ntoh(decrypted32[wordIx + 1] ^ init1);
|
|
decrypted32[wordIx + 2] = ntoh(decrypted32[wordIx + 2] ^ init2);
|
|
decrypted32[wordIx + 3] = ntoh(decrypted32[wordIx + 3] ^ init3);
|
|
|
|
// setup the IV for the next round
|
|
init0 = encrypted0;
|
|
init1 = encrypted1;
|
|
init2 = encrypted2;
|
|
init3 = encrypted3;
|
|
}
|
|
|
|
return decrypted;
|
|
};
|
|
|
|
exports.decrypt = decrypt;
|
|
/**
|
|
* The `Decrypter` class that manages decryption of AES
|
|
* data through `AsyncStream` objects and the `decrypt`
|
|
* function
|
|
*
|
|
* @param {Uint8Array} encrypted the encrypted bytes
|
|
* @param {Uint32Array} key the bytes of the decryption key
|
|
* @param {Uint32Array} initVector the initialization vector (IV) to
|
|
* @param {Function} done the function to run when done
|
|
* @class Decrypter
|
|
*/
|
|
|
|
var Decrypter = (function () {
|
|
function Decrypter(encrypted, key, initVector, done) {
|
|
_classCallCheck(this, Decrypter);
|
|
|
|
var step = Decrypter.STEP;
|
|
var encrypted32 = new Int32Array(encrypted.buffer);
|
|
var decrypted = new Uint8Array(encrypted.byteLength);
|
|
var i = 0;
|
|
|
|
this.asyncStream_ = new _asyncStream2['default']();
|
|
|
|
// split up the encryption job and do the individual chunks asynchronously
|
|
this.asyncStream_.push(this.decryptChunk_(encrypted32.subarray(i, i + step), key, initVector, decrypted));
|
|
for (i = step; i < encrypted32.length; i += step) {
|
|
initVector = new Uint32Array([ntoh(encrypted32[i - 4]), ntoh(encrypted32[i - 3]), ntoh(encrypted32[i - 2]), ntoh(encrypted32[i - 1])]);
|
|
this.asyncStream_.push(this.decryptChunk_(encrypted32.subarray(i, i + step), key, initVector, decrypted));
|
|
}
|
|
// invoke the done() callback when everything is finished
|
|
this.asyncStream_.push(function () {
|
|
// remove pkcs#7 padding from the decrypted bytes
|
|
done(null, (0, _pkcs7.unpad)(decrypted));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* a getter for step the maximum number of bytes to process at one time
|
|
*
|
|
* @return {Number} the value of step 32000
|
|
*/
|
|
|
|
_createClass(Decrypter, [{
|
|
key: 'decryptChunk_',
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
value: function decryptChunk_(encrypted, key, initVector, decrypted) {
|
|
return function () {
|
|
var bytes = decrypt(encrypted, key, initVector);
|
|
|
|
decrypted.set(bytes, encrypted.byteOffset);
|
|
};
|
|
}
|
|
}], [{
|
|
key: 'STEP',
|
|
get: function get() {
|
|
// 4 * 8000;
|
|
return 32000;
|
|
}
|
|
}]);
|
|
|
|
return Decrypter;
|
|
})();
|
|
|
|
exports.Decrypter = Decrypter;
|
|
exports['default'] = {
|
|
Decrypter: Decrypter,
|
|
decrypt: decrypt
|
|
};
|
|
},{"./aes":1,"./async-stream":2,"pkcs7":6}],4:[function(require,module,exports){
|
|
/**
|
|
* @file stream.js
|
|
*/
|
|
/**
|
|
* A lightweight readable stream implemention that handles event dispatching.
|
|
*
|
|
* @class Stream
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = (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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
var Stream = (function () {
|
|
function Stream() {
|
|
_classCallCheck(this, Stream);
|
|
|
|
this.listeners = {};
|
|
}
|
|
|
|
/**
|
|
* Add a listener for a specified event type.
|
|
*
|
|
* @param {String} type the event name
|
|
* @param {Function} listener the callback to be invoked when an event of
|
|
* the specified type occurs
|
|
*/
|
|
|
|
_createClass(Stream, [{
|
|
key: 'on',
|
|
value: function on(type, listener) {
|
|
if (!this.listeners[type]) {
|
|
this.listeners[type] = [];
|
|
}
|
|
this.listeners[type].push(listener);
|
|
}
|
|
|
|
/**
|
|
* Remove a listener for a specified event type.
|
|
*
|
|
* @param {String} type the event name
|
|
* @param {Function} listener a function previously registered for this
|
|
* type of event through `on`
|
|
* @return {Boolean} if we could turn it off or not
|
|
*/
|
|
}, {
|
|
key: 'off',
|
|
value: function off(type, listener) {
|
|
var index = undefined;
|
|
|
|
if (!this.listeners[type]) {
|
|
return false;
|
|
}
|
|
index = this.listeners[type].indexOf(listener);
|
|
this.listeners[type].splice(index, 1);
|
|
return index > -1;
|
|
}
|
|
|
|
/**
|
|
* Trigger an event of the specified type on this stream. Any additional
|
|
* arguments to this function are passed as parameters to event listeners.
|
|
*
|
|
* @param {String} type the event name
|
|
*/
|
|
}, {
|
|
key: 'trigger',
|
|
value: function trigger(type) {
|
|
var callbacks = undefined;
|
|
var i = undefined;
|
|
var length = undefined;
|
|
var args = undefined;
|
|
|
|
callbacks = this.listeners[type];
|
|
if (!callbacks) {
|
|
return;
|
|
}
|
|
// Slicing the arguments on every invocation of this method
|
|
// can add a significant amount of overhead. Avoid the
|
|
// intermediate object creation for the common case of a
|
|
// single callback argument
|
|
if (arguments.length === 2) {
|
|
length = callbacks.length;
|
|
for (i = 0; i < length; ++i) {
|
|
callbacks[i].call(this, arguments[1]);
|
|
}
|
|
} else {
|
|
args = Array.prototype.slice.call(arguments, 1);
|
|
length = callbacks.length;
|
|
for (i = 0; i < length; ++i) {
|
|
callbacks[i].apply(this, args);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Destroys the stream and cleans up.
|
|
*/
|
|
}, {
|
|
key: 'dispose',
|
|
value: function dispose() {
|
|
this.listeners = {};
|
|
}
|
|
|
|
/**
|
|
* Forwards all `data` events on this stream to the destination stream. The
|
|
* destination stream should provide a method `push` to receive the data
|
|
* events as they arrive.
|
|
*
|
|
* @param {Stream} destination the stream that will receive all `data` events
|
|
* @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
|
|
*/
|
|
}, {
|
|
key: 'pipe',
|
|
value: function pipe(destination) {
|
|
this.on('data', function (data) {
|
|
destination.push(data);
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return Stream;
|
|
})();
|
|
|
|
exports['default'] = Stream;
|
|
module.exports = exports['default'];
|
|
},{}],5:[function(require,module,exports){
|
|
/*
|
|
* pkcs7.pad
|
|
* https://github.com/brightcove/pkcs7
|
|
*
|
|
* Copyright (c) 2014 Brightcove
|
|
* Licensed under the apache2 license.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var PADDING;
|
|
|
|
/**
|
|
* Returns a new Uint8Array that is padded with PKCS#7 padding.
|
|
* @param plaintext {Uint8Array} the input bytes before encryption
|
|
* @return {Uint8Array} the padded bytes
|
|
* @see http://tools.ietf.org/html/rfc5652
|
|
*/
|
|
module.exports = function pad(plaintext) {
|
|
var padding = PADDING[(plaintext.byteLength % 16) || 0],
|
|
result = new Uint8Array(plaintext.byteLength + padding.length);
|
|
result.set(plaintext);
|
|
result.set(padding, plaintext.byteLength);
|
|
return result;
|
|
};
|
|
|
|
// pre-define the padding values
|
|
PADDING = [
|
|
[16, 16, 16, 16,
|
|
16, 16, 16, 16,
|
|
16, 16, 16, 16,
|
|
16, 16, 16, 16],
|
|
|
|
[15, 15, 15, 15,
|
|
15, 15, 15, 15,
|
|
15, 15, 15, 15,
|
|
15, 15, 15],
|
|
|
|
[14, 14, 14, 14,
|
|
14, 14, 14, 14,
|
|
14, 14, 14, 14,
|
|
14, 14],
|
|
|
|
[13, 13, 13, 13,
|
|
13, 13, 13, 13,
|
|
13, 13, 13, 13,
|
|
13],
|
|
|
|
[12, 12, 12, 12,
|
|
12, 12, 12, 12,
|
|
12, 12, 12, 12],
|
|
|
|
[11, 11, 11, 11,
|
|
11, 11, 11, 11,
|
|
11, 11, 11],
|
|
|
|
[10, 10, 10, 10,
|
|
10, 10, 10, 10,
|
|
10, 10],
|
|
|
|
[9, 9, 9, 9,
|
|
9, 9, 9, 9,
|
|
9],
|
|
|
|
[8, 8, 8, 8,
|
|
8, 8, 8, 8],
|
|
|
|
[7, 7, 7, 7,
|
|
7, 7, 7],
|
|
|
|
[6, 6, 6, 6,
|
|
6, 6],
|
|
|
|
[5, 5, 5, 5,
|
|
5],
|
|
|
|
[4, 4, 4, 4],
|
|
|
|
[3, 3, 3],
|
|
|
|
[2, 2],
|
|
|
|
[1]
|
|
];
|
|
|
|
},{}],6:[function(require,module,exports){
|
|
/*
|
|
* pkcs7
|
|
* https://github.com/brightcove/pkcs7
|
|
*
|
|
* Copyright (c) 2014 Brightcove
|
|
* Licensed under the apache2 license.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
exports.pad = require('./pad.js');
|
|
exports.unpad = require('./unpad.js');
|
|
|
|
},{"./pad.js":5,"./unpad.js":7}],7:[function(require,module,exports){
|
|
/*
|
|
* pkcs7.unpad
|
|
* https://github.com/brightcove/pkcs7
|
|
*
|
|
* Copyright (c) 2014 Brightcove
|
|
* Licensed under the apache2 license.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
/**
|
|
* Returns the subarray of a Uint8Array without PKCS#7 padding.
|
|
* @param padded {Uint8Array} unencrypted bytes that have been padded
|
|
* @return {Uint8Array} the unpadded bytes
|
|
* @see http://tools.ietf.org/html/rfc5652
|
|
*/
|
|
module.exports = function unpad(padded) {
|
|
return padded.subarray(0, padded.byteLength - padded[padded.byteLength - 1]);
|
|
};
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
/**
|
|
* @file index.js
|
|
*
|
|
* Index module to easily import the primary components of AES-128
|
|
* decryption. Like this:
|
|
*
|
|
* ```js
|
|
* import {Decrypter, decrypt, AsyncStream} from 'aes-decrypter';
|
|
* ```
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _decrypter = require('./decrypter');
|
|
|
|
var _asyncStream = require('./async-stream');
|
|
|
|
var _asyncStream2 = _interopRequireDefault(_asyncStream);
|
|
|
|
exports['default'] = {
|
|
decrypt: _decrypter.decrypt,
|
|
Decrypter: _decrypter.Decrypter,
|
|
AsyncStream: _asyncStream2['default']
|
|
};
|
|
module.exports = exports['default'];
|
|
},{"./async-stream":2,"./decrypter":3}]},{},[8])(8)
|
|
}); |