mirror of
https://github.com/bitwarden/web
synced 2025-12-06 00:03:28 +00:00
600 lines
22 KiB
JavaScript
600 lines
22 KiB
JavaScript
/**
|
|
* @file Web Cryptography API shim
|
|
* @author Artem S Vybornov <vybornov@gmail.com>
|
|
* @license MIT
|
|
*/
|
|
!function (global) {
|
|
'use strict';
|
|
|
|
// We are using an angular promise polyfill which is loaded after this script
|
|
//if (typeof Promise !== 'function')
|
|
// throw "Promise support required";
|
|
|
|
var _crypto = global.crypto || global.msCrypto;
|
|
if (!_crypto) return;
|
|
|
|
var _subtle = _crypto.subtle || _crypto.webkitSubtle;
|
|
if (!_subtle) return;
|
|
|
|
var _Crypto = global.Crypto || _crypto.constructor || Object,
|
|
_SubtleCrypto = global.SubtleCrypto || _subtle.constructor || Object,
|
|
_CryptoKey = global.CryptoKey || global.Key || Object;
|
|
|
|
var isIE = !!global.msCrypto,
|
|
// ref PR: https://github.com/vibornoff/webcrypto-shim/pull/15
|
|
isWebkit = !_crypto.subtle && !!_crypto.webkitSubtle;
|
|
if (!isIE && !isWebkit) return;
|
|
|
|
function s2a(s) {
|
|
return btoa(s).replace(/\=+$/, '').replace(/\+/g, '-').replace(/\//g, '_');
|
|
}
|
|
|
|
function a2s(s) {
|
|
s += '===', s = s.slice(0, -s.length % 4);
|
|
return atob(s.replace(/-/g, '+').replace(/_/g, '/'));
|
|
}
|
|
|
|
function s2b(s) {
|
|
var b = new Uint8Array(s.length);
|
|
for (var i = 0; i < s.length; i++) b[i] = s.charCodeAt(i);
|
|
return b;
|
|
}
|
|
|
|
function b2s(b) {
|
|
if (b instanceof ArrayBuffer) b = new Uint8Array(b);
|
|
return String.fromCharCode.apply(String, b);
|
|
}
|
|
|
|
function alg(a) {
|
|
var r = { 'name': (a.name || a || '').toUpperCase().replace('V', 'v') };
|
|
switch (r.name) {
|
|
case 'SHA-1':
|
|
case 'SHA-256':
|
|
case 'SHA-384':
|
|
case 'SHA-512':
|
|
break;
|
|
case 'AES-CBC':
|
|
case 'AES-GCM':
|
|
case 'AES-KW':
|
|
if (a.length) r['length'] = a.length;
|
|
break;
|
|
case 'HMAC':
|
|
if (a.hash) r['hash'] = alg(a.hash);
|
|
if (a.length) r['length'] = a.length;
|
|
break;
|
|
case 'RSAES-PKCS1-v1_5':
|
|
if (a.publicExponent) r['publicExponent'] = new Uint8Array(a.publicExponent);
|
|
if (a.modulusLength) r['modulusLength'] = a.modulusLength;
|
|
break;
|
|
case 'RSASSA-PKCS1-v1_5':
|
|
case 'RSA-OAEP':
|
|
if (a.hash) r['hash'] = alg(a.hash);
|
|
if (a.publicExponent) r['publicExponent'] = new Uint8Array(a.publicExponent);
|
|
if (a.modulusLength) r['modulusLength'] = a.modulusLength;
|
|
break;
|
|
default:
|
|
throw new SyntaxError("Bad algorithm name");
|
|
}
|
|
return r;
|
|
};
|
|
|
|
function jwkAlg(a) {
|
|
return {
|
|
'HMAC': {
|
|
'SHA-1': 'HS1',
|
|
'SHA-256': 'HS256',
|
|
'SHA-384': 'HS384',
|
|
'SHA-512': 'HS512',
|
|
},
|
|
'RSASSA-PKCS1-v1_5': {
|
|
'SHA-1': 'RS1',
|
|
'SHA-256': 'RS256',
|
|
'SHA-384': 'RS384',
|
|
'SHA-512': 'RS512',
|
|
},
|
|
'RSAES-PKCS1-v1_5': {
|
|
'': 'RSA1_5',
|
|
},
|
|
'RSA-OAEP': {
|
|
'SHA-1': 'RSA-OAEP',
|
|
'SHA-256': 'RSA-OAEP-256',
|
|
},
|
|
'AES-KW': {
|
|
'128': 'A128KW',
|
|
'192': 'A192KW',
|
|
'256': 'A256KW',
|
|
},
|
|
'AES-GCM': {
|
|
'128': 'A128GCM',
|
|
'192': 'A192GCM',
|
|
'256': 'A256GCM',
|
|
},
|
|
'AES-CBC': {
|
|
'128': 'A128CBC',
|
|
'192': 'A192CBC',
|
|
'256': 'A256CBC',
|
|
},
|
|
}[a.name][(a.hash || {}).name || a.length || ''];
|
|
}
|
|
|
|
function b2jwk(k) {
|
|
if (k instanceof ArrayBuffer || k instanceof Uint8Array) k = JSON.parse(decodeURIComponent(escape(b2s(k))));
|
|
var jwk = { 'kty': k.kty, 'alg': k.alg, 'ext': k.ext || k.extractable };
|
|
switch (jwk.kty) {
|
|
case 'oct':
|
|
jwk.k = k.k;
|
|
case 'RSA':
|
|
['n', 'e', 'd', 'p', 'q', 'dp', 'dq', 'qi', 'oth'].forEach(function (x) { if (x in k) jwk[x] = k[x] });
|
|
break;
|
|
default:
|
|
throw new TypeError("Unsupported key type");
|
|
}
|
|
return jwk;
|
|
}
|
|
|
|
function jwk2b(k) {
|
|
var jwk = b2jwk(k);
|
|
if (isIE) jwk['extractable'] = jwk.ext, delete jwk.ext;
|
|
return s2b(unescape(encodeURIComponent(JSON.stringify(jwk)))).buffer;
|
|
}
|
|
|
|
function pkcs2jwk(k) {
|
|
var info = b2der(k), prv = false;
|
|
if (info.length > 2) prv = true, info.shift(); // remove version from PKCS#8 PrivateKeyInfo structure
|
|
var jwk = { 'ext': true };
|
|
switch (info[0][0]) {
|
|
case '1.2.840.113549.1.1.1':
|
|
var rsaComp = ['n', 'e', 'd', 'p', 'q', 'dp', 'dq', 'qi'],
|
|
rsaKey = b2der(info[1]);
|
|
if (prv) rsaKey.shift(); // remove version from PKCS#1 RSAPrivateKey structure
|
|
for (var i = 0; i < rsaKey.length; i++) {
|
|
if (!rsaKey[i][0]) rsaKey[i] = rsaKey[i].subarray(1);
|
|
jwk[rsaComp[i]] = s2a(b2s(rsaKey[i]));
|
|
}
|
|
jwk['kty'] = 'RSA';
|
|
break;
|
|
default:
|
|
throw new TypeError("Unsupported key type");
|
|
}
|
|
return jwk;
|
|
}
|
|
|
|
function jwk2pkcs(k) {
|
|
var key, info = [['', null]], prv = false;
|
|
switch (k.kty) {
|
|
case 'RSA':
|
|
var rsaComp = ['n', 'e', 'd', 'p', 'q', 'dp', 'dq', 'qi'],
|
|
rsaKey = [];
|
|
for (var i = 0; i < rsaComp.length; i++) {
|
|
if (!(rsaComp[i] in k)) break;
|
|
var b = rsaKey[i] = s2b(a2s(k[rsaComp[i]]));
|
|
if (b[0] & 0x80) rsaKey[i] = new Uint8Array(b.length + 1), rsaKey[i].set(b, 1);
|
|
}
|
|
if (rsaKey.length > 2) prv = true, rsaKey.unshift(new Uint8Array([0])); // add version to PKCS#1 RSAPrivateKey structure
|
|
info[0][0] = '1.2.840.113549.1.1.1';
|
|
key = rsaKey;
|
|
break;
|
|
default:
|
|
throw new TypeError("Unsupported key type");
|
|
}
|
|
info.push(new Uint8Array(der2b(key)).buffer);
|
|
if (!prv) info[1] = { 'tag': 0x03, 'value': info[1] };
|
|
else info.unshift(new Uint8Array([0])); // add version to PKCS#8 PrivateKeyInfo structure
|
|
return new Uint8Array(der2b(info)).buffer;
|
|
}
|
|
|
|
var oid2str = { 'KoZIhvcNAQEB': '1.2.840.113549.1.1.1' },
|
|
str2oid = { '1.2.840.113549.1.1.1': 'KoZIhvcNAQEB' };
|
|
|
|
function b2der(buf, ctx) {
|
|
if (buf instanceof ArrayBuffer) buf = new Uint8Array(buf);
|
|
if (!ctx) ctx = { pos: 0, end: buf.length };
|
|
|
|
if (ctx.end - ctx.pos < 2 || ctx.end > buf.length) throw new RangeError("Malformed DER");
|
|
|
|
var tag = buf[ctx.pos++],
|
|
len = buf[ctx.pos++];
|
|
|
|
if (len >= 0x80) {
|
|
len &= 0x7f;
|
|
if (ctx.end - ctx.pos < len) throw new RangeError("Malformed DER");
|
|
for (var xlen = 0; len--;) xlen <<= 8, xlen |= buf[ctx.pos++];
|
|
len = xlen;
|
|
}
|
|
|
|
if (ctx.end - ctx.pos < len) throw new RangeError("Malformed DER");
|
|
|
|
var rv;
|
|
|
|
switch (tag) {
|
|
case 0x02: // Universal Primitive INTEGER
|
|
rv = buf.subarray(ctx.pos, ctx.pos += len);
|
|
break;
|
|
case 0x03: // Universal Primitive BIT STRING
|
|
if (buf[ctx.pos++]) throw new Error("Unsupported bit string");
|
|
len--;
|
|
case 0x04: // Universal Primitive OCTET STRING
|
|
rv = new Uint8Array(buf.subarray(ctx.pos, ctx.pos += len)).buffer;
|
|
break;
|
|
case 0x05: // Universal Primitive NULL
|
|
rv = null;
|
|
break;
|
|
case 0x06: // Universal Primitive OBJECT IDENTIFIER
|
|
var oid = btoa(b2s(buf.subarray(ctx.pos, ctx.pos += len)));
|
|
if (!(oid in oid2str)) throw new Error("Unsupported OBJECT ID " + oid);
|
|
rv = oid2str[oid];
|
|
break;
|
|
case 0x30: // Universal Constructed SEQUENCE
|
|
rv = [];
|
|
for (var end = ctx.pos + len; ctx.pos < end;) rv.push(b2der(buf, ctx));
|
|
break;
|
|
default:
|
|
throw new Error("Unsupported DER tag 0x" + tag.toString(16));
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
function der2b(val, buf) {
|
|
if (!buf) buf = [];
|
|
|
|
var tag = 0, len = 0,
|
|
pos = buf.length + 2;
|
|
|
|
buf.push(0, 0); // placeholder
|
|
|
|
if (val instanceof Uint8Array) { // Universal Primitive INTEGER
|
|
tag = 0x02, len = val.length;
|
|
for (var i = 0; i < len; i++) buf.push(val[i]);
|
|
}
|
|
else if (val instanceof ArrayBuffer) { // Universal Primitive OCTET STRING
|
|
tag = 0x04, len = val.byteLength, val = new Uint8Array(val);
|
|
for (var i = 0; i < len; i++) buf.push(val[i]);
|
|
}
|
|
else if (val === null) { // Universal Primitive NULL
|
|
tag = 0x05, len = 0;
|
|
}
|
|
else if (typeof val === 'string' && val in str2oid) { // Universal Primitive OBJECT IDENTIFIER
|
|
var oid = s2b(atob(str2oid[val]));
|
|
tag = 0x06, len = oid.length;
|
|
for (var i = 0; i < len; i++) buf.push(oid[i]);
|
|
}
|
|
else if (val instanceof Array) { // Universal Constructed SEQUENCE
|
|
for (var i = 0; i < val.length; i++) der2b(val[i], buf);
|
|
tag = 0x30, len = buf.length - pos;
|
|
}
|
|
else if (typeof val === 'object' && val.tag === 0x03 && val.value instanceof ArrayBuffer) { // Tag hint
|
|
val = new Uint8Array(val.value), tag = 0x03, len = val.byteLength;
|
|
buf.push(0); for (var i = 0; i < len; i++) buf.push(val[i]);
|
|
len++;
|
|
}
|
|
else {
|
|
throw new Error("Unsupported DER value " + val);
|
|
}
|
|
|
|
if (len >= 0x80) {
|
|
var xlen = len, len = 4;
|
|
buf.splice(pos, 0, (xlen >> 24) & 0xff, (xlen >> 16) & 0xff, (xlen >> 8) & 0xff, xlen & 0xff);
|
|
while (len > 1 && !(xlen >> 24)) xlen <<= 8, len--;
|
|
if (len < 4) buf.splice(pos, 4 - len);
|
|
len |= 0x80;
|
|
}
|
|
|
|
buf.splice(pos - 2, 2, tag, len);
|
|
|
|
return buf;
|
|
}
|
|
|
|
function CryptoKey(key, alg, ext, use) {
|
|
Object.defineProperties(this, {
|
|
_key: {
|
|
value: key
|
|
},
|
|
type: {
|
|
value: key.type,
|
|
enumerable: true,
|
|
},
|
|
extractable: {
|
|
value: (ext === undefined) ? key.extractable : ext,
|
|
enumerable: true,
|
|
},
|
|
algorithm: {
|
|
value: (alg === undefined) ? key.algorithm : alg,
|
|
enumerable: true,
|
|
},
|
|
usages: {
|
|
value: (use === undefined) ? key.usages : use,
|
|
enumerable: true,
|
|
},
|
|
});
|
|
}
|
|
|
|
function isPubKeyUse(u) {
|
|
return u === 'verify' || u === 'encrypt' || u === 'wrapKey';
|
|
}
|
|
|
|
function isPrvKeyUse(u) {
|
|
return u === 'sign' || u === 'decrypt' || u === 'unwrapKey';
|
|
}
|
|
|
|
['generateKey', 'importKey', 'unwrapKey']
|
|
.forEach(function (m) {
|
|
var _fn = _subtle[m];
|
|
|
|
_subtle[m] = function (a, b, c) {
|
|
var args = [].slice.call(arguments),
|
|
ka, kx, ku;
|
|
|
|
switch (m) {
|
|
case 'generateKey':
|
|
ka = alg(a), kx = b, ku = c;
|
|
break;
|
|
case 'importKey':
|
|
ka = alg(c), kx = args[3], ku = args[4];
|
|
if (a === 'jwk') {
|
|
b = b2jwk(b);
|
|
if (!b.alg) b.alg = jwkAlg(ka);
|
|
if (!b.key_ops) b.key_ops = (b.kty !== 'oct') ? ('d' in b) ? ku.filter(isPrvKeyUse) : ku.filter(isPubKeyUse) : ku.slice();
|
|
args[1] = jwk2b(b);
|
|
}
|
|
break;
|
|
case 'unwrapKey':
|
|
ka = args[4], kx = args[5], ku = args[6];
|
|
args[2] = c._key;
|
|
break;
|
|
}
|
|
|
|
if (m === 'generateKey' && ka.name === 'HMAC' && ka.hash) {
|
|
ka.length = ka.length || { 'SHA-1': 512, 'SHA-256': 512, 'SHA-384': 1024, 'SHA-512': 1024 }[ka.hash.name];
|
|
return _subtle.importKey('raw', _crypto.getRandomValues(new Uint8Array((ka.length + 7) >> 3)), ka, kx, ku);
|
|
}
|
|
|
|
if (isWebkit && m === 'generateKey' && ka.name === 'RSASSA-PKCS1-v1_5' && (!ka.modulusLength || ka.modulusLength >= 2048)) {
|
|
a = alg(a), a.name = 'RSAES-PKCS1-v1_5', delete a.hash;
|
|
return _subtle.generateKey(a, true, ['encrypt', 'decrypt'])
|
|
.then(function (k) {
|
|
return Promise.all([
|
|
_subtle.exportKey('jwk', k.publicKey),
|
|
_subtle.exportKey('jwk', k.privateKey),
|
|
]);
|
|
})
|
|
.then(function (keys) {
|
|
keys[0].alg = keys[1].alg = jwkAlg(ka);
|
|
keys[0].key_ops = ku.filter(isPubKeyUse), keys[1].key_ops = ku.filter(isPrvKeyUse);
|
|
return Promise.all([
|
|
_subtle.importKey('jwk', keys[0], ka, true, keys[0].key_ops),
|
|
_subtle.importKey('jwk', keys[1], ka, kx, keys[1].key_ops),
|
|
]);
|
|
})
|
|
.then(function (keys) {
|
|
return {
|
|
publicKey: keys[0],
|
|
privateKey: keys[1],
|
|
};
|
|
});
|
|
}
|
|
|
|
if ((isWebkit || (isIE && (ka.hash || {}).name === 'SHA-1'))
|
|
&& m === 'importKey' && a === 'jwk' && ka.name === 'HMAC' && b.kty === 'oct') {
|
|
return _subtle.importKey('raw', s2b(a2s(b.k)), c, args[3], args[4]);
|
|
}
|
|
|
|
if (isWebkit && m === 'importKey' && (a === 'spki' || a === 'pkcs8')) {
|
|
return _subtle.importKey('jwk', pkcs2jwk(b), c, args[3], args[4]);
|
|
}
|
|
|
|
if (isIE && m === 'unwrapKey') {
|
|
return _subtle.decrypt(args[3], c, b)
|
|
.then(function (k) {
|
|
return _subtle.importKey(a, k, args[4], args[5], args[6]);
|
|
});
|
|
}
|
|
|
|
var op;
|
|
try {
|
|
op = _fn.apply(_subtle, args);
|
|
}
|
|
catch (e) {
|
|
return Promise.reject(e);
|
|
}
|
|
|
|
if (isIE) {
|
|
op = new Promise(function (res, rej) {
|
|
op.onabort =
|
|
op.onerror = function (e) { rej(e) };
|
|
op.oncomplete = function (r) { res(r.target.result) };
|
|
});
|
|
}
|
|
|
|
op = op.then(function (k) {
|
|
if (ka.name === 'HMAC') {
|
|
if (!ka.length) ka.length = 8 * k.algorithm.length;
|
|
}
|
|
if (ka.name.search('RSA') == 0) {
|
|
if (!ka.modulusLength) ka.modulusLength = (k.publicKey || k).algorithm.modulusLength;
|
|
if (!ka.publicExponent) ka.publicExponent = (k.publicKey || k).algorithm.publicExponent;
|
|
}
|
|
if (k.publicKey && k.privateKey) {
|
|
k = {
|
|
publicKey: new CryptoKey(k.publicKey, ka, kx, ku.filter(isPubKeyUse)),
|
|
privateKey: new CryptoKey(k.privateKey, ka, kx, ku.filter(isPrvKeyUse)),
|
|
};
|
|
}
|
|
else {
|
|
k = new CryptoKey(k, ka, kx, ku);
|
|
}
|
|
return k;
|
|
});
|
|
|
|
return op;
|
|
}
|
|
});
|
|
|
|
['exportKey', 'wrapKey']
|
|
.forEach(function (m) {
|
|
var _fn = _subtle[m];
|
|
|
|
_subtle[m] = function (a, b, c) {
|
|
var args = [].slice.call(arguments);
|
|
|
|
switch (m) {
|
|
case 'exportKey':
|
|
args[1] = b._key;
|
|
break;
|
|
case 'wrapKey':
|
|
args[1] = b._key, args[2] = c._key;
|
|
break;
|
|
}
|
|
|
|
if ((isWebkit || (isIE && (b.algorithm.hash || {}).name === 'SHA-1'))
|
|
&& m === 'exportKey' && a === 'jwk' && b.algorithm.name === 'HMAC') {
|
|
args[0] = 'raw';
|
|
}
|
|
|
|
if (isWebkit && m === 'exportKey' && (a === 'spki' || a === 'pkcs8')) {
|
|
args[0] = 'jwk';
|
|
}
|
|
|
|
if (isIE && m === 'wrapKey') {
|
|
return _subtle.exportKey(a, b)
|
|
.then(function (k) {
|
|
if (a === 'jwk') k = s2b(unescape(encodeURIComponent(JSON.stringify(b2jwk(k)))));
|
|
return _subtle.encrypt(args[3], c, k);
|
|
});
|
|
}
|
|
|
|
var op;
|
|
try {
|
|
op = _fn.apply(_subtle, args);
|
|
}
|
|
catch (e) {
|
|
return Promise.reject(e);
|
|
}
|
|
|
|
if (isIE) {
|
|
op = new Promise(function (res, rej) {
|
|
op.onabort =
|
|
op.onerror = function (e) { rej(e) };
|
|
op.oncomplete = function (r) { res(r.target.result) };
|
|
});
|
|
}
|
|
|
|
if (m === 'exportKey' && a === 'jwk') {
|
|
op = op.then(function (k) {
|
|
if ((isWebkit || (isIE && (b.algorithm.hash || {}).name === 'SHA-1'))
|
|
&& b.algorithm.name === 'HMAC') {
|
|
return { 'kty': 'oct', 'alg': jwkAlg(b.algorithm), 'key_ops': b.usages.slice(), 'ext': true, 'k': s2a(b2s(k)) };
|
|
}
|
|
k = b2jwk(k);
|
|
if (!k.alg) k['alg'] = jwkAlg(b.algorithm);
|
|
if (!k.key_ops) k['key_ops'] = (b.type === 'public') ? b.usages.filter(isPubKeyUse) : (b.type === 'private') ? b.usages.filter(isPrvKeyUse) : b.usages.slice();
|
|
return k;
|
|
});
|
|
}
|
|
|
|
if (isWebkit && m === 'exportKey' && (a === 'spki' || a === 'pkcs8')) {
|
|
op = op.then(function (k) {
|
|
k = jwk2pkcs(b2jwk(k));
|
|
return k;
|
|
});
|
|
}
|
|
|
|
return op;
|
|
}
|
|
});
|
|
|
|
['encrypt', 'decrypt', 'sign', 'verify']
|
|
.forEach(function (m) {
|
|
var _fn = _subtle[m];
|
|
|
|
_subtle[m] = function (a, b, c, d) {
|
|
if (isIE && (!c.byteLength || (d && !d.byteLength)))
|
|
throw new Error("Empy input is not allowed");
|
|
|
|
var args = [].slice.call(arguments),
|
|
ka = alg(a);
|
|
|
|
if (isIE && m === 'decrypt' && ka.name === 'AES-GCM') {
|
|
var tl = a.tagLength >> 3;
|
|
args[2] = (c.buffer || c).slice(0, c.byteLength - tl),
|
|
a.tag = (c.buffer || c).slice(c.byteLength - tl);
|
|
}
|
|
|
|
args[1] = b._key;
|
|
|
|
var op;
|
|
try {
|
|
op = _fn.apply(_subtle, args);
|
|
}
|
|
catch (e) {
|
|
return Promise.reject(e);
|
|
}
|
|
|
|
if (isIE) {
|
|
op = new Promise(function (res, rej) {
|
|
op.onabort =
|
|
op.onerror = function (e) {
|
|
rej(e);
|
|
};
|
|
|
|
op.oncomplete = function (r) {
|
|
var r = r.target.result;
|
|
|
|
if (m === 'encrypt' && r instanceof AesGcmEncryptResult) {
|
|
var c = r.ciphertext, t = r.tag;
|
|
r = new Uint8Array(c.byteLength + t.byteLength);
|
|
r.set(new Uint8Array(c), 0);
|
|
r.set(new Uint8Array(t), c.byteLength);
|
|
r = r.buffer;
|
|
}
|
|
|
|
res(r);
|
|
};
|
|
});
|
|
}
|
|
|
|
return op;
|
|
}
|
|
});
|
|
|
|
if (isIE) {
|
|
var _digest = _subtle.digest;
|
|
|
|
_subtle['digest'] = function (a, b) {
|
|
if (!b.byteLength)
|
|
throw new Error("Empy input is not allowed");
|
|
|
|
var op;
|
|
try {
|
|
op = _digest.call(_subtle, a, b);
|
|
}
|
|
catch (e) {
|
|
return Promise.reject(e);
|
|
}
|
|
|
|
op = new Promise(function (res, rej) {
|
|
op.onabort =
|
|
op.onerror = function (e) { rej(e) };
|
|
op.oncomplete = function (r) { res(r.target.result) };
|
|
});
|
|
|
|
return op;
|
|
};
|
|
|
|
global.crypto = Object.create(_crypto, {
|
|
getRandomValues: { value: function (a) { return _crypto.getRandomValues(a) } },
|
|
subtle: { value: _subtle },
|
|
});
|
|
|
|
global.CryptoKey = CryptoKey;
|
|
}
|
|
|
|
if (isWebkit) {
|
|
_crypto.subtle = _subtle;
|
|
|
|
global.Crypto = _Crypto;
|
|
global.SubtleCrypto = _SubtleCrypto;
|
|
global.CryptoKey = CryptoKey;
|
|
}
|
|
}(typeof window === 'undefined' ? typeof self === 'undefined' ? this : self : window);
|