811 lines
26 KiB
JavaScript
811 lines
26 KiB
JavaScript
function CryptoService(constantsService, utilsService) {
|
|
this.constantsService = constantsService;
|
|
this.utilsService = utilsService;
|
|
|
|
initCryptoService(constantsService);
|
|
}
|
|
|
|
function initCryptoService(constantsService) {
|
|
var _key,
|
|
_encKey,
|
|
_legacyEtmKey,
|
|
_keyHash,
|
|
_privateKey,
|
|
_orgKeys,
|
|
_crypto = window.crypto,
|
|
_subtle = window.crypto.subtle,
|
|
keyKey = 'key',
|
|
encOrgKeysKey = 'encOrgKeys',
|
|
encPrivateKeyKey = 'encPrivateKey',
|
|
encKeyKey = 'encKey',
|
|
keyHashKey = 'keyHash';
|
|
|
|
CryptoService.prototype.setKey = function (key) {
|
|
var self = this;
|
|
_key = key;
|
|
|
|
return self.utilsService.getObjFromStorage(self.constantsService.lockOptionKey).then(function (option) {
|
|
if (option || option === 0) {
|
|
// if we have a lock option set, we do not store the key
|
|
return;
|
|
}
|
|
|
|
return self.utilsService.saveObjToStorage(keyKey, key.keyB64);
|
|
});
|
|
};
|
|
|
|
CryptoService.prototype.setKeyHash = function (keyHash, callback) {
|
|
if (!callback || typeof callback !== 'function') {
|
|
throw 'callback function required';
|
|
}
|
|
|
|
_keyHash = keyHash;
|
|
|
|
chrome.storage.local.set({
|
|
'keyHash': _keyHash
|
|
}, function () {
|
|
callback();
|
|
});
|
|
};
|
|
|
|
CryptoService.prototype.setEncKey = function (encKey) {
|
|
if (encKey === undefined) {
|
|
return Q();
|
|
}
|
|
|
|
return this.utilsService.saveObjToStorage(encKeyKey, encKey).then(function () {
|
|
_encKey = null;
|
|
});
|
|
};
|
|
|
|
CryptoService.prototype.setEncPrivateKey = function (encPrivateKey) {
|
|
if (encPrivateKey === undefined) {
|
|
return Q();
|
|
}
|
|
|
|
return this.utilsService.saveObjToStorage(encPrivateKeyKey, encPrivateKey).then(function () {
|
|
_privateKey = null;
|
|
});
|
|
};
|
|
|
|
CryptoService.prototype.setOrgKeys = function (orgs) {
|
|
var orgKeys = {};
|
|
for (var i = 0; i < orgs.length; i++) {
|
|
orgKeys[orgs[i].id] = orgs[i].key;
|
|
}
|
|
|
|
return this.utilsService.saveObjToStorage(encOrgKeysKey, orgKeys);
|
|
};
|
|
|
|
CryptoService.prototype.getKey = function () {
|
|
if (_key) {
|
|
return Q(_key);
|
|
}
|
|
|
|
var self = this;
|
|
return self.utilsService.getObjFromStorage(self.constantsService.lockOptionKey).then(function (option) {
|
|
if (option || option === 0) {
|
|
return false;
|
|
}
|
|
|
|
return self.utilsService.getObjFromStorage(keyKey);
|
|
}).then(function (key) {
|
|
if (key) {
|
|
_key = new SymmetricCryptoKey(key, true);
|
|
}
|
|
return key === false ? null : _key;
|
|
});
|
|
};
|
|
|
|
CryptoService.prototype.getKeyHash = function (callback) {
|
|
if (!callback || typeof callback !== 'function') {
|
|
throw 'callback function required';
|
|
}
|
|
|
|
if (_keyHash) {
|
|
callback(_keyHash);
|
|
return;
|
|
}
|
|
|
|
chrome.storage.local.get(keyHashKey, function (obj) {
|
|
if (obj && obj.keyHash) {
|
|
_keyHash = obj.keyHash;
|
|
}
|
|
|
|
callback(_keyHash);
|
|
});
|
|
};
|
|
|
|
CryptoService.prototype.getEncKey = function () {
|
|
if (_encKey) {
|
|
return Q(_encKey);
|
|
}
|
|
|
|
var self = this,
|
|
encKey = null;
|
|
return self.utilsService.getObjFromStorage(encKeyKey).then(function (theEncKey) {
|
|
if (!theEncKey) {
|
|
return null;
|
|
}
|
|
|
|
encKey = theEncKey;
|
|
return self.getKey();
|
|
}).then(function (key) {
|
|
if (!key) {
|
|
return null;
|
|
}
|
|
|
|
return self.decrypt(new CipherString(encKey), key, 'raw');
|
|
}).then(function (decEncKey) {
|
|
if (decEncKey) {
|
|
_encKey = new SymmetricCryptoKey(decEncKey);
|
|
return _encKey;
|
|
}
|
|
|
|
return null;
|
|
}, function () {
|
|
throw 'Cannot get enc key. Decryption failed.';
|
|
});
|
|
};
|
|
|
|
CryptoService.prototype.getPrivateKey = function () {
|
|
if (_privateKey) {
|
|
return Q(_privateKey);
|
|
}
|
|
|
|
var self = this;
|
|
return self.utilsService.getObjFromStorage(encPrivateKeyKey).then(function (encPrivateKey) {
|
|
if (!encPrivateKey) {
|
|
return null;
|
|
}
|
|
return self.decrypt(new CipherString(encPrivateKey), null, 'raw');
|
|
}).then(function (privateKey) {
|
|
if (privateKey) {
|
|
var privateKeyB64 = forge.util.encode64(privateKey);
|
|
_privateKey = fromB64ToArray(privateKeyB64).buffer;
|
|
return _privateKey;
|
|
}
|
|
|
|
return null;
|
|
}, function () {
|
|
throw 'Cannot get private key. Decryption failed.';
|
|
});
|
|
};
|
|
|
|
CryptoService.prototype.getOrgKeys = function () {
|
|
if (_orgKeys && _orgKeys.length) {
|
|
return Q(_orgKeys);
|
|
}
|
|
|
|
var self = this,
|
|
deferred = Q.defer();
|
|
|
|
chrome.storage.local.get(encOrgKeysKey, function (obj) {
|
|
if (obj && obj.encOrgKeys) {
|
|
var orgKeys = {},
|
|
setKey = false;
|
|
|
|
var decPromises = [];
|
|
for (var orgId in obj.encOrgKeys) {
|
|
if (obj.encOrgKeys.hasOwnProperty(orgId)) {
|
|
/* jshint ignore:start */
|
|
(function (orgIdInstance) {
|
|
var promise = self.rsaDecrypt(obj.encOrgKeys[orgIdInstance]).then(function (decValueB64) {
|
|
orgKeys[orgIdInstance] = new SymmetricCryptoKey(decValueB64, true);
|
|
setKey = true;
|
|
}, function (err) {
|
|
console.log('getOrgKeys error: ' + err);
|
|
});
|
|
decPromises.push(promise);
|
|
})(orgId);
|
|
/* jshint ignore:end */
|
|
}
|
|
}
|
|
|
|
Q.all(decPromises).then(function () {
|
|
if (setKey) {
|
|
_orgKeys = orgKeys;
|
|
}
|
|
|
|
deferred.resolve(_orgKeys);
|
|
});
|
|
}
|
|
else {
|
|
deferred.resolve(null);
|
|
}
|
|
});
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
CryptoService.prototype.getOrgKey = function (orgId) {
|
|
if (!orgId) {
|
|
return Q(null);
|
|
}
|
|
|
|
return this.getOrgKeys().then(function (orgKeys) {
|
|
if (!orgKeys || !(orgId in orgKeys)) {
|
|
return null;
|
|
}
|
|
|
|
return orgKeys[orgId];
|
|
});
|
|
};
|
|
|
|
CryptoService.prototype.clearKey = function (callback) {
|
|
_key = _legacyEtmKey = null;
|
|
return this.utilsService.removeFromStorage(keyKey);
|
|
};
|
|
|
|
CryptoService.prototype.clearKeyHash = function (callback) {
|
|
_keyHash = null;
|
|
return this.utilsService.removeFromStorage(keyHashKey);
|
|
};
|
|
|
|
CryptoService.prototype.clearEncKey = function (memoryOnly) {
|
|
_encKey = null;
|
|
if (memoryOnly) {
|
|
return Q();
|
|
}
|
|
return this.utilsService.removeFromStorage(encKeyKey);
|
|
};
|
|
|
|
CryptoService.prototype.clearPrivateKey = function (memoryOnly) {
|
|
_privateKey = null;
|
|
if (memoryOnly) {
|
|
return Q();
|
|
}
|
|
return this.utilsService.removeFromStorage(encPrivateKeyKey);
|
|
};
|
|
|
|
CryptoService.prototype.clearOrgKeys = function (memoryOnly) {
|
|
_orgKeys = null;
|
|
if (memoryOnly) {
|
|
return Q();
|
|
}
|
|
return this.utilsService.removeFromStorage(encOrgKeysKey);
|
|
};
|
|
|
|
CryptoService.prototype.clearKeys = function () {
|
|
var self = this;
|
|
return Q.all([
|
|
self.clearKey(),
|
|
self.clearKeyHash(),
|
|
self.clearOrgKeys(),
|
|
self.clearEncKey(),
|
|
self.clearPrivateKey()
|
|
]);
|
|
};
|
|
|
|
CryptoService.prototype.toggleKey = function () {
|
|
var self = this,
|
|
key = null;
|
|
|
|
return self.getKey().then(function (theKey) {
|
|
key = theKey;
|
|
return self.utilsService.getObjFromStorage(self.constantsService.lockOptionKey);
|
|
}).then(function (option) {
|
|
if (option || option === 0) {
|
|
// if we have a lock option set, clear the key
|
|
return self.clearKey().then(function () {
|
|
_key = key;
|
|
});
|
|
}
|
|
else {
|
|
// no lock option, so store the current key
|
|
return self.setKey(key);
|
|
}
|
|
});
|
|
};
|
|
|
|
CryptoService.prototype.makeKey = function (password, salt) {
|
|
var keyBytes = forge.pbkdf2(forge.util.encodeUtf8(password), forge.util.encodeUtf8(salt),
|
|
5000, 256 / 8, 'sha256');
|
|
|
|
return new SymmetricCryptoKey(keyBytes);
|
|
};
|
|
|
|
CryptoService.prototype.hashPassword = function (password, key, callback) {
|
|
this.getKey().then(function (storedKey) {
|
|
key = key || storedKey;
|
|
|
|
if (!password || !key) {
|
|
throw 'Invalid parameters.';
|
|
}
|
|
|
|
var hashBits = forge.pbkdf2(key.key, forge.util.encodeUtf8(password), 1, 256 / 8, 'sha256');
|
|
callback(forge.util.encode64(hashBits));
|
|
});
|
|
};
|
|
|
|
CryptoService.prototype.makeEncKey = function (key) {
|
|
var bytes = new Uint8Array(512 / 8);
|
|
_crypto.getRandomValues(bytes);
|
|
return this.encrypt(bytes, key, 'raw');
|
|
};
|
|
|
|
CryptoService.prototype.encrypt = function (plainValue, key, plainValueEncoding) {
|
|
if (plainValue === null || plainValue === undefined) {
|
|
return Q(null);
|
|
}
|
|
|
|
plainValueEncoding = plainValueEncoding || 'utf8';
|
|
if (plainValueEncoding === 'utf8') {
|
|
plainValue = fromUtf8ToArray(plainValue);
|
|
}
|
|
|
|
return aesEncrypt(this, plainValue.buffer, key).then(function (encValue) {
|
|
var encType = encValue.key.encType;
|
|
var iv = fromBufferToB64(encValue.iv);
|
|
var ct = fromBufferToB64(encValue.ct);
|
|
var mac = encValue.mac ? fromBufferToB64(encValue.mac) : null;
|
|
return new CipherString(encType, iv, ct, mac);
|
|
});
|
|
};
|
|
|
|
CryptoService.prototype.encryptToBytes = function (plainValue, key) {
|
|
return aesEncrypt(this, plainValue, key).then(function (encValue) {
|
|
var macLen = 0;
|
|
if (encValue.mac) {
|
|
macLen = encValue.mac.length;
|
|
}
|
|
|
|
var encBytes = new Uint8Array(1 + encValue.iv.length + macLen + encValue.ct.length);
|
|
|
|
encBytes.set([encValue.key.encType]);
|
|
encBytes.set(encValue.iv, 1);
|
|
if (encValue.mac) {
|
|
encBytes.set(encValue.mac, 1 + encValue.iv.length);
|
|
}
|
|
encBytes.set(encValue.ct, 1 + encValue.iv.length + macLen);
|
|
|
|
return encBytes.buffer;
|
|
});
|
|
};
|
|
|
|
function aesEncrypt(self, plainValue, key) {
|
|
var obj = {
|
|
iv: new Uint8Array(16),
|
|
ct: null,
|
|
mac: null,
|
|
key: null
|
|
};
|
|
|
|
_crypto.getRandomValues(obj.iv);
|
|
var keyBuf;
|
|
|
|
return getKeyForEncryption(self, key).then(function (keyToUse) {
|
|
obj.key = keyToUse;
|
|
keyBuf = keyToUse.getBuffers();
|
|
return _subtle.importKey('raw', keyBuf.encKey, { name: 'AES-CBC' }, false, ['encrypt']);
|
|
}).then(function (encKey) {
|
|
return _subtle.encrypt({ name: 'AES-CBC', iv: obj.iv }, encKey, plainValue);
|
|
}).then(function (encValue) {
|
|
obj.ct = new Uint8Array(encValue);
|
|
if (!keyBuf.macKey) {
|
|
return null;
|
|
}
|
|
|
|
var data = new Uint8Array(obj.iv.length + obj.ct.length);
|
|
data.set(obj.iv, 0);
|
|
data.set(obj.ct, obj.iv.length);
|
|
return computeMacWC(data.buffer, keyBuf.macKey);
|
|
}).then(function (mac) {
|
|
if (mac) {
|
|
obj.mac = new Uint8Array(mac);
|
|
}
|
|
return obj;
|
|
});
|
|
}
|
|
|
|
CryptoService.prototype.decrypt = function (cipherString, key, outputEncoding) {
|
|
outputEncoding = outputEncoding || 'utf8';
|
|
|
|
var ivBytes = forge.util.decode64(cipherString.initializationVector);
|
|
var ctBytes = forge.util.decode64(cipherString.cipherText);
|
|
var macBytes = cipherString.mac ? forge.util.decode64(cipherString.mac) : null;
|
|
|
|
return aesDecrypt(this, cipherString.encryptionType, ctBytes, ivBytes, macBytes, key).then(function (decipher) {
|
|
if (!decipher) {
|
|
return null;
|
|
}
|
|
|
|
if (outputEncoding === 'utf8') {
|
|
return decipher.output.toString('utf8');
|
|
}
|
|
else {
|
|
return decipher.output.getBytes();
|
|
}
|
|
});
|
|
};
|
|
|
|
CryptoService.prototype.decryptFromBytes = function (encBuf, key) {
|
|
if (!encBuf) {
|
|
throw 'no encBuf.';
|
|
}
|
|
|
|
var encBytes = new Uint8Array(encBuf),
|
|
encType = encBytes[0],
|
|
ctBytes = null,
|
|
ivBytes = null,
|
|
macBytes = null;
|
|
|
|
switch (encType) {
|
|
case constantsService.encType.AesCbc128_HmacSha256_B64:
|
|
case constantsService.encType.AesCbc256_HmacSha256_B64:
|
|
if (encBytes.length <= 49) { // 1 + 16 + 32 + ctLength
|
|
return null;
|
|
}
|
|
|
|
ivBytes = encBytes.slice(1, 17);
|
|
macBytes = encBytes.slice(17, 49);
|
|
ctBytes = encBytes.slice(49);
|
|
break;
|
|
case constantsService.encType.AesCbc256_B64:
|
|
if (encBytes.length <= 17) { // 1 + 16 + ctLength
|
|
return null;
|
|
}
|
|
|
|
ivBytes = encBytes.slice(1, 17);
|
|
ctBytes = encBytes.slice(17);
|
|
break;
|
|
default:
|
|
return null;
|
|
}
|
|
|
|
return aesDecryptWC(this, encType, ctBytes.buffer, ivBytes.buffer, macBytes ? macBytes.buffer : null, key);
|
|
};
|
|
|
|
function aesDecrypt(self, encType, ctBytes, ivBytes, macBytes, key) {
|
|
return getKeyForEncryption(self, key).then(function (theKey) {
|
|
theKey = resolveLegacyKey(encType, theKey);
|
|
|
|
if (encType !== theKey.encType) {
|
|
console.error('encType unavailable.');
|
|
return null;
|
|
}
|
|
|
|
if (theKey.macKey && macBytes) {
|
|
var computedMacBytes = computeMac(ivBytes + ctBytes, theKey.macKey, false);
|
|
if (!macsEqual(theKey.macKey, computedMacBytes, macBytes)) {
|
|
console.error('MAC failed.');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
var ctBuffer = forge.util.createBuffer(ctBytes);
|
|
var decipher = forge.cipher.createDecipher('AES-CBC', theKey.encKey);
|
|
decipher.start({ iv: ivBytes });
|
|
decipher.update(ctBuffer);
|
|
decipher.finish();
|
|
|
|
return decipher;
|
|
});
|
|
}
|
|
|
|
function aesDecryptWC(self, encType, ctBuf, ivBuf, macBuf, key) {
|
|
var keyBuf,
|
|
encKey;
|
|
|
|
return getKeyForEncryption(self, key).then(function (theKey) {
|
|
theKey = resolveLegacyKey(encType, theKey);
|
|
keyBuf = theKey.getBuffers();
|
|
return _subtle.importKey('raw', keyBuf.encKey, { name: 'AES-CBC' }, false, ['decrypt']);
|
|
}).then(function (theEncKey) {
|
|
encKey = theEncKey;
|
|
|
|
if (!keyBuf.macKey || !macBuf) {
|
|
return null;
|
|
}
|
|
|
|
var data = new Uint8Array(ivBuf.byteLength + ctBuf.byteLength);
|
|
data.set(new Uint8Array(ivBuf), 0);
|
|
data.set(new Uint8Array(ctBuf), ivBuf.byteLength);
|
|
return computeMacWC(data.buffer, keyBuf.macKey);
|
|
}).then(function (computedMacBuf) {
|
|
if (computedMacBuf === null) {
|
|
return null;
|
|
}
|
|
return macsEqualWC(keyBuf.macKey, macBuf, computedMacBuf);
|
|
}).then(function (macsMatch) {
|
|
if (macsMatch === false) {
|
|
console.error('MAC failed.');
|
|
return null;
|
|
}
|
|
return _subtle.decrypt({ name: 'AES-CBC', iv: ivBuf }, encKey, ctBuf);
|
|
});
|
|
}
|
|
|
|
function resolveLegacyKey(encType, key) {
|
|
if (encType === constantsService.encType.AesCbc128_HmacSha256_B64 &&
|
|
key.encType === constantsService.encType.AesCbc256_B64) {
|
|
// Old encrypt-then-mac scheme, make a new key
|
|
_legacyEtmKey = _legacyEtmKey ||
|
|
new SymmetricCryptoKey(key.key, false, constantsService.encType.AesCbc128_HmacSha256_B64);
|
|
return _legacyEtmKey;
|
|
}
|
|
|
|
return key;
|
|
}
|
|
|
|
CryptoService.prototype.rsaDecrypt = function (encValue) {
|
|
var headerPieces = encValue.split('.'),
|
|
encType,
|
|
encPieces;
|
|
|
|
if (headerPieces.length === 1) {
|
|
encType = constantsService.encType.Rsa2048_OaepSha256_B64;
|
|
encPieces = [headerPieces[0]];
|
|
}
|
|
else if (headerPieces.length === 2) {
|
|
try {
|
|
encType = parseInt(headerPieces[0]);
|
|
encPieces = headerPieces[1].split('|');
|
|
}
|
|
catch (e) { }
|
|
}
|
|
|
|
switch (encType) {
|
|
case constantsService.encType.Rsa2048_OaepSha256_B64:
|
|
case constantsService.encType.Rsa2048_OaepSha1_B64:
|
|
if (encPieces.length !== 1) {
|
|
throw 'Invalid cipher format.';
|
|
}
|
|
break;
|
|
case constantsService.encType.Rsa2048_OaepSha256_HmacSha256_B64:
|
|
case constantsService.encType.Rsa2048_OaepSha1_HmacSha256_B64:
|
|
if (encPieces.length !== 2) {
|
|
throw 'Invalid cipher format.';
|
|
}
|
|
break;
|
|
default:
|
|
throw 'encType unavailable.';
|
|
}
|
|
|
|
var padding = null;
|
|
switch (encType) {
|
|
case constantsService.encType.Rsa2048_OaepSha256_B64:
|
|
case constantsService.encType.Rsa2048_OaepSha256_HmacSha256_B64:
|
|
padding = {
|
|
name: 'RSA-OAEP',
|
|
hash: { name: 'SHA-256' }
|
|
};
|
|
break;
|
|
case constantsService.encType.Rsa2048_OaepSha1_B64:
|
|
case constantsService.encType.Rsa2048_OaepSha1_HmacSha256_B64:
|
|
padding = {
|
|
name: 'RSA-OAEP',
|
|
hash: { name: 'SHA-1' }
|
|
};
|
|
break;
|
|
default:
|
|
throw 'encType unavailable.';
|
|
}
|
|
|
|
var key = null,
|
|
self = this;
|
|
|
|
return self.getEncKey().then(function (encKey) {
|
|
key = encKey;
|
|
return self.getPrivateKey();
|
|
}).then(function (privateKeyBytes) {
|
|
if (!privateKeyBytes) {
|
|
throw 'No private key.';
|
|
}
|
|
|
|
if (!padding) {
|
|
throw 'Cannot determine padding.';
|
|
}
|
|
|
|
return _subtle.importKey('pkcs8', privateKeyBytes, padding, false, ['decrypt']);
|
|
}).then(function (privateKey) {
|
|
if (!encPieces || !encPieces.length) {
|
|
throw 'encPieces unavailable.';
|
|
}
|
|
|
|
if (key && key.macKey && encPieces.length > 1) {
|
|
var ctBytes = forge.util.decode64(encPieces[0]);
|
|
var macBytes = forge.util.decode64(encPieces[1]);
|
|
var computedMacBytes = computeMac(ctBytes, key.macKey, false);
|
|
if (!macsEqual(key.macKey, macBytes, computedMacBytes)) {
|
|
throw 'MAC failed.';
|
|
}
|
|
}
|
|
|
|
var ctArr = fromB64ToArray(encPieces[0]);
|
|
return _subtle.decrypt(padding, privateKey, ctArr.buffer);
|
|
}, function () {
|
|
throw 'Cannot import privateKey.';
|
|
}).then(function (decBytes) {
|
|
var b64DecValue = fromBufferToB64(decBytes);
|
|
return b64DecValue;
|
|
}, function () {
|
|
throw 'Cannot rsa decrypt.';
|
|
});
|
|
};
|
|
|
|
function computeMac(dataBytes, macKey, b64Output) {
|
|
var hmac = forge.hmac.create();
|
|
hmac.start('sha256', macKey);
|
|
hmac.update(dataBytes);
|
|
var mac = hmac.digest();
|
|
return b64Output ? forge.util.encode64(mac.getBytes()) : mac.getBytes();
|
|
}
|
|
|
|
function computeMacWC(dataBuf, macKeyBuf) {
|
|
return _subtle.importKey('raw', macKeyBuf, { name: 'HMAC', hash: { name: 'SHA-256' } }, false, ['sign'])
|
|
.then(function (key) {
|
|
return _subtle.sign({ name: 'HMAC', hash: { name: 'SHA-256' } }, key, dataBuf);
|
|
});
|
|
}
|
|
|
|
function getKeyForEncryption(self, key) {
|
|
var deferred = Q.defer();
|
|
|
|
if (key) {
|
|
deferred.resolve(key);
|
|
}
|
|
else {
|
|
self.getEncKey().then(function (encKey) {
|
|
return encKey || self.getKey();
|
|
}).then(function (keyToUse) {
|
|
deferred.resolve(keyToUse);
|
|
});
|
|
}
|
|
|
|
return deferred.promise;
|
|
}
|
|
|
|
// Safely compare two MACs in a way that protects against timing attacks (Double HMAC Verification).
|
|
// ref: https://www.nccgroup.trust/us/about-us/newsroom-and-events/blog/2011/february/double-hmac-verification/
|
|
function macsEqual(macKey, mac1, mac2) {
|
|
var hmac = forge.hmac.create();
|
|
|
|
hmac.start('sha256', macKey);
|
|
hmac.update(mac1);
|
|
mac1 = hmac.digest().getBytes();
|
|
|
|
hmac.start(null, null);
|
|
hmac.update(mac2);
|
|
mac2 = hmac.digest().getBytes();
|
|
|
|
return mac1 === mac2;
|
|
}
|
|
|
|
function macsEqualWC(macKeyBuf, mac1Buf, mac2Buf) {
|
|
var mac1,
|
|
macKey;
|
|
|
|
return window.crypto.subtle.importKey('raw', macKeyBuf, { name: 'HMAC', hash: { name: 'SHA-256' } }, false, ['sign'])
|
|
.then(function (key) {
|
|
macKey = key;
|
|
return window.crypto.subtle.sign({ name: 'HMAC', hash: { name: 'SHA-256' } }, macKey, mac1Buf);
|
|
}).then(function (mac) {
|
|
mac1 = mac;
|
|
return window.crypto.subtle.sign({ name: 'HMAC', hash: { name: 'SHA-256' } }, macKey, mac2Buf);
|
|
}).then(function (mac2) {
|
|
if (mac1.byteLength !== mac2.byteLength) {
|
|
return false;
|
|
}
|
|
|
|
var arr1 = new Uint8Array(mac1);
|
|
var arr2 = new Uint8Array(mac2);
|
|
|
|
for (var i = 0; i < arr2.length; i++) {
|
|
if (arr1[i] !== arr2[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
});
|
|
}
|
|
|
|
function SymmetricCryptoKey(keyBytes, b64KeyBytes, encType) {
|
|
if (b64KeyBytes) {
|
|
keyBytes = forge.util.decode64(keyBytes);
|
|
}
|
|
|
|
if (!keyBytes) {
|
|
throw 'Must provide keyBytes';
|
|
}
|
|
|
|
var buffer = forge.util.createBuffer(keyBytes);
|
|
if (!buffer || buffer.length() === 0) {
|
|
throw 'Couldn\'t make buffer';
|
|
}
|
|
var bufferLength = buffer.length();
|
|
|
|
if (encType === null || encType === undefined) {
|
|
if (bufferLength === 32) {
|
|
encType = constantsService.encType.AesCbc256_B64;
|
|
}
|
|
else if (bufferLength === 64) {
|
|
encType = constantsService.encType.AesCbc256_HmacSha256_B64;
|
|
}
|
|
else {
|
|
throw 'Unable to determine encType.';
|
|
}
|
|
}
|
|
|
|
this.key = keyBytes;
|
|
this.keyB64 = forge.util.encode64(keyBytes);
|
|
this.encType = encType;
|
|
|
|
if (encType === constantsService.encType.AesCbc256_B64 && bufferLength === 32) {
|
|
this.encKey = keyBytes;
|
|
this.macKey = null;
|
|
}
|
|
else if (encType === constantsService.encType.AesCbc128_HmacSha256_B64 && bufferLength === 32) {
|
|
this.encKey = buffer.getBytes(16); // first half
|
|
this.macKey = buffer.getBytes(16); // second half
|
|
}
|
|
else if (encType === constantsService.encType.AesCbc256_HmacSha256_B64 && bufferLength === 64) {
|
|
this.encKey = buffer.getBytes(32); // first half
|
|
this.macKey = buffer.getBytes(32); // second half
|
|
}
|
|
else {
|
|
throw 'Unsupported encType/key length.';
|
|
}
|
|
}
|
|
|
|
SymmetricCryptoKey.prototype.getBuffers = function () {
|
|
if (this.keyBuf) {
|
|
return this.keyBuf;
|
|
}
|
|
|
|
var key = fromB64ToArray(this.keyB64);
|
|
|
|
var keys = {
|
|
key: key.buffer
|
|
};
|
|
|
|
if (this.macKey) {
|
|
keys.encKey = key.slice(0, key.length / 2).buffer;
|
|
keys.macKey = key.slice(key.length / 2).buffer;
|
|
}
|
|
else {
|
|
keys.encKey = key.buffer;
|
|
keys.macKey = null;
|
|
}
|
|
|
|
this.keyBuf = keys;
|
|
return this.keyBuf;
|
|
};
|
|
|
|
function fromBufferToB64(buffer) {
|
|
var binary = '';
|
|
var bytes = new Uint8Array(buffer);
|
|
var len = bytes.byteLength;
|
|
for (var i = 0; i < len; i++) {
|
|
binary += String.fromCharCode(bytes[i]);
|
|
}
|
|
return window.btoa(binary);
|
|
}
|
|
|
|
function fromBufferToUtf8(buffer) {
|
|
var bytes = new Uint8Array(buffer);
|
|
var encodedString = String.fromCharCode.apply(null, bytes);
|
|
return decodeURIComponent(escape(encodedString));
|
|
}
|
|
|
|
function fromB64ToArray(str) {
|
|
var binary_string = window.atob(str);
|
|
var len = binary_string.length;
|
|
var bytes = new Uint8Array(len);
|
|
for (var i = 0; i < len; i++) {
|
|
bytes[i] = binary_string.charCodeAt(i);
|
|
}
|
|
return bytes;
|
|
}
|
|
|
|
function fromUtf8ToArray(str) {
|
|
var strUtf8 = unescape(encodeURIComponent(str));
|
|
var arr = new Uint8Array(strUtf8.length);
|
|
for (var i = 0; i < strUtf8.length; i++) {
|
|
arr[i] = strUtf8.charCodeAt(i);
|
|
}
|
|
return arr;
|
|
}
|
|
}
|