2015-12-09 04:35:05 +01:00
|
|
|
angular
|
|
|
|
.module('bit.services')
|
|
|
|
|
2017-04-14 00:18:32 +02:00
|
|
|
.factory('cryptoService', function ($sessionStorage, constants, $q) {
|
2015-12-09 04:35:05 +01:00
|
|
|
var _service = {},
|
|
|
|
_key,
|
2017-02-21 04:21:14 +01:00
|
|
|
_b64Key,
|
2017-02-28 06:18:11 +01:00
|
|
|
_privateKey,
|
2017-03-07 05:54:06 +01:00
|
|
|
_publicKey,
|
2017-04-11 00:55:18 +02:00
|
|
|
_orgKeys;
|
2015-12-09 04:35:05 +01:00
|
|
|
|
|
|
|
_service.setKey = function (key) {
|
|
|
|
_key = key;
|
2017-02-11 19:03:48 +01:00
|
|
|
$sessionStorage.key = forge.util.encode64(key);
|
2015-12-09 04:35:05 +01:00
|
|
|
};
|
|
|
|
|
2017-02-21 06:29:15 +01:00
|
|
|
_service.setPrivateKey = function (privateKeyCt, key) {
|
|
|
|
try {
|
2017-03-10 02:59:10 +01:00
|
|
|
var privateKeyBytes = _service.decrypt(privateKeyCt, key, 'raw');
|
|
|
|
$sessionStorage.privateKey = forge.util.encode64(privateKeyBytes);
|
2017-03-22 04:07:38 +01:00
|
|
|
_privateKey = forge.pki.privateKeyFromAsn1(forge.asn1.fromDer(privateKeyBytes));
|
2017-02-21 06:29:15 +01:00
|
|
|
}
|
|
|
|
catch (e) {
|
|
|
|
console.log('Cannot set private key. Decryption failed.');
|
|
|
|
}
|
2017-02-21 04:21:14 +01:00
|
|
|
};
|
|
|
|
|
2017-03-07 05:54:06 +01:00
|
|
|
_service.setOrgKeys = function (orgKeysCt, privateKey) {
|
2017-03-28 04:22:56 +02:00
|
|
|
if (!orgKeysCt || Object.keys(orgKeysCt).length === 0) {
|
2017-03-07 05:54:06 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-04-02 04:17:28 +02:00
|
|
|
_service.clearOrgKeys();
|
2017-03-07 05:54:06 +01:00
|
|
|
var orgKeysb64 = {},
|
2017-03-14 03:54:57 +01:00
|
|
|
_orgKeys = {},
|
|
|
|
setKey = false;
|
2017-03-28 03:55:39 +02:00
|
|
|
|
|
|
|
for (var orgId in orgKeysCt) {
|
|
|
|
if (orgKeysCt.hasOwnProperty(orgId)) {
|
|
|
|
try {
|
|
|
|
var orgKey = _service.rsaDecrypt(orgKeysCt[orgId].key, privateKey);
|
|
|
|
_orgKeys[orgId] = orgKey;
|
|
|
|
orgKeysb64[orgId] = forge.util.encode64(orgKey);
|
|
|
|
setKey = true;
|
|
|
|
}
|
|
|
|
catch (e) {
|
|
|
|
console.log('Cannot set org key ' + i + '. Decryption failed.');
|
|
|
|
}
|
2017-03-07 05:54:06 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-14 03:54:57 +01:00
|
|
|
if (setKey) {
|
|
|
|
$sessionStorage.orgKeys = orgKeysb64;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
_orgKeys = null;
|
|
|
|
}
|
2017-03-12 02:46:33 +01:00
|
|
|
};
|
|
|
|
|
2017-04-03 15:30:21 +02:00
|
|
|
_service.addOrgKey = function (orgId, encOrgKey, privateKey) {
|
2017-03-12 02:46:33 +01:00
|
|
|
_orgKeys = _service.getOrgKeys();
|
|
|
|
if (!_orgKeys) {
|
|
|
|
_orgKeys = {};
|
|
|
|
}
|
|
|
|
|
|
|
|
var orgKeysb64 = $sessionStorage.orgKeys;
|
|
|
|
if (!orgKeysb64) {
|
|
|
|
orgKeysb64 = {};
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
2017-04-03 15:30:21 +02:00
|
|
|
var decOrgKey = _service.rsaDecrypt(encOrgKey, privateKey);
|
|
|
|
_orgKeys[orgId] = decOrgKey;
|
|
|
|
orgKeysb64[orgId] = forge.util.encode64(decOrgKey);
|
2017-03-12 02:46:33 +01:00
|
|
|
}
|
|
|
|
catch (e) {
|
2017-03-14 03:54:57 +01:00
|
|
|
_orgKeys = null;
|
2017-03-12 02:46:33 +01:00
|
|
|
console.log('Cannot set org key. Decryption failed.');
|
|
|
|
}
|
2017-03-07 05:54:06 +01:00
|
|
|
|
|
|
|
$sessionStorage.orgKeys = orgKeysb64;
|
|
|
|
};
|
|
|
|
|
2015-12-09 04:35:05 +01:00
|
|
|
_service.getKey = function (b64) {
|
|
|
|
if (b64 && b64 === true && _b64Key) {
|
|
|
|
return _b64Key;
|
|
|
|
}
|
|
|
|
else if (!b64 && _key) {
|
|
|
|
return _key;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($sessionStorage.key) {
|
2017-02-11 19:03:48 +01:00
|
|
|
_key = forge.util.decode64($sessionStorage.key);
|
2015-12-09 04:35:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (b64 && b64 === true) {
|
2017-02-11 19:03:48 +01:00
|
|
|
_b64Key = forge.util.encode64(_key);
|
2015-12-09 04:35:05 +01:00
|
|
|
return _b64Key;
|
|
|
|
}
|
|
|
|
|
|
|
|
return _key;
|
|
|
|
};
|
|
|
|
|
2016-12-09 04:21:46 +01:00
|
|
|
_service.getEncKey = function (key) {
|
|
|
|
key = key || _service.getKey();
|
2017-02-11 19:03:48 +01:00
|
|
|
|
|
|
|
var buffer = forge.util.createBuffer(key);
|
|
|
|
return buffer.getBytes(16);
|
2016-12-09 04:21:46 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
_service.getMacKey = function (key) {
|
|
|
|
key = key || _service.getKey();
|
2017-02-11 19:03:48 +01:00
|
|
|
|
|
|
|
var buffer = forge.util.createBuffer(key);
|
|
|
|
buffer.getBytes(16); // skip first half
|
|
|
|
return buffer.getBytes(16);
|
2016-12-09 04:21:46 +01:00
|
|
|
};
|
|
|
|
|
2017-02-21 04:21:14 +01:00
|
|
|
_service.getPrivateKey = function () {
|
|
|
|
if (_privateKey) {
|
|
|
|
return _privateKey;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($sessionStorage.privateKey) {
|
2017-02-28 06:18:11 +01:00
|
|
|
var privateKeyBytes = forge.util.decode64($sessionStorage.privateKey);
|
|
|
|
_privateKey = forge.pki.privateKeyFromAsn1(forge.asn1.fromDer(privateKeyBytes));
|
2017-02-21 04:21:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return _privateKey;
|
|
|
|
};
|
|
|
|
|
2017-02-28 06:18:11 +01:00
|
|
|
_service.getPublicKey = function () {
|
|
|
|
if (_publicKey) {
|
|
|
|
return _publicKey;
|
|
|
|
}
|
|
|
|
|
|
|
|
var privateKey = _service.getPrivateKey();
|
|
|
|
if (!privateKey) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
_publicKey = forge.pki.setRsaPublicKey(privateKey.n, privateKey.e);
|
|
|
|
return _publicKey;
|
|
|
|
};
|
|
|
|
|
2017-03-07 05:54:06 +01:00
|
|
|
_service.getOrgKeys = function () {
|
|
|
|
if (_orgKeys) {
|
|
|
|
return _orgKeys;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($sessionStorage.orgKeys) {
|
2017-03-10 04:28:14 +01:00
|
|
|
var orgKeys = {},
|
|
|
|
setKey = false;
|
|
|
|
|
2017-03-07 05:54:06 +01:00
|
|
|
for (var orgId in $sessionStorage.orgKeys) {
|
|
|
|
if ($sessionStorage.orgKeys.hasOwnProperty(orgId)) {
|
|
|
|
var orgKeyBytes = forge.util.decode64($sessionStorage.orgKeys[orgId]);
|
2017-03-10 04:28:14 +01:00
|
|
|
orgKeys[orgId] = orgKeyBytes;
|
|
|
|
setKey = true;
|
2017-03-07 05:54:06 +01:00
|
|
|
}
|
|
|
|
}
|
2017-03-10 04:28:14 +01:00
|
|
|
|
|
|
|
if (setKey) {
|
|
|
|
_orgKeys = orgKeys;
|
|
|
|
}
|
2017-03-07 05:54:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return _orgKeys;
|
|
|
|
};
|
|
|
|
|
|
|
|
_service.getOrgKey = function (orgId) {
|
|
|
|
var orgKeys = _service.getOrgKeys();
|
|
|
|
if (!orgKeys || !(orgId in orgKeys)) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
return orgKeys[orgId];
|
2017-03-22 04:07:38 +01:00
|
|
|
};
|
2017-03-07 05:54:06 +01:00
|
|
|
|
2015-12-09 04:35:05 +01:00
|
|
|
_service.clearKey = function () {
|
2017-02-11 19:03:48 +01:00
|
|
|
_key = _b64Key = null;
|
2015-12-09 04:35:05 +01:00
|
|
|
delete $sessionStorage.key;
|
|
|
|
};
|
|
|
|
|
2017-02-28 06:18:11 +01:00
|
|
|
_service.clearKeyPair = function () {
|
2017-02-21 04:21:14 +01:00
|
|
|
_privateKey = null;
|
2017-02-28 06:18:11 +01:00
|
|
|
_publicKey = null;
|
2017-02-21 04:21:14 +01:00
|
|
|
delete $sessionStorage.privateKey;
|
|
|
|
};
|
|
|
|
|
2017-03-07 05:54:06 +01:00
|
|
|
_service.clearOrgKeys = function () {
|
2017-03-14 03:54:57 +01:00
|
|
|
_orgKeys = null;
|
2017-03-07 05:54:06 +01:00
|
|
|
delete $sessionStorage.orgKeys;
|
|
|
|
};
|
|
|
|
|
2017-04-11 16:52:16 +02:00
|
|
|
_service.clearOrgKey = function (orgId) {
|
|
|
|
if (_orgKeys.hasOwnProperty(orgId)) {
|
|
|
|
delete _orgKeys[orgId];
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($sessionStorage.orgKeys.hasOwnProperty(orgId)) {
|
|
|
|
delete $sessionStorage.orgKeys[orgId];
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-02-21 04:21:14 +01:00
|
|
|
_service.clearKeys = function () {
|
|
|
|
_service.clearKey();
|
2017-02-28 06:18:11 +01:00
|
|
|
_service.clearKeyPair();
|
2017-03-07 05:54:06 +01:00
|
|
|
_service.clearOrgKeys();
|
2017-02-21 04:21:14 +01:00
|
|
|
};
|
|
|
|
|
2015-12-09 04:35:05 +01:00
|
|
|
_service.makeKey = function (password, salt, b64) {
|
2017-02-16 01:03:56 +01:00
|
|
|
var key = forge.pbkdf2(forge.util.encodeUtf8(password), forge.util.encodeUtf8(salt),
|
|
|
|
5000, 256 / 8, 'sha256');
|
2015-12-09 04:35:05 +01:00
|
|
|
|
|
|
|
if (b64 && b64 === true) {
|
2017-02-11 19:03:48 +01:00
|
|
|
return forge.util.encode64(key);
|
2015-12-09 04:35:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return key;
|
|
|
|
};
|
|
|
|
|
2017-04-14 00:18:32 +02:00
|
|
|
_service.makeKeyPair = function (key) {
|
|
|
|
var deferred = $q.defer();
|
|
|
|
|
2017-02-21 04:21:14 +01:00
|
|
|
forge.pki.rsa.generateKeyPair({ bits: 2048, workers: 2 }, function (error, keypair) {
|
|
|
|
if (error) {
|
2017-04-14 00:18:32 +02:00
|
|
|
deferred.reject(error);
|
2017-02-21 04:21:14 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-03-11 02:49:50 +01:00
|
|
|
var privateKeyAsn1 = forge.pki.privateKeyToAsn1(keypair.privateKey);
|
|
|
|
var privateKeyPkcs8 = forge.pki.wrapRsaPrivateKey(privateKeyAsn1);
|
|
|
|
var privateKeyBytes = forge.asn1.toDer(privateKeyPkcs8).getBytes();
|
2017-04-14 00:18:32 +02:00
|
|
|
var privateKeyEncCt = _service.encrypt(privateKeyBytes, key, 'raw');
|
2017-02-21 04:21:14 +01:00
|
|
|
|
2017-03-11 02:49:50 +01:00
|
|
|
var publicKeyAsn1 = forge.pki.publicKeyToAsn1(keypair.publicKey);
|
|
|
|
var publicKeyBytes = forge.asn1.toDer(publicKeyAsn1).getBytes();
|
2017-02-21 04:21:14 +01:00
|
|
|
|
2017-04-14 00:18:32 +02:00
|
|
|
deferred.resolve({
|
|
|
|
publicKey: forge.util.encode64(publicKeyBytes),
|
|
|
|
privateKeyEnc: privateKeyEncCt
|
|
|
|
});
|
2017-02-21 04:21:14 +01:00
|
|
|
});
|
2017-04-14 00:18:32 +02:00
|
|
|
|
|
|
|
return deferred.promise;
|
2017-02-21 04:21:14 +01:00
|
|
|
};
|
|
|
|
|
2017-02-28 06:18:11 +01:00
|
|
|
_service.makeShareKey = function () {
|
2017-03-03 06:07:31 +01:00
|
|
|
return _service.rsaEncrypt(forge.random.getBytesSync(32));
|
2017-02-28 06:18:11 +01:00
|
|
|
};
|
|
|
|
|
2015-12-09 04:35:05 +01:00
|
|
|
_service.hashPassword = function (password, key) {
|
|
|
|
if (!key) {
|
|
|
|
key = _service.getKey();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!password || !key) {
|
|
|
|
throw 'Invalid parameters.';
|
|
|
|
}
|
|
|
|
|
2017-02-16 01:03:56 +01:00
|
|
|
var hashBits = forge.pbkdf2(key, forge.util.encodeUtf8(password), 1, 256 / 8, 'sha256');
|
2017-02-11 19:03:48 +01:00
|
|
|
return forge.util.encode64(hashBits);
|
2016-12-09 04:21:46 +01:00
|
|
|
};
|
|
|
|
|
2017-02-21 06:29:15 +01:00
|
|
|
_service.encrypt = function (plainValue, key, plainValueEncoding) {
|
2015-12-09 04:35:05 +01:00
|
|
|
if (!_service.getKey() && !key) {
|
|
|
|
throw 'Encryption key unavailable.';
|
|
|
|
}
|
|
|
|
|
2016-12-09 04:21:46 +01:00
|
|
|
// TODO: Turn on whenever ready to support encrypt-then-mac
|
2017-04-07 05:00:33 +02:00
|
|
|
var encKey, encType;
|
2016-12-09 04:21:46 +01:00
|
|
|
if (false) {
|
|
|
|
encKey = _service.getEncKey(key);
|
2017-04-11 00:55:18 +02:00
|
|
|
encType = constants.encType.AesCbc128_HmacSha256_B64;
|
2016-12-09 04:21:46 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
encKey = key || _service.getKey();
|
2017-04-11 00:55:18 +02:00
|
|
|
encType = constants.encType.AesCbc256_B64;
|
2015-12-09 04:35:05 +01:00
|
|
|
}
|
|
|
|
|
2017-02-21 06:29:15 +01:00
|
|
|
plainValueEncoding = plainValueEncoding || 'utf8';
|
|
|
|
var buffer = forge.util.createBuffer(plainValue, plainValueEncoding);
|
2017-02-11 19:03:48 +01:00
|
|
|
var ivBytes = forge.random.getBytesSync(16);
|
|
|
|
var cipher = forge.cipher.createCipher('AES-CBC', encKey);
|
|
|
|
cipher.start({ iv: ivBytes });
|
|
|
|
cipher.update(buffer);
|
|
|
|
cipher.finish();
|
2015-12-09 04:35:05 +01:00
|
|
|
|
2017-02-11 19:03:48 +01:00
|
|
|
var iv = forge.util.encode64(ivBytes);
|
|
|
|
var ctBytes = cipher.output.getBytes();
|
|
|
|
var ct = forge.util.encode64(ctBytes);
|
2016-12-09 04:21:46 +01:00
|
|
|
var cipherString = iv + '|' + ct;
|
|
|
|
|
2017-04-11 00:55:18 +02:00
|
|
|
if (encType === constants.encType.AesCbc128_HmacSha256_B64 ||
|
|
|
|
encType === constants.encType.AesCbc256_HmacSha256_B64) {
|
2017-02-11 19:03:48 +01:00
|
|
|
var mac = computeMac(ctBytes, ivBytes);
|
2016-12-09 04:21:46 +01:00
|
|
|
cipherString = cipherString + '|' + mac;
|
|
|
|
}
|
|
|
|
|
2017-04-07 15:26:43 +02:00
|
|
|
// TODO: Turn on whenever ready to support encryption type headers
|
|
|
|
return /*encType + '.' +*/ cipherString;
|
2015-12-09 04:35:05 +01:00
|
|
|
};
|
|
|
|
|
2017-02-28 06:18:11 +01:00
|
|
|
_service.rsaEncrypt = function (plainValue, publicKey) {
|
|
|
|
publicKey = publicKey || _service.getPublicKey();
|
|
|
|
if (!publicKey) {
|
|
|
|
throw 'Public key unavailable.';
|
|
|
|
}
|
|
|
|
|
2017-03-05 02:41:45 +01:00
|
|
|
if (typeof publicKey === 'string') {
|
|
|
|
var publicKeyBytes = forge.util.decode64(publicKey);
|
|
|
|
publicKey = forge.pki.publicKeyFromAsn1(forge.asn1.fromDer(publicKeyBytes));
|
|
|
|
}
|
|
|
|
|
2017-02-28 06:18:11 +01:00
|
|
|
var encryptedBytes = publicKey.encrypt(plainValue, 'RSA-OAEP', {
|
|
|
|
md: forge.md.sha256.create()
|
|
|
|
});
|
2017-04-11 00:55:18 +02:00
|
|
|
return constants.encType.RsaOaep_Sha256_B64 + '.' + forge.util.encode64(encryptedBytes);
|
2017-03-01 04:53:19 +01:00
|
|
|
};
|
2017-02-28 06:18:11 +01:00
|
|
|
|
2017-02-21 06:29:15 +01:00
|
|
|
_service.decrypt = function (encValue, key, outputEncoding) {
|
2017-04-07 05:00:33 +02:00
|
|
|
var headerPieces = encValue.split('.'),
|
|
|
|
encType,
|
|
|
|
encPieces,
|
|
|
|
encKey,
|
|
|
|
doMacCheck = false;
|
|
|
|
|
|
|
|
if (headerPieces.length === 2) {
|
|
|
|
try {
|
|
|
|
encType = parseInt(headerPieces[0]);
|
|
|
|
encPieces = headerPieces[1].split('|');
|
|
|
|
}
|
|
|
|
catch (e) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2017-04-11 00:55:18 +02:00
|
|
|
encType = constants.encType.AesCbc256_B64;
|
2017-04-07 05:00:33 +02:00
|
|
|
encPieces = encValue.split('|');
|
2015-12-09 04:35:05 +01:00
|
|
|
}
|
|
|
|
|
2017-04-07 05:00:33 +02:00
|
|
|
switch (encType) {
|
2017-04-11 00:55:18 +02:00
|
|
|
case constants.encType.AesCbc128_HmacSha256_B64:
|
2017-04-07 05:00:33 +02:00
|
|
|
if (encPieces.length !== 3) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
doMacCheck = true;
|
|
|
|
encKey = _service.getEncKey(key);
|
|
|
|
break;
|
2017-04-11 00:55:18 +02:00
|
|
|
case constants.encType.AesCbc256_HmacSha256_B64:
|
2017-04-07 05:00:33 +02:00
|
|
|
if (encPieces.length !== 3) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
doMacCheck = true;
|
|
|
|
encKey = _service.getEncKey(key);
|
|
|
|
break;
|
2017-04-11 00:55:18 +02:00
|
|
|
case constants.encType.AesCbc256_B64:
|
2017-04-07 05:00:33 +02:00
|
|
|
if (encPieces.length !== 2) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
doMacCheck = false;
|
|
|
|
encKey = key || _service.getKey();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!encKey) {
|
|
|
|
throw 'Encryption key unavailable.';
|
2015-12-09 04:35:05 +01:00
|
|
|
}
|
|
|
|
|
2017-02-11 19:03:48 +01:00
|
|
|
var ivBytes = forge.util.decode64(encPieces[0]);
|
|
|
|
var ctBytes = forge.util.decode64(encPieces[1]);
|
2015-12-09 04:35:05 +01:00
|
|
|
|
2017-04-07 05:00:33 +02:00
|
|
|
if (doMacCheck) {
|
|
|
|
var computedMac = computeMac(ctBytes, ivBytes);
|
2016-12-09 04:21:46 +01:00
|
|
|
if (computedMac !== encPieces[2]) {
|
|
|
|
console.error('MAC failed.');
|
2017-04-07 05:00:33 +02:00
|
|
|
return null;
|
2016-12-09 04:21:46 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-11 19:03:48 +01:00
|
|
|
var ctBuffer = forge.util.createBuffer(ctBytes);
|
2017-02-21 06:29:15 +01:00
|
|
|
var decipher = forge.cipher.createDecipher('AES-CBC', encKey);
|
2017-02-11 19:03:48 +01:00
|
|
|
decipher.start({ iv: ivBytes });
|
|
|
|
decipher.update(ctBuffer);
|
|
|
|
decipher.finish();
|
2015-12-09 04:35:05 +01:00
|
|
|
|
2017-02-21 04:21:14 +01:00
|
|
|
outputEncoding = outputEncoding || 'utf8';
|
|
|
|
if (outputEncoding === 'utf8') {
|
|
|
|
return decipher.output.toString('utf8');
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return decipher.output.getBytes();
|
|
|
|
}
|
2017-02-11 19:03:48 +01:00
|
|
|
};
|
2016-12-09 04:21:46 +01:00
|
|
|
|
2017-02-28 06:18:11 +01:00
|
|
|
_service.rsaDecrypt = function (encValue, privateKey) {
|
|
|
|
privateKey = privateKey || _service.getPrivateKey();
|
|
|
|
if (!privateKey) {
|
|
|
|
throw 'Private key unavailable.';
|
|
|
|
}
|
|
|
|
|
2017-04-07 05:00:33 +02:00
|
|
|
var headerPieces = encValue.split('.'),
|
|
|
|
encType,
|
|
|
|
encPiece;
|
|
|
|
|
|
|
|
if (headerPieces.length === 1) {
|
2017-04-11 00:55:18 +02:00
|
|
|
encType = constants.encType.RsaOaep_Sha256_B64;
|
2017-04-07 05:00:33 +02:00
|
|
|
encPiece = headerPieces[0];
|
|
|
|
}
|
|
|
|
else if (headerPieces.length === 2) {
|
|
|
|
try {
|
|
|
|
encType = parseInt(headerPieces[0]);
|
|
|
|
encPiece = headerPieces[1];
|
|
|
|
}
|
|
|
|
catch (e) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-11 00:55:18 +02:00
|
|
|
if (encType !== constants.encType.RsaOaep_Sha256_B64) {
|
2017-04-07 05:00:33 +02:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
var ctBytes = forge.util.decode64(encPiece);
|
2017-02-28 06:18:11 +01:00
|
|
|
var decBytes = privateKey.decrypt(ctBytes, 'RSA-OAEP', {
|
|
|
|
md: forge.md.sha256.create()
|
|
|
|
});
|
|
|
|
|
|
|
|
return decBytes;
|
2017-03-01 04:53:19 +01:00
|
|
|
};
|
2017-02-28 06:18:11 +01:00
|
|
|
|
2017-02-11 19:03:48 +01:00
|
|
|
function computeMac(ct, iv, macKey) {
|
|
|
|
var hmac = forge.hmac.create();
|
|
|
|
hmac.start('sha256', macKey || _service.getMacKey());
|
|
|
|
hmac.update(iv + ct);
|
|
|
|
var mac = hmac.digest();
|
|
|
|
return forge.util.encode64(mac.getBytes());
|
2016-12-09 04:21:46 +01:00
|
|
|
}
|
|
|
|
|
2015-12-09 04:35:05 +01:00
|
|
|
return _service;
|
|
|
|
});
|