diff --git a/src/key.js b/src/key.js
index 31130995..ae303f38 100644
--- a/src/key.js
+++ b/src/key.js
@@ -933,24 +933,21 @@ export function readArmored(armoredText) {
  */
 export function generate(options) {
   var packetlist, secretKeyPacket, userIdPacket, dataToSign, signaturePacket, secretSubkeyPacket, subkeySignaturePacket;
+  return new Promise(resolve => resolve()).then(() => {
+    options.keyType = options.keyType || enums.publicKey.rsa_encrypt_sign;
+    if (options.keyType !== enums.publicKey.rsa_encrypt_sign) { // RSA Encrypt-Only and RSA Sign-Only are deprecated and SHOULD NOT be generated
+      throw new Error('Only RSA Encrypt or Sign supported');
+    }
 
-  options.keyType = options.keyType || enums.publicKey.rsa_encrypt_sign;
-  // RSA Encrypt-Only and RSA Sign-Only are deprecated and SHOULD NOT be generated
-  if (options.keyType !== enums.publicKey.rsa_encrypt_sign) {
-    throw new Error('Only RSA Encrypt or Sign supported');
-  }
-  // Key without passphrase is unlocked by definition
-  if (!options.passphrase) {
-    options.unlocked = true;
-  }
-  if (String.prototype.isPrototypeOf(options.userIds) || typeof options.userIds === 'string') {
-    options.userIds = [options.userIds];
-  }
+    if (!options.passphrase) { // Key without passphrase is unlocked by definition
+      options.unlocked = true;
+    }
+    if (String.prototype.isPrototypeOf(options.userIds) || typeof options.userIds === 'string') {
+      options.userIds = [options.userIds];
+    }
 
-  // generate
-  var genSecretKey = generateSecretKey();
-  var genSecretSubkey = generateSecretSubkey();
-  return Promise.all([genSecretKey, genSecretSubkey]).then(wrapKeyObject);
+    return Promise.all([generateSecretKey(), generateSecretSubkey()]).then(wrapKeyObject);
+  });
 
   function generateSecretKey() {
     secretKeyPacket = new packet.SecretKey();
diff --git a/src/message.js b/src/message.js
index f5f217d3..8ac585fe 100644
--- a/src/message.js
+++ b/src/message.js
@@ -92,26 +92,29 @@ Message.prototype.getSigningKeyIds = function() {
  * @return {Message}             new message with decrypted content
  */
 Message.prototype.decrypt = function(privateKey, sessionKey, password) {
-  var keyObj = sessionKey || this.decryptSessionKey(privateKey, password);
-  if (!keyObj || !util.isUint8Array(keyObj.data) || !util.isString(keyObj.algorithm)) {
-    throw new Error('Invalid session key for decryption.');
-  }
+  return new Promise(resolve => resolve()).then(() => {
+    const keyObj = sessionKey || this.decryptSessionKey(privateKey, password);
+    if (!keyObj || !util.isUint8Array(keyObj.data) || !util.isString(keyObj.algorithm)) {
+      throw new Error('Invalid session key for decryption.');
+    }
 
-  var symEncryptedPacketlist = this.packets.filterByTag(
-    enums.packet.symmetricallyEncrypted,
-    enums.packet.symEncryptedIntegrityProtected,
-    enums.packet.symEncryptedAEADProtected
-  );
+    const symEncryptedPacketlist = this.packets.filterByTag(
+      enums.packet.symmetricallyEncrypted,
+      enums.packet.symEncryptedIntegrityProtected,
+      enums.packet.symEncryptedAEADProtected
+    );
 
-  if (symEncryptedPacketlist.length !== 0) {
-    var symEncryptedPacket = symEncryptedPacketlist[0];
+    if (symEncryptedPacketlist.length === 0) {
+      return;
+    }
+
+    const symEncryptedPacket = symEncryptedPacketlist[0];
     return symEncryptedPacket.decrypt(keyObj.algorithm, keyObj.data).then(() => {
-      var resultMsg = new Message(symEncryptedPacket.packets);
+      const resultMsg = new Message(symEncryptedPacket.packets);
       symEncryptedPacket.packets = new packet.List(); // remove packets after decryption
       return resultMsg;
     });
-  }
-  return Promise.resolve();
+  });
 };
 
 /**
@@ -212,29 +215,31 @@ Message.prototype.getText = function() {
  * @return {Message}                   new message with encrypted content
  */
 Message.prototype.encrypt = function(keys, passwords) {
-  var symAlgo;
-  if (keys) {
-    symAlgo = keyModule.getPreferredSymAlgo(keys);
-  } else if (passwords) {
-    symAlgo = config.encryption_cipher;
-  } else {
-    throw new Error('No keys or passwords');
-  }
+  let symAlgo, msg, symEncryptedPacket;
+  return new Promise(resolve => resolve()).then(() => {
+    if (keys) {
+      symAlgo = keyModule.getPreferredSymAlgo(keys);
+    } else if (passwords) {
+      symAlgo = config.encryption_cipher;
+    } else {
+      throw new Error('No keys or passwords');
+    }
 
-  var sessionKey = crypto.generateSessionKey(enums.read(enums.symmetric, symAlgo));
-  var msg = encryptSessionKey(sessionKey, enums.read(enums.symmetric, symAlgo), keys, passwords);
+    let sessionKey = crypto.generateSessionKey(enums.read(enums.symmetric, symAlgo));
+    msg = encryptSessionKey(sessionKey, enums.read(enums.symmetric, symAlgo), keys, passwords);
 
-  var symEncryptedPacket;
-  if (config.aead_protect) {
-    symEncryptedPacket = new packet.SymEncryptedAEADProtected();
-  } else if (config.integrity_protect) {
-    symEncryptedPacket = new packet.SymEncryptedIntegrityProtected();
-  } else {
-    symEncryptedPacket = new packet.SymmetricallyEncrypted();
-  }
-  symEncryptedPacket.packets = this.packets;
+    if (config.aead_protect) {
+      symEncryptedPacket = new packet.SymEncryptedAEADProtected();
+    } else if (config.integrity_protect) {
+      symEncryptedPacket = new packet.SymEncryptedIntegrityProtected();
+    } else {
+      symEncryptedPacket = new packet.SymmetricallyEncrypted();
+    }
+    symEncryptedPacket.packets = this.packets;
 
-  return symEncryptedPacket.encrypt(enums.read(enums.symmetric, symAlgo), sessionKey).then(() => {
+    return symEncryptedPacket.encrypt(enums.read(enums.symmetric, symAlgo), sessionKey);
+
+  }).then(() => {
     msg.packets.push(symEncryptedPacket);
     symEncryptedPacket.packets = new packet.List(); // remove packets after encryption
     return msg;