Use generic AsyncProxy.delegate for all public apis

src/openpgp.js

@@ -213,7 +213,7 @@ export function sign({ data, privateKeys }) {
   privateKeys = toArray(privateKeys);
 
   if (asyncProxy) { // use web worker if available
-    return asyncProxy.sign({ data, privateKeys });
+    return asyncProxy.delegate('sign', { data, privateKeys });
   }
 
   return execute(() => {
@@ -240,7 +240,7 @@ export function verify({ message, publicKeys }) {
   publicKeys = toArray(publicKeys);
 
   if (asyncProxy) { // use web worker if available
-    return asyncProxy.verify({ message, publicKeys });
+    return asyncProxy.delegate('verify', { message, publicKeys });
   }
 
   return execute(() => ({
@@ -270,7 +270,7 @@ export function verify({ message, publicKeys }) {
  */
 export function encryptSessionKey({ sessionKey, algo, publicKeys, passwords }) {
   if (asyncProxy) { // use web worker if available
-    return asyncProxy.encryptSessionKey({ sessionKey, algo, publicKeys, passwords });
+    return asyncProxy.delegate('encryptSessionKey', { sessionKey, algo, publicKeys, passwords });
   }
 
   return execute(() => ({
@@ -294,7 +294,7 @@ export function encryptSessionKey({ sessionKey, algo, publicKeys, passwords }) {
  */
 export function decryptSessionKey({ message, privateKey, sessionKey, password }) {
   if (asyncProxy) { // use web worker if available
-    return asyncProxy.decryptSessionKey({ message, privateKey, sessionKey, password });
+    return asyncProxy.delegate('decryptSessionKey', { message, privateKey, sessionKey, password });
   }
 
   return execute(() => message.decryptSessionKey(privateKey, sessionKey, password), 'Error decrypting session key');

src/worker/async_proxy.js

@@ -167,78 +167,6 @@ function parseClonedPackets(data) {
   return data;
 }
 
-AsyncProxy.prototype.encryptSessionKey = function({ sessionKey, algo, keys, passwords }) {
-  return this.execute(() => {
-    if(keys) {
-      keys = keys.length ? keys : [keys];
-      keys = keys.map(key => key.toPacketlist());
-    }
-    this.worker.postMessage({ event:'encrypt-session-key', sessionKey, algo, keys, passwords });
-  });
-};
-
-AsyncProxy.prototype.decryptSessionKey = function(privateKey, message) {
-  var self = this;
-
-  return self.execute(function() {
-    if(!(String.prototype.isPrototypeOf(privateKey) || typeof privateKey === 'string')) {
-      privateKey = privateKey.toPacketlist();
-    }
-
-    self.worker.postMessage({
-      event: 'decrypt-session-key',
-      privateKey: privateKey,
-      message: message
-    });
-  });
-};
-
-AsyncProxy.prototype.signClearMessage = function(privateKeys, text) {
-  var self = this;
-
-  return self.execute(function() {
-    if (!privateKeys.length) {
-      privateKeys = [privateKeys];
-    }
-    privateKeys = privateKeys.map(function(key) {
-      return key.toPacketlist();
-    });
-    self.worker.postMessage({
-      event: 'sign-clear-message',
-      privateKeys: privateKeys,
-      text: text
-    });
-  });
-};
-
-AsyncProxy.prototype.verifyClearSignedMessage = function(publicKeys, message) {
-  var self = this;
-
-  var promise = new Promise(function(resolve, reject) {
-    if (!publicKeys.length) {
-      publicKeys = [publicKeys];
-    }
-    publicKeys = publicKeys.map(function(key) {
-      return key.toPacketlist();
-    });
-    self.worker.postMessage({
-      event: 'verify-clear-signed-message',
-      publicKeys: publicKeys,
-      message: message
-    });
-
-    self.tasks.push({ resolve:function(data) {
-      data.signatures = data.signatures.map(function(sig) {
-        sig.keyid = type_keyid.fromClone(sig.keyid);
-        return sig;
-      });
-      resolve(data);
-    }, reject:reject });
-  });
-
-  return promise;
-};
-
 AsyncProxy.prototype.decryptKey = function(privateKey, password) {
   var self = this;
 

src/worker/worker.js

@@ -69,64 +69,6 @@ self.onmessage = function (event) {
       window.openpgp.crypto.random.randomBuffer.set(msg.buf);
       break;
 
-    case 'generateKey':
-    case 'encrypt':
-    case 'decrypt':
-      // parse cloned packets
-      window.openpgp[msg.event](parseClonedPackets(opt)).then(function(data) {
-        // clone packets (for web worker structured cloning algorithm)
-        response({ event:'method-return', data:clonePackets(data) });
-      }).catch(function(e) {
-        response({ event:'method-return', err:e.message });
-      });
-      break;
-
-    case 'encrypt-session-key':
-      if(msg.keys) {
-        msg.keys = msg.keys.map(packetlistCloneToKey);
-      }
-      window.openpgp.encryptSessionKey(msg.sessionKey, msg.algo, msg.keys, msg.passwords).then(function(data) {
-        response({event: 'method-return', data: data});
-      }).catch(function(e) {
-        response({event: 'method-return', err: e.message});
-      });
-      break;
-
-    case 'decrypt-session-key':
-      if(!(String.prototype.isPrototypeOf(msg.privateKey) || typeof msg.privateKey === 'string')) {
-        msg.privateKey = packetlistCloneToKey(msg.privateKey);
-      }
-      msg.message = packetlistCloneToMessage(msg.message.packets);
-      window.openpgp.decryptSessionKey(msg.privateKey, msg.message).then(function(data) {
-        response({event: 'method-return', data: data});
-      }).catch(function(e) {
-        response({event: 'method-return', err: e.message});
-      });
-      break;
-
-    case 'sign-clear-message':
-      msg.privateKeys = msg.privateKeys.map(packetlistCloneToKey);
-      window.openpgp.signClearMessage(msg.privateKeys, msg.text).then(function(data) {
-        response({event: 'method-return', data: data});
-      }).catch(function(e) {
-        response({event: 'method-return', err: e.message});
-      });
-      break;
-
-    case 'verify-clear-signed-message':
-      if (!msg.publicKeys.length) {
-        msg.publicKeys = [msg.publicKeys];
-      }
-      msg.publicKeys = msg.publicKeys.map(packetlistCloneToKey);
-      var packetlist = window.openpgp.packet.List.fromStructuredClone(msg.message.packets);
-      msg.message = new window.openpgp.cleartext.CleartextMessage(msg.message.text, packetlist);
-      window.openpgp.verifyClearSignedMessage(msg.publicKeys, msg.message).then(function(data) {
-        response({event: 'method-return', data: data});
-      }).catch(function(e) {
-        response({event: 'method-return', err: e.message});
-      });
-      break;
-
     case 'decrypt-key':
       try {
         msg.privateKey = packetlistCloneToKey(msg.privateKey);
@@ -158,12 +100,28 @@ self.onmessage = function (event) {
       response({event: 'method-return', data: data, err: err});
       break;
 
+    case 'generateKey':
+    case 'encrypt':
+    case 'decrypt':
+    case 'sign':
+    case 'verify':
+    case 'encryptSessionKey':
+    case 'decryptSessionKey':
+      // parse cloned packets
+      window.openpgp[msg.event](parseClonedPackets(opt, msg.event)).then(function(data) {
+        // clone packets (for web worker structured cloning algorithm)
+        response({ event:'method-return', data:clonePackets(data) });
+      }).catch(function(e) {
+        response({ event:'method-return', err:e.message });
+      });
+      break;
+
     default:
       throw new Error('Unknown Worker Event.');
   }
 };
 
-function parseClonedPackets(options) {
+function parseClonedPackets(options, method) {
   if(options.publicKeys) {
     options.publicKeys = options.publicKeys.map(packetlistCloneToKey);
   }
@@ -173,12 +131,30 @@ function parseClonedPackets(options) {
   if(options.privateKey) {
     options.privateKey = packetlistCloneToKey(options.privateKey);
   }
-  if (options.message) {
+  // parse message depending on method
-    options.message = packetlistCloneToMessage(options.message.packets);
+  if (options.message && method === 'verify') {
+    options.message = packetlistCloneToCleartextMessage(options.message);
+  } else if (options.message) {
+    options.message = packetlistCloneToMessage(options.message);
   }
   return options;
 }
 
+function packetlistCloneToKey(packetlistClone) {
+  var packetlist = window.openpgp.packet.List.fromStructuredClone(packetlistClone);
+  return new window.openpgp.key.Key(packetlist);
+}
+
+function packetlistCloneToMessage(message) {
+  var packetlist = window.openpgp.packet.List.fromStructuredClone(message.packets);
+  return new window.openpgp.message.Message(packetlist);
+}
+
+function packetlistCloneToCleartextMessage(message) {
+  var packetlist = window.openpgp.packet.List.fromStructuredClone(message.packets);
+  return new window.openpgp.cleartext.CleartextMessage(message.text, packetlist);
+}
+
 function clonePackets(data) {
   if (data.key) {
     data.key = data.key.toPacketlist();
@@ -191,14 +167,4 @@ function response(event) {
     postMessage({event: 'request-seed'});
   }
   postMessage(event);
-}
-
-function packetlistCloneToKey(packetlistClone) {
-  var packetlist = window.openpgp.packet.List.fromStructuredClone(packetlistClone);
-  return new window.openpgp.key.Key(packetlist);
-}
-
-function packetlistCloneToMessage(packetlistClone) {
-  var packetlist = window.openpgp.packet.List.fromStructuredClone(packetlistClone);
-  return new window.openpgp.message.Message(packetlist);
 }