Remove worker (#1072)
This commit is contained in:
larabr
Daniel Huigens
parent
85d0358d45
commit
8823603396
37
Gruntfile.js
37
Gruntfile.js
|
|
@ -75,14 +75,6 @@ module.exports = function(grunt) {
|
|||
plugin: ['browserify-derequire']
|
||||
}
|
||||
},
|
||||
worker: {
|
||||
files: {
|
||||
'dist/openpgp.worker.js': ['./src/worker/worker.js']
|
||||
},
|
||||
options: {
|
||||
cacheFile: 'browserify-cache-worker.json'
|
||||
}
|
||||
},
|
||||
unittests: {
|
||||
files: {
|
||||
'test/lib/unittests-bundle.js': ['./test/unittests.js']
|
||||
|
|
@ -129,22 +121,6 @@ module.exports = function(grunt) {
|
|||
to: 'OpenPGP.js v<%= pkg.version %>'
|
||||
}]
|
||||
},
|
||||
openpgp_min: {
|
||||
src: ['dist/openpgp.min.js'],
|
||||
dest: ['dist/openpgp.min.js'],
|
||||
replacements: [{
|
||||
from: "openpgp.worker.js",
|
||||
to: "openpgp.worker.min.js"
|
||||
}]
|
||||
},
|
||||
worker_min: {
|
||||
src: ['dist/openpgp.worker.min.js'],
|
||||
dest: ['dist/openpgp.worker.min.js'],
|
||||
replacements: [{
|
||||
from: "openpgp.js",
|
||||
to: "openpgp.min.js"
|
||||
}]
|
||||
},
|
||||
lightweight_build: {
|
||||
src: ['dist/openpgp.js'],
|
||||
overwrite: true,
|
||||
|
|
@ -169,8 +145,7 @@ module.exports = function(grunt) {
|
|||
terser: {
|
||||
openpgp: {
|
||||
files: {
|
||||
'dist/openpgp.min.js' : ['dist/openpgp.js'],
|
||||
'dist/openpgp.worker.min.js' : ['dist/openpgp.worker.js']
|
||||
'dist/openpgp.min.js' : ['dist/openpgp.js']
|
||||
},
|
||||
options: {
|
||||
output: {
|
||||
|
|
@ -192,8 +167,7 @@ module.exports = function(grunt) {
|
|||
'this is LGPL licensed code, see LICENSE/our website <%= pkg.homepage %> for more information. */'
|
||||
},
|
||||
files: {
|
||||
'dist/openpgp.js': 'dist/openpgp.js',
|
||||
'dist/openpgp.worker.js': 'dist/openpgp.worker.js'
|
||||
'dist/openpgp.js': 'dist/openpgp.js'
|
||||
}
|
||||
}
|
||||
},
|
||||
|
|
@ -283,7 +257,7 @@ module.exports = function(grunt) {
|
|||
watch: {
|
||||
src: {
|
||||
files: ['src/**/*.js'],
|
||||
tasks: lightweight ? ['browserify:openpgp', 'browserify:worker', 'replace:lightweight_build'] : ['browserify:openpgp', 'browserify:worker']
|
||||
tasks: lightweight ? ['browserify:openpgp', 'replace:lightweight_build'] : ['browserify:openpgp']
|
||||
},
|
||||
test: {
|
||||
files: ['test/*.js', 'test/crypto/**/*.js', 'test/general/**/*.js', 'test/worker/**/*.js'],
|
||||
|
|
@ -342,13 +316,12 @@ module.exports = function(grunt) {
|
|||
|
||||
// Build tasks
|
||||
grunt.registerTask('version', ['replace:openpgp']);
|
||||
grunt.registerTask('replace_min', ['replace:openpgp_min', 'replace:worker_min']);
|
||||
grunt.registerTask('build', function() {
|
||||
if (lightweight) {
|
||||
grunt.task.run(['copy:indutny_elliptic', 'browserify:openpgp', 'browserify:worker', 'replace:lightweight_build', 'replace:indutny_global', 'version', 'header', 'terser', 'replace_min']);
|
||||
grunt.task.run(['copy:indutny_elliptic', 'browserify:openpgp', 'replace:lightweight_build', 'replace:indutny_global', 'version', 'header', 'terser']);
|
||||
return;
|
||||
}
|
||||
grunt.task.run(['browserify:openpgp', 'browserify:worker', 'version', 'header', 'terser', 'replace_min']);
|
||||
grunt.task.run(['browserify:openpgp', 'version', 'header', 'terser']);
|
||||
}
|
||||
);
|
||||
grunt.registerTask('documentation', ['jsdoc']);
|
||||
|
|
|
|||
20
README.md
20
README.md
|
|
@ -42,7 +42,7 @@ OpenPGP.js [, and Firefox
|
||||
|
|
@ -107,7 +107,7 @@ Or just fetch a minified build under [dist](https://github.com/openpgpjs/openpgp
|
|||
|
||||
### Examples
|
||||
|
||||
Here are some examples of how to use the v2.x+ API. For more elaborate examples and working code, please check out the [public API unit tests](https://github.com/openpgpjs/openpgpjs/blob/master/test/general/openpgp.js). If you're upgrading from v1.x it might help to check out the [documentation](https://github.com/openpgpjs/openpgpjs#documentation).
|
||||
Here are some examples of how to use the v5.x+ API. For more elaborate examples and working code, please check out the [public API unit tests](https://github.com/openpgpjs/openpgpjs/blob/master/test/general/openpgp.js). If you're upgrading from v4.x it might help to check out the [documentation](https://github.com/openpgpjs/openpgpjs#documentation).
|
||||
|
||||
#### Set up
|
||||
|
||||
|
|
@ -125,19 +125,7 @@ Copy `dist/openpgp.min.js` or `dist/compat/openpgp.min.js` (depending on the bro
|
|||
<script src="openpgp.min.js"></script>
|
||||
```
|
||||
|
||||
If you want to use the built-in Web Worker, to offload cryptographic operations off the main thread:
|
||||
|
||||
```js
|
||||
await openpgp.initWorker({ path: 'openpgp.worker.js' }); // set the relative web worker path
|
||||
```
|
||||
|
||||
On logout, be sure to destroy the worker again, to clear private keys from memory:
|
||||
|
||||
```js
|
||||
await openpgp.destroyWorker();
|
||||
```
|
||||
|
||||
Alternatively, you can also implement a Web Worker in your application and load OpenPGP.js from there. This can be more performant if you store or fetch keys and messages directly inside the Worker, so that they don't have to be `postMessage`d there.
|
||||
To offload cryptographic operations off the main thread, you can implement a Web Worker in your application and load OpenPGP.js from there. This can be more performant if you store or fetch keys and messages directly inside the Worker, so that they don't have to be `postMessage`d there. For an example Worker implementation, see `test/worker/worker_example.js`.
|
||||
|
||||
If you want to use the lightweight build (which is smaller, and lazily loads non-default curves on demand), copy `dist/lightweight/openpgp.min.js` and `dist/lightweight/elliptic.min.js`, load the former in a script tag, and point `openpgp.config.indutny_elliptic_path` to the latter:
|
||||
|
||||
|
|
@ -186,8 +174,6 @@ Encryption will use the algorithm preferred by the public key (defaults to aes25
|
|||
const openpgp = require('openpgp'); // use as CommonJS, AMD, ES6 module or via window.openpgp
|
||||
|
||||
(async () => {
|
||||
await openpgp.initWorker({ path: 'openpgp.worker.js' }); // set the relative web worker path
|
||||
|
||||
// put keys in backtick (``) to avoid errors caused by spaces or tabs
|
||||
const publicKeyArmored = `-----BEGIN PGP PUBLIC KEY BLOCK-----
|
||||
...
|
||||
|
|
|
|||
|
|
@ -9,7 +9,6 @@
|
|||
"description": "OpenPGP.js is a Javascript implementation of the OpenPGP protocol. This is defined in RFC 4880.",
|
||||
"main": [
|
||||
"dist/openpgp.js",
|
||||
"dist/openpgp.worker.js"
|
||||
],
|
||||
"moduleType": [
|
||||
"amd",
|
||||
|
|
|
|||
|
|
@ -137,11 +137,6 @@ export default {
|
|||
* @property {Integer} min_bytes_for_web_crypto The minimum amount of bytes for which to use native WebCrypto APIs when available
|
||||
*/
|
||||
min_bytes_for_web_crypto: 1000,
|
||||
/**
|
||||
* @memberof module:config
|
||||
* @property {Boolean} Use transferable objects between the Web Worker and main thread
|
||||
*/
|
||||
zero_copy: false,
|
||||
/**
|
||||
* @memberof module:config
|
||||
* @property {Boolean} debug If enabled, debug messages will be printed
|
||||
|
|
|
|||
|
|
@ -20,8 +20,7 @@ export default openpgp;
|
|||
export {
|
||||
encrypt, decrypt, sign, verify,
|
||||
generateKey, reformatKey, revokeKey, decryptKey,
|
||||
generateSessionKey, encryptSessionKey, decryptSessionKeys,
|
||||
initWorker, getWorker, destroyWorker
|
||||
generateSessionKey, encryptSessionKey, decryptSessionKeys
|
||||
} from './openpgp';
|
||||
|
||||
/**
|
||||
|
|
@ -136,12 +135,6 @@ export { default as crypto } from './crypto';
|
|||
*/
|
||||
export { default as Keyring } from './keyring';
|
||||
|
||||
/**
|
||||
* @see module:worker/async_proxy
|
||||
* @name module:openpgp.AsyncProxy
|
||||
*/
|
||||
export { default as AsyncProxy } from './worker/async_proxy';
|
||||
|
||||
/**
|
||||
* @see module:hkp
|
||||
* @name module:openpgp.HKP
|
||||
|
|
|
|||
121
src/openpgp.js
121
src/openpgp.js
|
|
@ -27,7 +27,6 @@
|
|||
* @requires enums
|
||||
* @requires util
|
||||
* @requires polyfills
|
||||
* @requires worker/async_proxy
|
||||
* @module openpgp
|
||||
*/
|
||||
|
||||
|
|
@ -45,10 +44,8 @@ import * as messageLib from './message';
|
|||
import { CleartextMessage } from './cleartext';
|
||||
import { generate, reformat } from './key';
|
||||
import config from './config/config';
|
||||
import enums from './enums';
|
||||
import './polyfills';
|
||||
import util from './util';
|
||||
import AsyncProxy from './worker/async_proxy';
|
||||
|
||||
let toNativeReadable;
|
||||
if (global.ReadableStream) {
|
||||
|
|
@ -57,54 +54,6 @@ if (global.ReadableStream) {
|
|||
} catch (e) {}
|
||||
}
|
||||
|
||||
//////////////////////////
|
||||
// //
|
||||
// Web Worker setup //
|
||||
// //
|
||||
//////////////////////////
|
||||
|
||||
|
||||
let asyncProxy; // instance of the asyncproxy
|
||||
|
||||
/**
|
||||
* Set the path for the web worker script and create an instance of the async proxy
|
||||
* @param {String} path relative path to the worker scripts, default: 'openpgp.worker.js'
|
||||
* @param {Number} n number of workers to initialize
|
||||
* @param {Array<Object>} workers alternative to path parameter: web workers initialized with 'openpgp.worker.js'
|
||||
* @returns {Promise<Boolean>} returns a promise that resolves to true if all workers have succesfully finished loading
|
||||
* @async
|
||||
*/
|
||||
export async function initWorker({ path = 'openpgp.worker.js', n = 1, workers = [] } = {}) {
|
||||
if (workers.length || (typeof global !== 'undefined' && global.Worker && global.MessageChannel)) {
|
||||
const proxy = new AsyncProxy();
|
||||
await proxy.init({ path, n, workers, config });
|
||||
asyncProxy = proxy;
|
||||
} else {
|
||||
throw new Error('Web Workers are not available');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a reference to the async proxy if the worker was initialized with openpgp.initWorker()
|
||||
* @returns {module:worker/async_proxy.AsyncProxy|null} the async proxy or null if not initialized
|
||||
*/
|
||||
export function getWorker() {
|
||||
return asyncProxy;
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleanup the current instance of the web worker.
|
||||
*/
|
||||
export async function destroyWorker() {
|
||||
const proxy = asyncProxy;
|
||||
asyncProxy = undefined;
|
||||
if (proxy) {
|
||||
await proxy.clearKeyCache();
|
||||
proxy.terminate();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//////////////////////
|
||||
// //
|
||||
// Key handling //
|
||||
|
|
@ -137,10 +86,6 @@ export function generateKey({ userIds = [], passphrase = "", rsaBits = null, key
|
|||
throw new Error('rsaBits should be 2048 or 4096, found: ' + rsaBits);
|
||||
}
|
||||
|
||||
if (!util.getWebCryptoAll() && asyncProxy) { // use web worker if web crypto apis are not supported
|
||||
return asyncProxy.delegate('generateKey', options);
|
||||
}
|
||||
|
||||
return generate(options).then(async key => {
|
||||
const revocationCertificate = await key.getRevocationCertificate(date);
|
||||
key.revocationSignatures = [];
|
||||
|
|
@ -170,9 +115,6 @@ export function generateKey({ userIds = [], passphrase = "", rsaBits = null, key
|
|||
export function reformatKey({ privateKey, userIds = [], passphrase = "", keyExpirationTime = 0, date }) {
|
||||
userIds = toArray(userIds);
|
||||
const options = { privateKey, userIds, passphrase, keyExpirationTime, date };
|
||||
if (asyncProxy) {
|
||||
return asyncProxy.delegate('reformatKey', options);
|
||||
}
|
||||
|
||||
return reformat(options).then(async key => {
|
||||
const revocationCertificate = await key.getRevocationCertificate(date);
|
||||
|
|
@ -205,14 +147,6 @@ export function reformatKey({ privateKey, userIds = [], passphrase = "", keyExpi
|
|||
export function revokeKey({
|
||||
key, revocationCertificate, reasonForRevocation
|
||||
} = {}) {
|
||||
const options = {
|
||||
key, revocationCertificate, reasonForRevocation
|
||||
};
|
||||
|
||||
if (!util.getWebCryptoAll() && asyncProxy) { // use web worker if web crypto apis are not supported
|
||||
return asyncProxy.delegate('revokeKey', options);
|
||||
}
|
||||
|
||||
return Promise.resolve().then(() => {
|
||||
if (revocationCertificate) {
|
||||
return key.applyRevocationCertificate(revocationCertificate);
|
||||
|
|
@ -243,13 +177,9 @@ export function revokeKey({
|
|||
* @returns {Promise<Object>} the unlocked key object in the form: { key:Key }
|
||||
* @async
|
||||
*/
|
||||
export function decryptKey({ privateKey, passphrase }, fromWorker = false) {
|
||||
if (asyncProxy) { // use web worker if available
|
||||
return asyncProxy.delegate('decryptKey', { privateKey, passphrase });
|
||||
}
|
||||
|
||||
export function decryptKey({ privateKey, passphrase }) {
|
||||
return Promise.resolve().then(async function() {
|
||||
const key = fromWorker ? privateKey : await privateKey.clone(true);
|
||||
const key = await privateKey.clone(true);
|
||||
await key.decrypt(passphrase);
|
||||
return key;
|
||||
}).catch(onError.bind(null, 'Error decrypting private key'));
|
||||
|
|
@ -262,13 +192,9 @@ export function decryptKey({ privateKey, passphrase }, fromWorker = false) {
|
|||
* @returns {Promise<Object>} the locked key object in the form: { key:Key }
|
||||
* @async
|
||||
*/
|
||||
export function encryptKey({ privateKey, passphrase }, fromWorker = false) {
|
||||
if (asyncProxy) { // use web worker if available
|
||||
return asyncProxy.delegate('encryptKey', { privateKey, passphrase });
|
||||
}
|
||||
|
||||
export function encryptKey({ privateKey, passphrase }) {
|
||||
return Promise.resolve().then(async function() {
|
||||
const key = fromWorker ? privateKey : await privateKey.clone(true);
|
||||
const key = await privateKey.clone(true);
|
||||
await key.encrypt(passphrase);
|
||||
return key;
|
||||
}).catch(onError.bind(null, 'Error encrypting private key'));
|
||||
|
|
@ -308,9 +234,6 @@ export function encrypt({ message, publicKeys, privateKeys, passwords, sessionKe
|
|||
throw new Error("detached option has been removed from openpgp.encrypt. Separately call openpgp.sign instead. Don't forget to remove privateKeys option as well.");
|
||||
}
|
||||
|
||||
if (!nativeAEAD() && asyncProxy) { // use web worker if web crypto apis are not supported
|
||||
return asyncProxy.delegate('encrypt', { message, publicKeys, privateKeys, passwords, sessionKey, compression, armor, streaming, detached, signature, wildcard, date, fromUserIds, toUserIds });
|
||||
}
|
||||
return Promise.resolve().then(async function() {
|
||||
if (!privateKeys) {
|
||||
privateKeys = [];
|
||||
|
|
@ -357,10 +280,6 @@ export function encrypt({ message, publicKeys, privateKeys, passwords, sessionKe
|
|||
export function decrypt({ message, privateKeys, passwords, sessionKeys, publicKeys, format = 'utf8', streaming = message && message.fromStream, signature = null, date = new Date() }) {
|
||||
checkMessage(message); publicKeys = toArray(publicKeys); privateKeys = toArray(privateKeys); passwords = toArray(passwords); sessionKeys = toArray(sessionKeys);
|
||||
|
||||
if (!nativeAEAD() && asyncProxy) { // use web worker if web crypto apis are not supported
|
||||
return asyncProxy.delegate('decrypt', { message, privateKeys, passwords, sessionKeys, publicKeys, format, streaming, signature, date });
|
||||
}
|
||||
|
||||
return message.decrypt(privateKeys, passwords, sessionKeys, streaming).then(async function(decrypted) {
|
||||
if (!publicKeys) {
|
||||
publicKeys = [];
|
||||
|
|
@ -403,11 +322,6 @@ export function sign({ message, privateKeys, armor = true, streaming = message &
|
|||
if (message instanceof CleartextMessage && !armor) throw new Error("Can't sign non-armored cleartext message");
|
||||
if (message instanceof CleartextMessage && detached) throw new Error("Can't sign detached cleartext message");
|
||||
privateKeys = toArray(privateKeys); fromUserIds = toArray(fromUserIds);
|
||||
if (asyncProxy) { // use web worker if available
|
||||
return asyncProxy.delegate('sign', {
|
||||
message, privateKeys, armor, streaming, detached, date, fromUserIds
|
||||
});
|
||||
}
|
||||
|
||||
return Promise.resolve().then(async function() {
|
||||
let signature;
|
||||
|
|
@ -458,10 +372,6 @@ export function verify({ message, publicKeys, format = 'utf8', streaming = messa
|
|||
if (message instanceof CleartextMessage && format === 'binary') throw new Error("Can't return cleartext message data as binary");
|
||||
publicKeys = toArray(publicKeys);
|
||||
|
||||
if (asyncProxy) { // use web worker if available
|
||||
return asyncProxy.delegate('verify', { message, publicKeys, streaming, signature, date });
|
||||
}
|
||||
|
||||
return Promise.resolve().then(async function() {
|
||||
const result = {};
|
||||
result.signatures = signature ? await message.verifyDetached(signature, publicKeys, date, streaming) : await message.verify(publicKeys, date, streaming);
|
||||
|
|
@ -495,10 +405,6 @@ export function verify({ message, publicKeys, format = 'utf8', streaming = messa
|
|||
export function generateSessionKey({ publicKeys, date = new Date(), toUserIds = [] }) {
|
||||
publicKeys = toArray(publicKeys); toUserIds = toArray(toUserIds);
|
||||
|
||||
if (asyncProxy) { // use web worker if available
|
||||
return asyncProxy.delegate('generateSessionKey', { publicKeys, date, toUserIds });
|
||||
}
|
||||
|
||||
return Promise.resolve().then(async function() {
|
||||
|
||||
return messageLib.generateSessionKey(publicKeys, date, toUserIds);
|
||||
|
|
@ -525,10 +431,6 @@ export function generateSessionKey({ publicKeys, date = new Date(), toUserIds =
|
|||
export function encryptSessionKey({ data, algorithm, aeadAlgorithm, publicKeys, passwords, armor = true, wildcard = false, date = new Date(), toUserIds = [] }) {
|
||||
checkBinary(data); checkString(algorithm, 'algorithm'); publicKeys = toArray(publicKeys); passwords = toArray(passwords); toUserIds = toArray(toUserIds);
|
||||
|
||||
if (asyncProxy) { // use web worker if available
|
||||
return asyncProxy.delegate('encryptSessionKey', { data, algorithm, aeadAlgorithm, publicKeys, passwords, armor, wildcard, date, toUserIds });
|
||||
}
|
||||
|
||||
return Promise.resolve().then(async function() {
|
||||
|
||||
const message = await messageLib.encryptSessionKey(data, algorithm, aeadAlgorithm, publicKeys, passwords, wildcard, date, toUserIds);
|
||||
|
|
@ -552,10 +454,6 @@ export function encryptSessionKey({ data, algorithm, aeadAlgorithm, publicKeys,
|
|||
export function decryptSessionKeys({ message, privateKeys, passwords }) {
|
||||
checkMessage(message); privateKeys = toArray(privateKeys); passwords = toArray(passwords);
|
||||
|
||||
if (asyncProxy) { // use web worker if available
|
||||
return asyncProxy.delegate('decryptSessionKeys', { message, privateKeys, passwords });
|
||||
}
|
||||
|
||||
return Promise.resolve().then(async function() {
|
||||
|
||||
return message.decryptSessionKeys(privateKeys, passwords);
|
||||
|
|
@ -691,14 +589,3 @@ function onError(message, error) {
|
|||
|
||||
throw error;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check for native AEAD support and configuration by the user. Only
|
||||
* browsers that implement the current WebCrypto specification support
|
||||
* native GCM. Native EAX is built on CTR and CBC, which current
|
||||
* browsers support. OCB and CFB are not natively supported.
|
||||
* @returns {Boolean} If authenticated encryption should be used
|
||||
*/
|
||||
function nativeAEAD() {
|
||||
return config.aead_protect && (config.aead_mode === enums.aead.eax || config.aead_mode === enums.aead.experimental_gcm) && util.getWebCrypto();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@
|
|||
* @module packet/all_packets
|
||||
*/
|
||||
|
||||
import enums from '../enums.js';
|
||||
import * as packets from './all_packets.js'; // re-import module to parse packets from tag
|
||||
|
||||
export {
|
||||
|
|
@ -87,24 +86,6 @@ export function newPacketFromTag(tag) {
|
|||
return new packets[packetClassFromTagName(tag)]();
|
||||
}
|
||||
|
||||
/**
|
||||
* Allocate a new packet from structured packet clone
|
||||
* @see {@link https://w3c.github.io/html/infrastructure.html#safe-passing-of-structured-data}
|
||||
* @function fromStructuredClone
|
||||
* @memberof module:packet
|
||||
* @param {Object} packetClone packet clone
|
||||
* @returns {Object} new packet object with data from packet clone
|
||||
*/
|
||||
export function fromStructuredClone(packetClone) {
|
||||
const tagName = enums.read(enums.packet, packetClone.tag);
|
||||
const packet = newPacketFromTag(tagName);
|
||||
Object.assign(packet, packetClone);
|
||||
if (packet.postCloneTypeFix) {
|
||||
packet.postCloneTypeFix();
|
||||
}
|
||||
return packet;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert tag name to class name
|
||||
* @param {String} tag property name from {@link module:enums.packet}
|
||||
|
|
|
|||
|
|
@ -1,189 +0,0 @@
|
|||
// OpenPGP.js - An OpenPGP implementation in javascript
|
||||
// Copyright (C) 2015 Tankred Hase
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Lesser General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 3.0 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public
|
||||
// License along with this library; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
/**
|
||||
* @fileoverview This module implements packet list cloning required to
|
||||
* pass certain object types between the web worker and main thread using
|
||||
* the structured cloning algorithm.
|
||||
* @module packet/clone
|
||||
*/
|
||||
|
||||
import stream from 'web-stream-tools';
|
||||
import { Key } from '../key';
|
||||
import { Message } from '../message';
|
||||
import { CleartextMessage } from '../cleartext';
|
||||
import { Signature } from '../signature';
|
||||
import List from './packetlist';
|
||||
import type_keyid from '../type/keyid';
|
||||
import util from '../util';
|
||||
|
||||
|
||||
//////////////////////////////
|
||||
// //
|
||||
// List --> Clone //
|
||||
// //
|
||||
//////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Create a packetlist from the correspoding object types.
|
||||
* @param {Object} options the object passed to and from the web worker
|
||||
* @returns {Object} a mutated version of the options optject
|
||||
*/
|
||||
export function clonePackets(options) {
|
||||
if (options.publicKeys) {
|
||||
options.publicKeys = options.publicKeys.map(key => key.toPacketlist());
|
||||
}
|
||||
if (options.privateKeys) {
|
||||
options.privateKeys = options.privateKeys.map(key => key.toPacketlist());
|
||||
}
|
||||
if (options.publicKey) {
|
||||
options.publicKey = options.publicKey.toPacketlist();
|
||||
}
|
||||
if (options.privateKey) {
|
||||
options.privateKey = options.privateKey.toPacketlist();
|
||||
}
|
||||
if (options.key) {
|
||||
options.key = options.key.toPacketlist();
|
||||
}
|
||||
if (options.message) {
|
||||
//could be either a Message or CleartextMessage object
|
||||
if (options.message instanceof Message) {
|
||||
options.message = { packets: options.message.packets, fromStream: options.message.fromStream };
|
||||
} else if (options.message instanceof CleartextMessage) {
|
||||
options.message = { text: options.message.text, signature: options.message.signature.packets };
|
||||
}
|
||||
}
|
||||
if (options.signature && (options.signature instanceof Signature)) {
|
||||
options.signature = options.signature.packets;
|
||||
}
|
||||
if (options.signatures) {
|
||||
options.signatures.forEach(verificationObjectToClone);
|
||||
}
|
||||
return options;
|
||||
}
|
||||
|
||||
function verificationObjectToClone(verObject) {
|
||||
const verified = verObject.verified;
|
||||
verObject.verified = stream.fromAsync(() => verified);
|
||||
if (verObject.signature instanceof Promise) {
|
||||
const signature = verObject.signature;
|
||||
verObject.signature = stream.fromAsync(async () => {
|
||||
const packets = (await signature).packets;
|
||||
try {
|
||||
await verified;
|
||||
} catch (e) {}
|
||||
if (packets && packets[0]) {
|
||||
delete packets[0].signature;
|
||||
delete packets[0].hashed;
|
||||
}
|
||||
return packets;
|
||||
});
|
||||
} else {
|
||||
verObject.signature = verObject.signature.packets;
|
||||
}
|
||||
if (verObject.error) {
|
||||
verObject.error = verObject.error.message;
|
||||
}
|
||||
return verObject;
|
||||
}
|
||||
|
||||
//////////////////////////////
|
||||
// //
|
||||
// Clone --> List //
|
||||
// //
|
||||
//////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Creates an object with the correct prototype from a corresponding packetlist.
|
||||
* @param {Object} options the object passed to and from the web worker
|
||||
* @param {String} method the public api function name to be delegated to the worker
|
||||
* @returns {Object} a mutated version of the options optject
|
||||
*/
|
||||
export function parseClonedPackets(options) {
|
||||
if (options.publicKeys) {
|
||||
options.publicKeys = options.publicKeys.map(packetlistCloneToKey);
|
||||
}
|
||||
if (options.privateKeys) {
|
||||
options.privateKeys = options.privateKeys.map(packetlistCloneToKey);
|
||||
}
|
||||
if (options.publicKey) {
|
||||
options.publicKey = packetlistCloneToKey(options.publicKey);
|
||||
}
|
||||
if (options.privateKey) {
|
||||
options.privateKey = packetlistCloneToKey(options.privateKey);
|
||||
}
|
||||
if (options.key) {
|
||||
options.key = packetlistCloneToKey(options.key);
|
||||
}
|
||||
if (options.message && options.message.signature) {
|
||||
options.message = packetlistCloneToCleartextMessage(options.message);
|
||||
} else if (options.message) {
|
||||
options.message = packetlistCloneToMessage(options.message);
|
||||
}
|
||||
if (options.signatures) {
|
||||
options.signatures = options.signatures.map(packetlistCloneToSignatures);
|
||||
}
|
||||
if (options.signature) {
|
||||
options.signature = packetlistCloneToSignature(options.signature);
|
||||
}
|
||||
return options;
|
||||
}
|
||||
|
||||
function packetlistCloneToKey(clone) {
|
||||
const packetlist = List.fromStructuredClone(clone);
|
||||
return new Key(packetlist);
|
||||
}
|
||||
|
||||
function packetlistCloneToMessage(clone) {
|
||||
const packetlist = List.fromStructuredClone(clone.packets);
|
||||
const message = new Message(packetlist);
|
||||
message.fromStream = clone.fromStream;
|
||||
return message;
|
||||
}
|
||||
|
||||
function packetlistCloneToCleartextMessage(clone) {
|
||||
const packetlist = List.fromStructuredClone(clone.signature);
|
||||
return new CleartextMessage(clone.text, new Signature(packetlist));
|
||||
}
|
||||
|
||||
//verification objects
|
||||
function packetlistCloneToSignatures(clone) {
|
||||
clone.keyid = type_keyid.fromClone(clone.keyid);
|
||||
if (util.isStream(clone.signature)) {
|
||||
clone.signature = stream.readToEnd(clone.signature, ([signature]) => new Signature(List.fromStructuredClone(signature)));
|
||||
clone.signature.catch(() => {});
|
||||
} else {
|
||||
clone.signature = new Signature(List.fromStructuredClone(clone.signature));
|
||||
}
|
||||
clone.verified = stream.readToEnd(clone.verified, ([verified]) => verified);
|
||||
clone.verified.catch(() => {});
|
||||
if (clone.error) {
|
||||
clone.error = new Error(clone.error);
|
||||
}
|
||||
return clone;
|
||||
}
|
||||
|
||||
function packetlistCloneToSignature(clone) {
|
||||
if (util.isString(clone) || util.isStream(clone)) {
|
||||
//signature is armored
|
||||
return clone;
|
||||
}
|
||||
const packetlist = List.fromStructuredClone(clone);
|
||||
return new Signature(packetlist);
|
||||
}
|
||||
|
|
@ -7,12 +7,10 @@
|
|||
*/
|
||||
|
||||
import * as packets from './all_packets';
|
||||
import * as clone from './clone';
|
||||
import List from './packetlist';
|
||||
|
||||
const mod = {
|
||||
List,
|
||||
clone
|
||||
List
|
||||
};
|
||||
|
||||
Object.assign(mod, packets);
|
||||
|
|
|
|||
|
|
@ -122,13 +122,6 @@ OnePassSignature.prototype.write = function () {
|
|||
return util.concatUint8Array([start, this.issuerKeyId.write(), end]);
|
||||
};
|
||||
|
||||
/**
|
||||
* Fix custom types after cloning
|
||||
*/
|
||||
OnePassSignature.prototype.postCloneTypeFix = function() {
|
||||
this.issuerKeyId = type_keyid.fromClone(this.issuerKeyId);
|
||||
};
|
||||
|
||||
OnePassSignature.prototype.hash = Signature.prototype.hash;
|
||||
OnePassSignature.prototype.toHash = Signature.prototype.toHash;
|
||||
OnePassSignature.prototype.toSign = Signature.prototype.toSign;
|
||||
|
|
|
|||
|
|
@ -203,30 +203,4 @@ List.prototype.concat = function (packetlist) {
|
|||
return this;
|
||||
};
|
||||
|
||||
/**
|
||||
* Allocate a new packetlist from structured packetlist clone
|
||||
* See {@link https://w3c.github.io/html/infrastructure.html#safe-passing-of-structured-data}
|
||||
* @param {Object} packetClone packetlist clone
|
||||
* @returns {Object} new packetlist object with data from packetlist clone
|
||||
*/
|
||||
List.fromStructuredClone = function(packetlistClone) {
|
||||
const packetlist = new List();
|
||||
for (let i = 0; i < packetlistClone.length; i++) {
|
||||
const packet = packets.fromStructuredClone(packetlistClone[i]);
|
||||
packetlist.push(packet);
|
||||
if (packet.embeddedSignature) {
|
||||
packet.embeddedSignature = packets.fromStructuredClone(packet.embeddedSignature);
|
||||
}
|
||||
if (packet.packets.length !== 0) {
|
||||
packet.packets = this.fromStructuredClone(packet.packets);
|
||||
} else {
|
||||
packet.packets = new List();
|
||||
}
|
||||
}
|
||||
if (packetlistClone.stream) {
|
||||
packetlist.stream = stream.transform(packetlistClone.stream, packet => packets.fromStructuredClone(packet));
|
||||
}
|
||||
return packetlist;
|
||||
};
|
||||
|
||||
export default List;
|
||||
|
|
|
|||
|
|
@ -262,19 +262,4 @@ PublicKey.prototype.getAlgorithmInfo = function () {
|
|||
return result;
|
||||
};
|
||||
|
||||
/**
|
||||
* Fix custom types after cloning
|
||||
*/
|
||||
PublicKey.prototype.postCloneTypeFix = function() {
|
||||
const algo = enums.write(enums.publicKey, this.algorithm);
|
||||
const types = crypto.getPubKeyParamTypes(algo);
|
||||
for (let i = 0; i < types.length; i++) {
|
||||
const param = this.params[i];
|
||||
this.params[i] = types[i].fromClone(param);
|
||||
}
|
||||
if (this.keyid) {
|
||||
this.keyid = type_keyid.fromClone(this.keyid);
|
||||
}
|
||||
};
|
||||
|
||||
export default PublicKey;
|
||||
|
|
|
|||
|
|
@ -146,16 +146,4 @@ PublicKeyEncryptedSessionKey.prototype.decrypt = async function (key) {
|
|||
return true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Fix custom types after cloning
|
||||
*/
|
||||
PublicKeyEncryptedSessionKey.prototype.postCloneTypeFix = function() {
|
||||
this.publicKeyId = type_keyid.fromClone(this.publicKeyId);
|
||||
const algo = enums.write(enums.publicKey, this.publicKeyAlgorithm);
|
||||
const types = crypto.getEncSessionKeyParamTypes(algo);
|
||||
for (let i = 0; i < this.encrypted.length; i++) {
|
||||
this.encrypted[i] = types[i].fromClone(this.encrypted[i]);
|
||||
}
|
||||
};
|
||||
|
||||
export default PublicKeyEncryptedSessionKey;
|
||||
|
|
|
|||
|
|
@ -25,7 +25,6 @@
|
|||
*/
|
||||
|
||||
import PublicKey from './public_key';
|
||||
import type_keyid from '../type/keyid.js';
|
||||
import type_s2k from '../type/s2k';
|
||||
import crypto from '../crypto';
|
||||
import enums from '../enums';
|
||||
|
|
@ -450,22 +449,4 @@ SecretKey.prototype.clearPrivateParams = function () {
|
|||
this.isEncrypted = true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Fix custom types after cloning
|
||||
*/
|
||||
SecretKey.prototype.postCloneTypeFix = function() {
|
||||
const algo = enums.write(enums.publicKey, this.algorithm);
|
||||
const types = [].concat(crypto.getPubKeyParamTypes(algo), crypto.getPrivKeyParamTypes(algo));
|
||||
for (let i = 0; i < this.params.length; i++) {
|
||||
const param = this.params[i];
|
||||
this.params[i] = types[i].fromClone(param);
|
||||
}
|
||||
if (this.keyid) {
|
||||
this.keyid = type_keyid.fromClone(this.keyid);
|
||||
}
|
||||
if (this.s2k) {
|
||||
this.s2k = type_s2k.fromClone(this.s2k);
|
||||
}
|
||||
};
|
||||
|
||||
export default SecretKey;
|
||||
|
|
|
|||
|
|
@ -774,11 +774,4 @@ Signature.prototype.getExpirationTime = function () {
|
|||
return !this.signatureNeverExpires ? new Date(this.created.getTime() + this.signatureExpirationTime * 1000) : Infinity;
|
||||
};
|
||||
|
||||
/**
|
||||
* Fix custom types after cloning
|
||||
*/
|
||||
Signature.prototype.postCloneTypeFix = function() {
|
||||
this.issuerKeyId = type_keyid.fromClone(this.issuerKeyId);
|
||||
};
|
||||
|
||||
export default Signature;
|
||||
|
|
|
|||
|
|
@ -194,11 +194,4 @@ SymEncryptedSessionKey.prototype.encrypt = async function(passphrase) {
|
|||
return true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Fix custom types after cloning
|
||||
*/
|
||||
SymEncryptedSessionKey.prototype.postCloneTypeFix = function() {
|
||||
this.s2k = type_s2k.fromClone(this.s2k);
|
||||
};
|
||||
|
||||
export default SymEncryptedSessionKey;
|
||||
|
|
|
|||
|
|
@ -62,8 +62,4 @@ ECDHSymmetricKey.prototype.write = function () {
|
|||
return util.concatUint8Array([new Uint8Array([this.data.length]), this.data]);
|
||||
};
|
||||
|
||||
ECDHSymmetricKey.fromClone = function (clone) {
|
||||
return new ECDHSymmetricKey(clone.data);
|
||||
};
|
||||
|
||||
export default ECDHSymmetricKey;
|
||||
|
|
|
|||
|
|
@ -65,9 +65,4 @@ KDFParams.prototype.write = function () {
|
|||
return new Uint8Array([3, 1, this.hash, this.cipher]);
|
||||
};
|
||||
|
||||
KDFParams.fromClone = function (clone) {
|
||||
const { hash, cipher } = clone;
|
||||
return new KDFParams({ hash, cipher });
|
||||
};
|
||||
|
||||
export default KDFParams;
|
||||
|
|
|
|||
|
|
@ -89,12 +89,6 @@ Keyid.mapToHex = function (keyId) {
|
|||
return keyId.toHex();
|
||||
};
|
||||
|
||||
Keyid.fromClone = function (clone) {
|
||||
const keyid = new Keyid();
|
||||
keyid.bytes = clone.bytes;
|
||||
return keyid;
|
||||
};
|
||||
|
||||
Keyid.fromId = function (hex) {
|
||||
const keyid = new Keyid();
|
||||
keyid.read(util.hex_to_Uint8Array(hex));
|
||||
|
|
|
|||
|
|
@ -131,8 +131,4 @@ MPI.prototype.fromBN = function (bn) {
|
|||
this.data = bn.toArrayLike(Uint8Array);
|
||||
};
|
||||
|
||||
MPI.fromClone = function (clone) {
|
||||
return new MPI(clone.data);
|
||||
};
|
||||
|
||||
export default MPI;
|
||||
|
|
|
|||
|
|
@ -103,8 +103,4 @@ OID.prototype.getName = function() {
|
|||
}
|
||||
};
|
||||
|
||||
OID.fromClone = function (clone) {
|
||||
return new OID(clone.oid);
|
||||
};
|
||||
|
||||
export default OID;
|
||||
|
|
|
|||
|
|
@ -191,13 +191,4 @@ S2K.prototype.produce_key = async function (passphrase, numBytes) {
|
|||
return util.concatUint8Array(arr).subarray(0, numBytes);
|
||||
};
|
||||
|
||||
S2K.fromClone = function (clone) {
|
||||
const s2k = new S2K();
|
||||
s2k.algorithm = clone.algorithm;
|
||||
s2k.type = clone.type;
|
||||
s2k.c = clone.c;
|
||||
s2k.salt = clone.salt;
|
||||
return s2k;
|
||||
};
|
||||
|
||||
export default S2K;
|
||||
|
|
|
|||
63
src/util.js
63
src/util.js
|
|
@ -45,69 +45,6 @@ export default {
|
|||
|
||||
isStream: stream.isStream,
|
||||
|
||||
/**
|
||||
* Get transferable objects to pass buffers with zero copy (similar to "pass by reference" in C++)
|
||||
* See: https://developer.mozilla.org/en-US/docs/Web/API/Worker/postMessage
|
||||
* Also, convert ReadableStreams to MessagePorts
|
||||
* @param {Object} obj the options object to be passed to the web worker
|
||||
* @returns {Array<ArrayBuffer>} an array of binary data to be passed
|
||||
*/
|
||||
getTransferables: function(obj, zero_copy) {
|
||||
const transferables = [];
|
||||
util.collectTransferables(obj, transferables, zero_copy);
|
||||
return transferables.length ? transferables : undefined;
|
||||
},
|
||||
|
||||
collectTransferables: function(obj, collection, zero_copy) {
|
||||
if (!obj) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (util.isUint8Array(obj)) {
|
||||
if (zero_copy && collection.indexOf(obj.buffer) === -1 && !(
|
||||
navigator.userAgent.indexOf('Version/11.1') !== -1 || // Safari 11.1
|
||||
((navigator.userAgent.match(/Chrome\/(\d+)/) || [])[1] < 56 && navigator.userAgent.indexOf('Edge') === -1) // Chrome < 56
|
||||
)) {
|
||||
collection.push(obj.buffer);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (Object.prototype.isPrototypeOf(obj)) {
|
||||
Object.entries(obj).forEach(([key, value]) => { // recursively search all children
|
||||
if (util.isStream(value)) {
|
||||
if (value.locked) {
|
||||
obj[key] = null;
|
||||
} else {
|
||||
const transformed = stream.transformPair(value, async readable => {
|
||||
const reader = stream.getReader(readable);
|
||||
const { port1, port2 } = new MessageChannel();
|
||||
port1.onmessage = async function({ data: { action } }) {
|
||||
if (action === 'read') {
|
||||
try {
|
||||
const result = await reader.read();
|
||||
port1.postMessage(result, util.getTransferables(result));
|
||||
} catch (e) {
|
||||
port1.postMessage({ error: e.message });
|
||||
}
|
||||
} else if (action === 'cancel') {
|
||||
await transformed.cancel();
|
||||
port1.postMessage();
|
||||
}
|
||||
};
|
||||
obj[key] = port2;
|
||||
collection.push(port2);
|
||||
});
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (Object.prototype.toString.call(value) === '[object MessagePort]') {
|
||||
throw new Error("Can't transfer the same stream twice.");
|
||||
}
|
||||
util.collectTransferables(value, collection, zero_copy);
|
||||
});
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Convert MessagePorts back to ReadableStreams
|
||||
* @param {Object} obj
|
||||
|
|
|
|||
|
|
@ -1,176 +0,0 @@
|
|||
// GPG4Browsers - An OpenPGP implementation in javascript
|
||||
// Copyright (C) 2011 Recurity Labs GmbH
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Lesser General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 3.0 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public
|
||||
// License along with this library; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
/**
|
||||
* @fileoverview Provides functions for maintaining browser workers
|
||||
* @see module:openpgp.initWorker
|
||||
* @see module:openpgp.getWorker
|
||||
* @see module:openpgp.destroyWorker
|
||||
* @see module:worker/worker
|
||||
* @requires util
|
||||
* @requires config
|
||||
* @requires crypto
|
||||
* @requires packet
|
||||
* @module worker/async_proxy
|
||||
*/
|
||||
|
||||
import util from '../util.js';
|
||||
import config from '../config';
|
||||
import crypto from '../crypto';
|
||||
import packet from '../packet';
|
||||
|
||||
|
||||
/**
|
||||
* Creates a new async proxy
|
||||
* @constructor
|
||||
*/
|
||||
function AsyncProxy() {}
|
||||
|
||||
/**
|
||||
* Initializes the proxy and loads the web worker
|
||||
* @param {String} path The path to the worker or 'openpgp.worker.js' by default
|
||||
* @param {Number} n number of workers to initialize if path given
|
||||
* @param {Object} config config The worker configuration
|
||||
* @param {Array<Object>} worker alternative to path parameter: web worker initialized with 'openpgp.worker.js'
|
||||
*/
|
||||
AsyncProxy.prototype.init = async function({ path = 'openpgp.worker.js', n = 1, workers = [], config } = {}) {
|
||||
/**
|
||||
* Message handling
|
||||
*/
|
||||
const handleMessage = workerId => event => {
|
||||
const msg = event.data;
|
||||
switch (msg.event) {
|
||||
case 'method-return':
|
||||
if (msg.err) {
|
||||
// fail
|
||||
const err = new Error(msg.err);
|
||||
// add worker stack
|
||||
err.workerStack = msg.stack;
|
||||
this.tasks[msg.id].reject(err);
|
||||
} else {
|
||||
// success
|
||||
this.tasks[msg.id].resolve(msg.data);
|
||||
}
|
||||
delete this.tasks[msg.id];
|
||||
this.workers[workerId].requests--;
|
||||
break;
|
||||
case 'request-seed':
|
||||
this.seedRandom(workerId, msg.amount);
|
||||
break;
|
||||
default:
|
||||
throw new Error('Unknown Worker Event.');
|
||||
}
|
||||
};
|
||||
|
||||
if (workers.length) {
|
||||
this.workers = workers;
|
||||
}
|
||||
else {
|
||||
this.workers = [];
|
||||
while (this.workers.length < n) {
|
||||
this.workers.push(new Worker(path));
|
||||
}
|
||||
}
|
||||
|
||||
// Cannot rely on task order being maintained, use object keyed by request ID to track tasks
|
||||
this.tasks = {};
|
||||
this.currentID = 0;
|
||||
|
||||
let workerId = 0;
|
||||
await Promise.all(this.workers.map(worker => new Promise(async (resolve, reject) => {
|
||||
worker.requests = 0;
|
||||
worker.onmessage = handleMessage(workerId++);
|
||||
worker.onerror = e => {
|
||||
reject(new Error('Unhandled error in openpgp worker: ' + e.message + ' (' + e.filename + ':' + e.lineno + ')'));
|
||||
};
|
||||
|
||||
await this.callWorker(worker, 'configure', config);
|
||||
resolve();
|
||||
})));
|
||||
};
|
||||
|
||||
/**
|
||||
* Get new request ID
|
||||
* @returns {integer} New unique request ID
|
||||
*/
|
||||
AsyncProxy.prototype.getID = function() {
|
||||
return this.currentID++;
|
||||
};
|
||||
|
||||
/**
|
||||
* Send message to worker with random data
|
||||
* @param {Integer} size Number of bytes to send
|
||||
* @async
|
||||
*/
|
||||
AsyncProxy.prototype.seedRandom = async function(workerId, size) {
|
||||
const buf = await crypto.random.getRandomBytes(size);
|
||||
this.workers[workerId].postMessage({ event: 'seed-random', buf }, util.getTransferables(buf, true));
|
||||
};
|
||||
|
||||
/**
|
||||
* Clear key caches
|
||||
* @async
|
||||
*/
|
||||
AsyncProxy.prototype.clearKeyCache = async function() {
|
||||
await Promise.all(this.workers.map(worker => this.callWorker(worker, 'clear-key-cache')));
|
||||
};
|
||||
|
||||
/**
|
||||
* Terminates the workers
|
||||
*/
|
||||
AsyncProxy.prototype.terminate = function() {
|
||||
this.workers.forEach(worker => {
|
||||
worker.terminate();
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Generic proxy function that handles all commands from the public api.
|
||||
* @param {String} method the public api function to be delegated to the worker thread
|
||||
* @param {Object} options the api function's options
|
||||
* @returns {Promise} see the corresponding public api functions for their return types
|
||||
* @async
|
||||
*/
|
||||
AsyncProxy.prototype.delegate = async function (method, options) {
|
||||
const requests = this.workers.map(worker => worker.requests);
|
||||
const minRequests = Math.min(...requests);
|
||||
let workerId = 0;
|
||||
for (; workerId < this.workers.length; workerId++) {
|
||||
if (this.workers[workerId].requests === minRequests) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
const data = { options: packet.clone.clonePackets(options) };
|
||||
const transferables = util.getTransferables(data, config.zero_copy);
|
||||
const worker = this.workers[workerId];
|
||||
worker.requests++;
|
||||
const result = await this.callWorker(worker, method, data.options, transferables);
|
||||
return packet.clone.parseClonedPackets(util.restoreStreams(result, options.streaming), method);
|
||||
};
|
||||
|
||||
AsyncProxy.prototype.callWorker = function(worker, method, options, transferables) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const id = this.getID();
|
||||
|
||||
worker.postMessage({ id, method, options }, transferables);
|
||||
|
||||
this.tasks[id] = { resolve, reject };
|
||||
});
|
||||
};
|
||||
|
||||
export default AsyncProxy;
|
||||
|
|
@ -1,164 +0,0 @@
|
|||
// GPG4Browsers - An OpenPGP implementation in javascript
|
||||
// Copyright (C) 2011 Recurity Labs GmbH
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Lesser General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 3.0 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public
|
||||
// License along with this library; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
/* eslint-disable no-restricted-globals */
|
||||
/* eslint-disable no-var */
|
||||
/* eslint-disable vars-on-top */
|
||||
|
||||
/**
|
||||
* @fileoverview Provides functions for communicating with workers
|
||||
* @see module:openpgp.initWorker
|
||||
* @see module:openpgp.getWorker
|
||||
* @see module:openpgp.destroyWorker
|
||||
* @see module:worker/async_proxy
|
||||
* @module worker/worker
|
||||
*/
|
||||
|
||||
importScripts('openpgp.js');
|
||||
var openpgp = global.openpgp;
|
||||
|
||||
var randomQueue = [];
|
||||
var MAX_SIZE_RANDOM_BUFFER = 60000;
|
||||
|
||||
/**
|
||||
* Handle random buffer exhaustion by requesting more random bytes from the main window
|
||||
* @returns {Promise<Object>} Empty promise whose resolution indicates that the buffer has been refilled
|
||||
*/
|
||||
function randomCallback() {
|
||||
|
||||
if (!randomQueue.length) {
|
||||
self.postMessage({ event: 'request-seed', amount: MAX_SIZE_RANDOM_BUFFER });
|
||||
}
|
||||
|
||||
return new Promise(function(resolve) {
|
||||
randomQueue.push(resolve);
|
||||
});
|
||||
}
|
||||
|
||||
openpgp.crypto.random.randomBuffer.init(MAX_SIZE_RANDOM_BUFFER, randomCallback);
|
||||
|
||||
/**
|
||||
* Handle messages from the main window.
|
||||
* @param {Object} event Contains event type and data
|
||||
*/
|
||||
self.onmessage = function(event) {
|
||||
var msg = event.data || {};
|
||||
|
||||
switch (msg.method) {
|
||||
case 'seed-random':
|
||||
seedRandom(msg.buf);
|
||||
|
||||
var queueCopy = randomQueue;
|
||||
randomQueue = [];
|
||||
for (var i = 0; i < queueCopy.length; i++) {
|
||||
queueCopy[i]();
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
delegate(msg.id, msg.method, msg.options || {});
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Set config from main context to worker context.
|
||||
* @param {Object} config The openpgp configuration
|
||||
*/
|
||||
function configure(config) {
|
||||
Object.keys(config).forEach(function(key) {
|
||||
openpgp.config[key] = config[key];
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Seed the library with entropy gathered global.crypto.getRandomValues
|
||||
* as this api is only avalible in the main window.
|
||||
* @param {ArrayBuffer} buffer Some random bytes
|
||||
*/
|
||||
function seedRandom(buffer) {
|
||||
if (!(buffer instanceof Uint8Array)) {
|
||||
buffer = new Uint8Array(buffer);
|
||||
}
|
||||
openpgp.crypto.random.randomBuffer.set(buffer);
|
||||
}
|
||||
|
||||
const keyCache = new Map();
|
||||
function getCachedKey(key) {
|
||||
const armor = key.armor();
|
||||
if (keyCache.has(armor)) {
|
||||
return keyCache.get(armor);
|
||||
}
|
||||
keyCache.set(armor, key);
|
||||
return key;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generic proxy function that handles all commands from the public api.
|
||||
* @param {String} method The public api function to be delegated to the worker thread
|
||||
* @param {Object} options The api function's options
|
||||
*/
|
||||
function delegate(id, method, options) {
|
||||
if (method === 'configure') {
|
||||
configure(options);
|
||||
response({ id, event: 'method-return' });
|
||||
return;
|
||||
}
|
||||
if (method === 'clear-key-cache') {
|
||||
Array.from(keyCache.values()).forEach(key => {
|
||||
if (key.isPrivate()) {
|
||||
key.clearPrivateParams();
|
||||
}
|
||||
});
|
||||
keyCache.clear();
|
||||
response({ id, event: 'method-return' });
|
||||
return;
|
||||
}
|
||||
if (typeof openpgp[method] !== 'function') {
|
||||
response({ id:id, event:'method-return', err:'Unknown Worker Event' });
|
||||
return;
|
||||
}
|
||||
// construct ReadableStreams from MessagePorts
|
||||
openpgp.util.restoreStreams(options);
|
||||
// parse cloned packets
|
||||
options = openpgp.packet.clone.parseClonedPackets(options, method);
|
||||
// cache keys by armor, so that we don't have to repeatedly verify self-signatures
|
||||
if (options.publicKeys) {
|
||||
options.publicKeys = options.publicKeys.map(getCachedKey);
|
||||
}
|
||||
if (options.privateKeys) {
|
||||
options.privateKeys = options.privateKeys.map(getCachedKey);
|
||||
}
|
||||
openpgp[method](options, true).then(function(data) {
|
||||
// clone packets (for web worker structured cloning algorithm)
|
||||
response({ id:id, event:'method-return', data:openpgp.packet.clone.clonePackets(data) });
|
||||
}).catch(function(e) {
|
||||
openpgp.util.print_debug_error(e);
|
||||
response({
|
||||
id:id, event:'method-return', err:e.message, stack:e.stack
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Respond to the main window.
|
||||
* @param {Object} event Contains event type and data
|
||||
*/
|
||||
function response(event) {
|
||||
self.postMessage(event, openpgp.util.getTransferables(event.data, openpgp.config.zero_copy));
|
||||
}
|
||||
|
||||
|
|
@ -339,21 +339,4 @@ tryTests('Brainpool Omnibus Tests @lightweight', omnibus, {
|
|||
if: !openpgp.config.ci && (openpgp.config.use_indutny_elliptic || openpgp.util.getNodeCrypto())
|
||||
});
|
||||
|
||||
tryTests('Brainpool Omnibus Tests - Worker @lightweight', omnibus, {
|
||||
if: typeof window !== 'undefined' && window.Worker && (openpgp.config.use_indutny_elliptic || openpgp.util.getNodeCrypto()),
|
||||
before: async function() {
|
||||
try {
|
||||
await openpgp.initWorker({ path: '../dist/openpgp.worker.js' });
|
||||
} catch (e) {
|
||||
openpgp.util.print_debug_error(e);
|
||||
}
|
||||
},
|
||||
beforeEach: function() {
|
||||
openpgp.config.use_native = true;
|
||||
},
|
||||
after: function() {
|
||||
openpgp.destroyWorker();
|
||||
}
|
||||
});
|
||||
|
||||
// TODO find test vectors
|
||||
|
|
|
|||
|
|
@ -98,22 +98,5 @@ describe('Elliptic Curve Cryptography for NIST P-256,P-384,P-521 curves @lightwe
|
|||
expect(result.signatures[0].valid).to.be.true;
|
||||
});
|
||||
|
||||
tryTests('ECC Worker Tests', omnibus, {
|
||||
if: typeof window !== 'undefined' && window.Worker,
|
||||
before: async function() {
|
||||
try {
|
||||
await openpgp.initWorker({ path:'../dist/openpgp.worker.js' });
|
||||
} catch (e) {
|
||||
openpgp.util.print_debug_error(e);
|
||||
}
|
||||
},
|
||||
beforeEach: function() {
|
||||
openpgp.config.use_native = true;
|
||||
},
|
||||
after: function() {
|
||||
openpgp.destroyWorker();
|
||||
}
|
||||
});
|
||||
|
||||
// TODO find test vectors
|
||||
});
|
||||
|
|
|
|||
|
|
@ -2011,11 +2011,6 @@ function versionSpecificTests() {
|
|||
openpgp.config.prefer_hash_algorithm = openpgp.enums.hash.sha224;
|
||||
openpgp.config.compression = openpgp.enums.compression.zlib;
|
||||
openpgp.config.aead_mode = openpgp.enums.aead.experimental_gcm;
|
||||
if (openpgp.getWorker()) {
|
||||
openpgp.getWorker().workers.forEach(worker => {
|
||||
openpgp.getWorker().callWorker(worker, 'configure', openpgp.config);
|
||||
});
|
||||
}
|
||||
|
||||
const testPref = function(key) {
|
||||
// key flags
|
||||
|
|
@ -2055,11 +2050,6 @@ function versionSpecificTests() {
|
|||
openpgp.config.prefer_hash_algorithm = prefer_hash_algorithmVal;
|
||||
openpgp.config.compression = compressionVal;
|
||||
openpgp.config.aead_mode = aead_modeVal;
|
||||
if (openpgp.getWorker()) {
|
||||
openpgp.getWorker().workers.forEach(worker => {
|
||||
openpgp.getWorker().callWorker(worker, 'configure', openpgp.config);
|
||||
});
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
|
|
@ -2565,27 +2555,6 @@ describe('Key', function() {
|
|||
}
|
||||
});
|
||||
|
||||
tryTests('V4 - With Worker', versionSpecificTests, {
|
||||
if: typeof window !== 'undefined' && window.Worker,
|
||||
beforeEach: function() {
|
||||
v5_keysVal = openpgp.config.v5_keys;
|
||||
openpgp.config.v5_keys = false;
|
||||
},
|
||||
afterEach: function() {
|
||||
openpgp.config.v5_keys = v5_keysVal;
|
||||
},
|
||||
before: async function() {
|
||||
try {
|
||||
await openpgp.initWorker({ path: '../dist/openpgp.worker.js' });
|
||||
} catch (e) {
|
||||
openpgp.util.print_debug_error(e);
|
||||
}
|
||||
},
|
||||
after: function() {
|
||||
openpgp.destroyWorker();
|
||||
}
|
||||
});
|
||||
|
||||
tryTests('V5', versionSpecificTests, {
|
||||
if: !openpgp.config.ci,
|
||||
beforeEach: function() {
|
||||
|
|
|
|||
|
|
@ -467,11 +467,6 @@ function withCompression(tests) {
|
|||
return options;
|
||||
},
|
||||
function() {
|
||||
// Disable the call expectations when using the web worker because it's not possible to spy on what functions get called.
|
||||
if (openpgp.getWorker()) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (compression === openpgp.enums.compression.uncompressed) {
|
||||
expect(compressSpy.called).to.be.false;
|
||||
expect(decompressSpy.called).to.be.false;
|
||||
|
|
@ -502,28 +497,6 @@ describe('OpenPGP.js public api tests', function() {
|
|||
rsaGenStub.restore();
|
||||
});
|
||||
|
||||
describe('initWorker, getWorker, destroyWorker - unit tests', function() {
|
||||
afterEach(function() {
|
||||
openpgp.destroyWorker(); // cleanup worker in case of failure
|
||||
});
|
||||
|
||||
it('should work', async function() {
|
||||
const workerStub = {
|
||||
postMessage: function() {},
|
||||
terminate: function() {}
|
||||
};
|
||||
await Promise.all([
|
||||
openpgp.initWorker({
|
||||
workers: [workerStub]
|
||||
}),
|
||||
workerStub.onmessage({ data: { id: 0, event: 'method-return' } })
|
||||
]);
|
||||
expect(openpgp.getWorker()).to.exist;
|
||||
openpgp.destroyWorker();
|
||||
expect(openpgp.getWorker()).to.not.exist;
|
||||
});
|
||||
});
|
||||
|
||||
describe('generateKey - validate user ids', function() {
|
||||
it('should fail for invalid user name', async function() {
|
||||
const opt = {
|
||||
|
|
@ -634,7 +607,6 @@ describe('OpenPGP.js public api tests', function() {
|
|||
|
||||
afterEach(function() {
|
||||
keyGenStub.restore();
|
||||
openpgp.destroyWorker();
|
||||
getWebCryptoAllStub.restore();
|
||||
});
|
||||
|
||||
|
|
@ -661,30 +633,6 @@ describe('OpenPGP.js public api tests', function() {
|
|||
expect(newKey.publicKeyArmored).to.exist;
|
||||
});
|
||||
});
|
||||
|
||||
it('should delegate to async proxy', async function() {
|
||||
const workerStub = {
|
||||
postMessage: function() {},
|
||||
terminate: function() {}
|
||||
};
|
||||
await Promise.all([
|
||||
openpgp.initWorker({
|
||||
workers: [workerStub]
|
||||
}),
|
||||
workerStub.onmessage({ data: { id: 0, event: 'method-return' } })
|
||||
]);
|
||||
const proxyGenStub = stub(openpgp.getWorker(), 'delegate');
|
||||
getWebCryptoAllStub.returns();
|
||||
|
||||
const opt = {
|
||||
userIds: { name: 'Test User', email: 'text@example.com' },
|
||||
passphrase: 'secret',
|
||||
subkeys: []
|
||||
};
|
||||
openpgp.generateKey(opt);
|
||||
expect(proxyGenStub.calledOnce).to.be.true;
|
||||
expect(keyGenStub.calledOnce).to.be.false;
|
||||
});
|
||||
});
|
||||
|
||||
describe('generateKey - integration tests', function() {
|
||||
|
|
@ -696,30 +644,10 @@ describe('OpenPGP.js public api tests', function() {
|
|||
|
||||
afterEach(function() {
|
||||
openpgp.config.use_native = use_nativeVal;
|
||||
openpgp.destroyWorker();
|
||||
});
|
||||
|
||||
it('should work in JS (without worker)', function() {
|
||||
it('should work in JS', function() {
|
||||
openpgp.config.use_native = false;
|
||||
openpgp.destroyWorker();
|
||||
const opt = {
|
||||
userIds: [{ name: 'Test User', email: 'text@example.com' }],
|
||||
};
|
||||
|
||||
return openpgp.generateKey(opt).then(function(newKey) {
|
||||
expect(newKey.key.getUserIds()[0]).to.equal('Test User <text@example.com>');
|
||||
expect(newKey.publicKeyArmored).to.match(/^-----BEGIN PGP PUBLIC/);
|
||||
expect(newKey.privateKeyArmored).to.match(/^-----BEGIN PGP PRIVATE/);
|
||||
});
|
||||
});
|
||||
|
||||
it('should work in JS (with worker)', async function() {
|
||||
openpgp.config.use_native = false;
|
||||
try {
|
||||
await openpgp.initWorker({ path:'../dist/openpgp.worker.js' });
|
||||
} catch (e) {
|
||||
openpgp.util.print_debug_error(e);
|
||||
}
|
||||
const opt = {
|
||||
userIds: [{ name: 'Test User', email: 'text@example.com' }],
|
||||
};
|
||||
|
|
@ -755,7 +683,6 @@ describe('OpenPGP.js public api tests', function() {
|
|||
let privateKey;
|
||||
let publicKey;
|
||||
let publicKeyNoAEAD;
|
||||
let zero_copyVal;
|
||||
let use_nativeVal;
|
||||
let aead_protectVal;
|
||||
let aead_modeVal;
|
||||
|
|
@ -772,7 +699,6 @@ describe('OpenPGP.js public api tests', function() {
|
|||
publicKey_2038_2045 = privateKey_2038_2045.toPublic();
|
||||
privateKey_1337 = await openpgp.key.readArmored(priv_key_expires_1337);
|
||||
publicKey_1337 = privateKey_1337.toPublic();
|
||||
zero_copyVal = openpgp.config.zero_copy;
|
||||
use_nativeVal = openpgp.config.use_native;
|
||||
aead_protectVal = openpgp.config.aead_protect;
|
||||
aead_modeVal = openpgp.config.aead_mode;
|
||||
|
|
@ -781,7 +707,6 @@ describe('OpenPGP.js public api tests', function() {
|
|||
});
|
||||
|
||||
afterEach(function() {
|
||||
openpgp.config.zero_copy = zero_copyVal;
|
||||
openpgp.config.use_native = use_nativeVal;
|
||||
openpgp.config.aead_protect = aead_protectVal;
|
||||
openpgp.config.aead_mode = aead_modeVal;
|
||||
|
|
@ -792,9 +717,7 @@ describe('OpenPGP.js public api tests', function() {
|
|||
it('Configuration', async function() {
|
||||
openpgp.config.show_version = false;
|
||||
openpgp.config.commentstring = 'different';
|
||||
if (openpgp.getWorker()) { // init again to trigger config event
|
||||
await openpgp.initWorker({ path:'../dist/openpgp.worker.js' });
|
||||
}
|
||||
|
||||
return openpgp.encrypt({ publicKeys:publicKey, message:openpgp.message.fromText(plaintext) }).then(function(encrypted) {
|
||||
expect(encrypted).to.exist;
|
||||
expect(encrypted).not.to.match(/^Version:/);
|
||||
|
|
@ -802,48 +725,6 @@ describe('OpenPGP.js public api tests', function() {
|
|||
});
|
||||
});
|
||||
|
||||
it('Test multiple workers', async function() {
|
||||
openpgp.config.show_version = false;
|
||||
openpgp.config.commentstring = 'different';
|
||||
if (!openpgp.getWorker()) {
|
||||
return;
|
||||
}
|
||||
const { workers } = openpgp.getWorker();
|
||||
try {
|
||||
await privateKey.decrypt(passphrase)
|
||||
try {
|
||||
await openpgp.initWorker({path: '../dist/openpgp.worker.js', workers, n: 2});
|
||||
} catch (e) {
|
||||
openpgp.util.print_debug_error(e);
|
||||
}
|
||||
|
||||
const workerTest = (_, index) => {
|
||||
const plaintext = input.createSomeMessage() + index;
|
||||
return openpgp.encrypt({
|
||||
publicKeys: publicKey,
|
||||
data: plaintext
|
||||
}).then(function (encrypted) {
|
||||
expect(encrypted).to.exist;
|
||||
expect(encrypted).not.to.match(/^Version:/);
|
||||
expect(encrypted).to.match(/Comment: different/);
|
||||
return openpgp.decrypt({
|
||||
privateKeys: privateKey,
|
||||
message: openpgp.message.readArmored(encrypted)
|
||||
});
|
||||
}).then(function (decrypted) {
|
||||
expect(decrypted.data).to.equal(plaintext);
|
||||
});
|
||||
};
|
||||
await Promise.all(Array(10).fill(null).map(workerTest));
|
||||
} finally {
|
||||
try {
|
||||
await openpgp.initWorker({path: '../dist/openpgp.worker.js', workers, n: 1 });
|
||||
} catch (e) {
|
||||
openpgp.util.print_debug_error(e);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('Decrypting key with wrong passphrase rejected', async function () {
|
||||
await expect(privateKey.decrypt('wrong passphrase')).to.eventually.be.rejectedWith('Incorrect key passphrase');
|
||||
});
|
||||
|
|
@ -890,29 +771,12 @@ describe('OpenPGP.js public api tests', function() {
|
|||
});
|
||||
|
||||
tryTests('CFB mode (asm.js)', tests, {
|
||||
if: !(typeof window !== 'undefined' && window.Worker),
|
||||
if: true,
|
||||
beforeEach: function() {
|
||||
openpgp.config.aead_protect = false;
|
||||
}
|
||||
});
|
||||
|
||||
tryTests('CFB mode (asm.js, worker)', tests, {
|
||||
if: typeof window !== 'undefined' && window.Worker,
|
||||
before: async function() {
|
||||
try {
|
||||
await openpgp.initWorker({ path:'../dist/openpgp.worker.js' });
|
||||
} catch (e) {
|
||||
openpgp.util.print_debug_error(e);
|
||||
}
|
||||
},
|
||||
beforeEach: function() {
|
||||
openpgp.config.aead_protect = false;
|
||||
},
|
||||
after: function() {
|
||||
openpgp.destroyWorker();
|
||||
}
|
||||
});
|
||||
|
||||
tryTests('GCM mode (V5 keys)', tests, {
|
||||
if: true,
|
||||
beforeEach: function() {
|
||||
|
|
@ -1639,11 +1503,6 @@ describe('OpenPGP.js public api tests', function() {
|
|||
const badBodyEncrypted = data.replace(/\n=([a-zA-Z0-9/+]{4})/, 'aaa\n=$1');
|
||||
for (let allow_streaming = 1; allow_streaming >= 0; allow_streaming--) {
|
||||
openpgp.config.allow_unauthenticated_stream = !!allow_streaming;
|
||||
if (openpgp.getWorker()) {
|
||||
openpgp.getWorker().workers.forEach(worker => {
|
||||
openpgp.getWorker().callWorker(worker, 'configure', openpgp.config);
|
||||
});
|
||||
}
|
||||
await Promise.all([badSumEncrypted, badBodyEncrypted].map(async (encrypted, i) => {
|
||||
await Promise.all([
|
||||
encrypted,
|
||||
|
|
@ -1840,8 +1699,7 @@ describe('OpenPGP.js public api tests', function() {
|
|||
});
|
||||
});
|
||||
|
||||
it('should encrypt and decrypt with binary data and transferable objects', function () {
|
||||
openpgp.config.zero_copy = true; // activate transferable objects
|
||||
it('should encrypt and decrypt with binary data', function () {
|
||||
const encOpt = {
|
||||
message: openpgp.message.fromBinary(new Uint8Array([0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01])),
|
||||
passwords: password1,
|
||||
|
|
@ -1853,21 +1711,8 @@ describe('OpenPGP.js public api tests', function() {
|
|||
};
|
||||
return openpgp.encrypt(encOpt).then(async function (encrypted) {
|
||||
decOpt.message = await openpgp.message.read(encrypted);
|
||||
openpgp.config.zero_copy = false;
|
||||
if (openpgp.getWorker()) {
|
||||
openpgp.getWorker().workers.forEach(worker => {
|
||||
openpgp.getWorker().callWorker(worker, 'configure', openpgp.config);
|
||||
});
|
||||
}
|
||||
return openpgp.decrypt(decOpt);
|
||||
}).then(function (decrypted) {
|
||||
if (openpgp.getWorker()) {
|
||||
if (navigator.userAgent.indexOf('Safari') !== -1 && (navigator.userAgent.indexOf('Version/11.1') !== -1 || (navigator.userAgent.match(/Chrome\/(\d+)/) || [])[1] < 56)) {
|
||||
expect(encOpt.message.packets[0].data.byteLength).to.equal(8); // browser doesn't support transfering buffers
|
||||
} else {
|
||||
expect(encOpt.message.packets[0].data.byteLength).to.equal(0); // transferred buffer should be empty
|
||||
}
|
||||
}
|
||||
expect(decrypted.data).to.deep.equal(new Uint8Array([0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01]));
|
||||
expect(decrypted.signatures.length).to.equal(0);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1331,20 +1331,6 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
|
|||
|
||||
tests();
|
||||
|
||||
tryTests('With Worker', tests, {
|
||||
if: typeof window !== 'undefined' && window.Worker,
|
||||
before: async function() {
|
||||
try {
|
||||
await openpgp.initWorker({ path:'../dist/openpgp.worker.js' });
|
||||
} catch (e) {
|
||||
openpgp.util.print_debug_error(e);
|
||||
}
|
||||
},
|
||||
after: function() {
|
||||
openpgp.destroyWorker();
|
||||
}
|
||||
});
|
||||
|
||||
let reject_message_hash_algorithms;
|
||||
tryTests('Accept SHA-1 signatures', tests, {
|
||||
if: true,
|
||||
|
|
|
|||
|
|
@ -132,38 +132,6 @@ describe('Util unit tests', function() {
|
|||
});
|
||||
});
|
||||
|
||||
describe('getTransferables', function() {
|
||||
const buf1 = new Uint8Array(1);
|
||||
const buf2 = new Uint8Array(1);
|
||||
const obj = {
|
||||
data1: buf1,
|
||||
data2: buf1,
|
||||
data3: {
|
||||
data4: buf2
|
||||
}
|
||||
};
|
||||
|
||||
it('should return undefined when zero_copy is false', function() {
|
||||
openpgp.config.zero_copy = false;
|
||||
expect(openpgp.util.getTransferables(obj, false)).to.be.undefined;
|
||||
});
|
||||
it('should return undefined for no input', function() {
|
||||
expect(openpgp.util.getTransferables(undefined, true)).to.be.undefined;
|
||||
});
|
||||
it('should return undefined for an empty oject', function() {
|
||||
expect(openpgp.util.getTransferables({}, true)).to.be.undefined;
|
||||
});
|
||||
if (typeof navigator !== 'undefined') {
|
||||
it('should return two buffers', function() {
|
||||
expect(openpgp.util.getTransferables(obj, true)).to.deep.equal(
|
||||
navigator.userAgent.indexOf('Safari') !== -1 && (navigator.userAgent.indexOf('Version/11.1') !== -1 || (navigator.userAgent.match(/Chrome\/(\d+)/) || [])[1] < 56) ?
|
||||
undefined :
|
||||
[buf1.buffer, buf2.buffer]
|
||||
);
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
describe("Misc.", function() {
|
||||
it('util.readNumber should not overflow until full range of uint32', function () {
|
||||
const ints = [Math.pow(2, 20), Math.pow(2, 25), Math.pow(2, 30), Math.pow(2, 32) - 1];
|
||||
|
|
|
|||
|
|
@ -220,7 +220,7 @@ const input = require('./testInputs');
|
|||
expect(publicKey).to.deep.equal(openpgp.util.hex_to_Uint8Array(vector.PUBLIC_KEY));
|
||||
const data = util.str_to_Uint8Array(vector.MESSAGE);
|
||||
const keyIntegers = [
|
||||
openpgp.OID.fromClone(curve),
|
||||
new openpgp.OID(curve.oid),
|
||||
new openpgp.MPI(util.hex_to_str('40'+vector.PUBLIC_KEY)),
|
||||
new openpgp.MPI(util.hex_to_str(vector.SECRET_KEY))
|
||||
];
|
||||
|
|
@ -538,19 +538,3 @@ tryTests('X25519 Omnibus Tests', omnibus, {
|
|||
if: !openpgp.config.ci
|
||||
});
|
||||
|
||||
tryTests('X25519 Omnibus Tests - Worker', omnibus, {
|
||||
if: typeof window !== 'undefined' && window.Worker,
|
||||
before: async function() {
|
||||
try {
|
||||
await openpgp.initWorker({ path:'../dist/openpgp.worker.js' });
|
||||
} catch (e) {
|
||||
openpgp.util.print_debug_error(e);
|
||||
}
|
||||
},
|
||||
beforeEach: function() {
|
||||
openpgp.config.use_native = true;
|
||||
},
|
||||
after: function() {
|
||||
openpgp.destroyWorker();
|
||||
}
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,68 +0,0 @@
|
|||
/* globals tryTests: true */
|
||||
|
||||
const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../../dist/openpgp');
|
||||
|
||||
const chai = require('chai');
|
||||
|
||||
const { expect } = chai;
|
||||
|
||||
const pub_key =
|
||||
['-----BEGIN PGP PUBLIC KEY BLOCK-----',
|
||||
'Version: GnuPG v2.0.19 (GNU/Linux)',
|
||||
'',
|
||||
'mI0EUmEvTgEEANyWtQQMOybQ9JltDqmaX0WnNPJeLILIM36sw6zL0nfTQ5zXSS3+',
|
||||
'fIF6P29lJFxpblWk02PSID5zX/DYU9/zjM2xPO8Oa4xo0cVTOTLj++Ri5mtr//f5',
|
||||
'GLsIXxFrBJhD/ghFsL3Op0GXOeLJ9A5bsOn8th7x6JucNKuaRB6bQbSPABEBAAG0',
|
||||
'JFRlc3QgTWNUZXN0aW5ndG9uIDx0ZXN0QGV4YW1wbGUuY29tPoi5BBMBAgAjBQJS',
|
||||
'YS9OAhsvBwsJCAcDAgEGFQgCCQoLBBYCAwECHgECF4AACgkQSmNhOk1uQJQwDAP6',
|
||||
'AgrTyqkRlJVqz2pb46TfbDM2TDF7o9CBnBzIGoxBhlRwpqALz7z2kxBDmwpQa+ki',
|
||||
'Bq3jZN/UosY9y8bhwMAlnrDY9jP1gdCo+H0sD48CdXybblNwaYpwqC8VSpDdTndf',
|
||||
'9j2wE/weihGp/DAdy/2kyBCaiOY1sjhUfJ1GogF49rC4jQRSYS9OAQQA6R/PtBFa',
|
||||
'JaT4jq10yqASk4sqwVMsc6HcifM5lSdxzExFP74naUMMyEsKHP53QxTF0Grqusag',
|
||||
'Qg/ZtgT0CN1HUM152y7ACOdp1giKjpMzOTQClqCoclyvWOFB+L/SwGEIJf7LSCEr',
|
||||
'woBuJifJc8xAVr0XX0JthoW+uP91eTQ3XpsAEQEAAYkBPQQYAQIACQUCUmEvTgIb',
|
||||
'LgCoCRBKY2E6TW5AlJ0gBBkBAgAGBQJSYS9OAAoJEOCE90RsICyXuqIEANmmiRCA',
|
||||
'SF7YK7PvFkieJNwzeK0V3F2lGX+uu6Y3Q/Zxdtwc4xR+me/CSBmsURyXTO29OWhP',
|
||||
'GLszPH9zSJU9BdDi6v0yNprmFPX/1Ng0Abn/sCkwetvjxC1YIvTLFwtUL/7v6NS2',
|
||||
'bZpsUxRTg9+cSrMWWSNjiY9qUKajm1tuzPDZXAUEAMNmAN3xXN/Kjyvj2OK2ck0X',
|
||||
'W748sl/tc3qiKPMJ+0AkMF7Pjhmh9nxqE9+QCEl7qinFqqBLjuzgUhBU4QlwX1GD',
|
||||
'AtNTq6ihLMD5v1d82ZC7tNatdlDMGWnIdvEMCv2GZcuIqDQ9rXWs49e7tq1NncLY',
|
||||
'hz3tYjKhoFTKEIq3y3Pp',
|
||||
'=h/aX',
|
||||
'-----END PGP PUBLIC KEY BLOCK-----'].join('\n');
|
||||
|
||||
const plaintext = 'short message\nnext line\n한국어/조선말';
|
||||
let pubKey;
|
||||
|
||||
tryTests('Async Proxy', tests, {
|
||||
if: typeof window !== 'undefined' && window.Worker && window.MessageChannel,
|
||||
before: async function() {
|
||||
try {
|
||||
await openpgp.initWorker({ path:'../dist/openpgp.worker.js' });
|
||||
} catch (e) {
|
||||
openpgp.util.print_debug_error(e);
|
||||
}
|
||||
pubKey = await openpgp.key.readArmored(pub_key);
|
||||
},
|
||||
after: async function() {
|
||||
await openpgp.destroyWorker();
|
||||
}
|
||||
});
|
||||
|
||||
function tests() {
|
||||
|
||||
describe('Random number pipeline', function() {
|
||||
it('Random number buffer automatically reseeded', async function() {
|
||||
const worker = new Worker('../dist/openpgp.worker.js');
|
||||
const wProxy = new openpgp.AsyncProxy();
|
||||
try {
|
||||
await wProxy.init({ path:'../dist/openpgp.worker.js', workers: [worker] });
|
||||
} catch (e) {
|
||||
openpgp.util.print_debug_error(e);
|
||||
return;
|
||||
}
|
||||
return wProxy.delegate('encrypt', { publicKeys:[pubKey], message:openpgp.message.fromText(plaintext) });
|
||||
});
|
||||
});
|
||||
|
||||
}
|
||||
|
|
@ -1,5 +1,4 @@
|
|||
describe('Web Worker', function () {
|
||||
require('./async_proxy.js');
|
||||
require('./application_worker.js');
|
||||
});
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user