@sendsafely/sendsafely 2.0.1 → 2.0.3

package/lib/FileUtil.js

@@ -23,13 +23,9 @@ function FileUtil(param) {
     this.SEGMENT_SIZE = 2621440;
     this.filePath = param.filePath;
     this.callback = param.callback;
-    this.file = {size: 0, name: '', totalParts: 0};
-    this.readableStream = fs.createReadStream(myself.filePath);
-    this.reading = false;
     this.eof = false;
     this.data = [];
     this.tempSize = 0;
-    this.part = 1;
 
     this.init = function() {
         return new Promise(function(resolve) {
@@ -37,20 +33,9 @@ function FileUtil(param) {
                 if (err) {
                     throw new Error('FileUtil: File does not exist, ' + myself.filePath);
                 } else {
-                    myself.file.size = stats.size;
-                    myself.file.name =  path.basename(myself.filePath);
-
-                    if(myself.file.size > (myself.SEGMENT_SIZE/4)) {
-                        myself.file.totalParts = 1 + Math.ceil((myself.file.size-(myself.SEGMENT_SIZE/4))/myself.SEGMENT_SIZE);
-                    } else {
-                        myself.file.totalParts = 1;
-                    }
-
-                    resolve(myself.file);
-
-                    myself.readableStream.on('readable', function() {
-                        // keep reading chunk until it reaches SEGMENT_SIZE
-                        if(myself.reading && !myself.eof) {
+                    myself.readableStream = fs.createReadStream(myself.filePath);
+                    myself.readableStream.on('readable', function () {
+                        if (myself.waitingForRead) {
                             processChunk();
                         }
                     });
@@ -58,15 +43,19 @@ function FileUtil(param) {
                     myself.readableStream.on('end', function() {
                         // done reading file
                         myself.eof = true;
-                        if(myself.part === myself.file.totalParts) {
-                            callback(true);
-                        } else {
-                            // increment extra part if file size is less than segment/4
-                            // so that we callback with an empty array
-                            myself.part++;
-                            callback(false);
+                        if (myself.waitingForRead) {
+                            // Handle timing edge case where 'end' fires while a read is pending
+                            processChunk();
                         }
                     });
+
+                    const totalParts = stats.size === 0 ? 1 : Math.ceil(stats.size / myself.SEGMENT_SIZE);
+
+                    resolve({
+                        name: path.basename(myself.filePath),
+                        size: stats.size,
+                        totalParts: totalParts,
+                    });
                 }
             });
 
@@ -74,34 +63,36 @@ function FileUtil(param) {
     }
 
     this.read = function() {
-        if(!myself.reading && !myself.eof) {
-            myself.reading = true;
-            processChunk();
-        } else if(myself.part === myself.file.totalParts) {
-            //extra part padding with empty array if file size is less than segment/4
-            callback(true);
+        if (myself.eof && myself.tempSize === 0) {
+            return;
         }
+
+        myself.waitingForRead = true;
+        processChunk();
     }
 
     function processChunk() {
-        if(myself.tempSize === myself.SEGMENT_SIZE) {
-            myself.part++;
-            // callback when data size reaches SEGMENT_SIZE
-            callback(false);
-        } else {
-            let chunk = myself.readableStream.read();
-            if(chunk !== null) {
-                myself.data.push(new Uint8Array(chunk));
-                myself.tempSize += chunk.length;
-            }
+        let chunk;
+        while ((chunk = myself.readableStream.read()) !== null) { // Completely drain the stream's internal buffer
+            myself.data.push(new Uint8Array(chunk));
+            myself.tempSize += chunk.length;
         }
-    }
 
-    function callback(isComplete) {
-        myself.tempSize = 0;
-        myself.reading = false;
-        myself.callback({data: concatenate(myself.data), complete: isComplete});
-        myself.data = [];
+        if (myself.tempSize >= myself.SEGMENT_SIZE || myself.eof) {
+            if (myself.tempSize > 0) {
+                // We have a full segment
+                const buf = concatenate(myself.data);
+                const seg = buf.slice(0, myself.SEGMENT_SIZE);
+                const remainder = buf.slice(myself.SEGMENT_SIZE);
+                myself.data = remainder.length > 0 ? [remainder] : [];
+                myself.tempSize = remainder.length;
+                myself.callback({data: seg, complete: myself.eof && myself.tempSize === 0});
+            } else {
+                // Emit an empty final segment to signal completion & handles empty files
+                myself.callback({data: new Uint8Array(0), complete: true});
+            }
+            myself.waitingForRead = false;
+        }
     }
 
     function concatenate(arrays) {

package/lib/SendSafely.js

@@ -1,4 +1,6 @@
 const URL = require('url').URL;
+const { ReadableStream, WritableStream, TransformStream } = require('stream/web');
+Object.assign(globalThis, {ReadableStream, WritableStream, TransformStream});
 const Window = require('./window');
 const window = new Window();
 const self = window;
@@ -3941,7 +3943,7 @@ function GenerateKeyPair(eventHandler) {
   }
 
   function buildNameStr() {
-    return {name:myself.NAME, email:myself.EMAIL};
+    return myself.NAME + ' <' + myself.EMAIL + '>';
   }
 
 }

package/lib/keyGeneratorWorker.js

@@ -1,47 +1,40 @@
-if(typeof window === 'undefined') {
+try {
+  if (window === undefined) {
+    window = globalThis;
+  }
+} catch (err) {
   window = {};
 }
 
-window.crypto = {
-  getRandomValues: function (buf) {
-    for(var i = 0; i<buf.length; i++)
-    {
-      if((self.randomCounter%20) === 0) {
-        reportProgress(self.randomCounter);
-      }
-      if((self.randomCounter % 512) === 0)
-      {
-        self.send({'cmd': 'randBuff', 'bytes': 64});
-      }
-      buf[i] = self.randomness[self.randomCounter++].charCodeAt();
-    }
-  }
-};
-
-self.randomCounter = 0;
-
-self.addEventListener('message', async function(e) {
+self.addEventListener('message', function(e) {
   var data = e.data;
   switch (data.cmd) {
     case 'generate_key':
       debug("Starting to generate key..");
-      self.randomCounter = 0;
-      self.randomness = data.randomness;
 
-      var bits = data.bits;
       var userStr = data.userStr;
+      var splitUserStr = userStr.split('<');
+      var userObj = {};
+      if (splitUserStr.length > 1) {
+        var name = splitUserStr[0].substring(0, splitUserStr[0].length-1);
+        var email = splitUserStr[1].substring(0, splitUserStr[1].length-1);
+        userObj = {
+          email: email,
+          name: name
+        }
+      }
+
+      var options = {};
+      options.rsaBits = 2048;
+      options.type = 'rsa';
+      options.userIDs = [userObj];
+      options.format = 'armored';
+      options.config = {showComment: true, showVersion: true};
 
-      
-      var options = 
-      {
-	    userIds: [userStr], // multiple user IDs
-	    numBits: 2048
-	  };
-      
       openpgp.generateKey(options).then(function(key) {
-        var privateKey = key.privateKeyArmored;
-        var publicKey = key.publicKeyArmored;
-        
+        debug("Generated key!");
+        var privateKey = key.privateKey;
+        var publicKey = key.publicKey;
         self.send({'cmd': 'key_generated', 'privateKey': privateKey, 'publicKey': publicKey});
       }, function(err) {
         debug("An Unknown Error Occurred While Generating the key");
@@ -49,66 +42,119 @@ self.addEventListener('message', async function(e) {
       });
       break;
     case 'convert_key':
-      self.randomCounter = 0;
-      self.randomness = data.randomness;
       var result = convertRawKey(data.rsaKeys, data.userStr);
       self.send({'cmd': 'key_converted', 'privateKey': result.privateKeyArmored, 'publicKey': result.publicKeyArmored});
       break;
     case 'encrypt_keycode':
-      self.randomCounter = 0;
-      self.randomness = data.randomness;
-
       debug(data.publicKey);
-      var publicKeys = await openpgp.key.readArmored(data.publicKey);
-      
-      if(publicKeys.keys.length > 0) {
-        var pubKey = publicKeys.keys[0];
-        
-        var options = {
-    		message: openpgp.message.fromText(data.keyCode),
-    		publicKeys: [pubKey]
-        }
-
-        openpgp.encrypt(options).then(function(encryptedMessage) {
-          self.send({'cmd': 'keycode_encrypted', 'encryptedKeyCode': encryptedMessage.data});
-        }, function(err) {
-          debug('ERROR');
-          debug(err);
-        });
-      }
+      // Read in armored keys
+      openpgp.readKeys({"armoredKeys": data.publicKey})
+          .then(function(publicKeys) {
+            if(publicKeys.length > 0) {
+              // Create open PGP message
+              openpgp.createMessage({"text": data.keyCode})
+                  .then(function(message) {
+                    var options = {
+                      message,
+                      encryptionKeys: publicKeys,
+                      config: {
+                        s2kIterationCountByte: 96,
+                        allowMissingKeyFlags: true
+                      }
+                    }
+
+                    // Encrypt open PGP message
+                    openpgp.encrypt(options)
+                        .then(function(encryptedMessage) {
+                          self.send({'cmd': 'keycode_encrypted', 'encryptedKeyCode': encryptedMessage});
+                        }, function(err) {
+                          debug('ERROR');
+                          debug(err);
+                          sendError(err);
+                        });
+                  }, function(err) {
+                    debug('ERROR');
+                    debug(err);
+                    sendError(err);
+                  });
+            }
+          }, function(err) {
+            console.error(err);
+            sendError(err);
+          });
       break;
     case 'decrypt_keycode':
-      try {
-        self.randomCounter = 0;
-        self.randomness = data.randomness;
-        var privKeys = await openpgp.key.readArmored(data.privateKey);
-        privKey = privKeys.keys[0];
-        var message = await openpgp.message.readArmored(data.keyCode);
-
-        options =
-            {
-              message: message,   // parse armored message
-              privateKeys: [privKey]                                 // for decryption
-            };
-
-        openpgp.decrypt(options).then(function(plaintext) {
-          self.send({'cmd': 'keycode_decrypted', 'decryptedKeycode': plaintext.data});
-        }, function(err) {
-          debug('ERROR');
-          debug(err);
-          sendError(err);
-        });
-      } catch (err) {
-        sendError(err);
-      }
+      decryptKeycode(data.privateKey, data.keyCode, 0);
       break;
-    case 'randBuff':
-      self.randomness += data.randomness;
     default:
       ;
   };
 }, false);
 
+function decryptKeycode(privateKey, keyCode, failback) {
+  // read in armored private key
+  openpgp.readKeys({"armoredKeys": privateKey}).then(function (privateKeys) {
+    if (privateKeys != undefined && privateKeys.length > 0) {
+      // Read encrypted message from key code
+      openpgp.readMessage({"armoredMessage": keyCode}).then(async function (encryptedMessage) {
+        let options = {
+          message: encryptedMessage,
+          decryptionKeys: privateKeys
+        }
+        if (failback === 1) {
+          options.config = {
+            allowInsecureDecryptionWithSigningKeys: true
+          }
+        } else if (failback === 2) {
+          options.config = {
+            allowInsecureDecryptionWithSigningKeys: true,
+            allowUnauthenticatedMessages: true
+          }
+        } else if (failback === 3) {
+          options.config = {
+            allowMissingKeyFlags: true
+          }
+        } else if (failback === 4) {
+          options.config = {
+            allowInsecureDecryptionWithSigningKeys: true,
+            allowUnauthenticatedMessages: true,
+            allowMissingKeyFlags: true
+          }
+        }
+        try {
+          let {data: decrypted} = await openpgp.decrypt(options);
+          self.send({'cmd': 'keycode_decrypted', 'decryptedKeycode': decrypted});
+        } catch (e) {
+          if (e.message === 'Error decrypting message: No decryption key packets found') {
+            // this might be a keycode encrypted with our old Java or .NET API that was incorrectly encrypting keycodes with the signing key
+            // update the config to bypass this and try again.
+            decryptKeycode(privateKey, keyCode, 1)
+          } else if (e.message === 'Error decrypting message: Message is not authenticated.' && failback !== 3) {
+            // this might be a keycode encrypted with our old Java API that wasn't setting setWithIntegrity = true.
+            // update the config to bypass this and try again.
+            decryptKeycode(privateKey, keyCode, 2)
+          } else if (e.message === 'Error decrypting message: None of the key flags is set: consider passing `config.allowMissingKeyFlags`') {
+            // this might be a keycode encrypted with an incorrectly formatted SCEAR key
+            // update the config to bypass this and try again.
+            decryptKeycode(privateKey, keyCode, 3)
+          } else if (e.message === 'Error decrypting message: Message is not authenticated.' && failback === 3) {
+            // this might be a keycode encrypted with our old Java API that wasn't setting setWithIntegrity = true,
+            // and the keycode was encrypted with an incorrectly formatted SCEAR key
+            // update the config to bypass this and try again.
+            decryptKeycode(privateKey, keyCode, 4)
+          } else {
+            // something else is the issue so log it
+            debug('ERROR');
+            debug(e);
+            console.log(e);
+            sendError(e);
+          }
+        }
+      });
+    }
+  });
+}
+
 function convertRawKey(rsaKeys, userStr) {
 
   var secretKey = createSecretKey(rsaKeys.privateKey);
@@ -125,33 +171,33 @@ function convertRawKey(rsaKeys, userStr) {
 
 function wrapKeyObject(userId, secretKeyPacket, secretSubkeyPacket)
 {
-  packetlist = new window.openpgp.packet.List();
+  var packetlist = new openpgp.PacketList();
 
-  userIdPacket = new window.openpgp.packet.Userid();
+  var userIdPacket = new openpgp.UserIDPacket();
   userIdPacket.read(userId);
 
   dataToSign = {};
   dataToSign.userid = userIdPacket;
   dataToSign.key = secretKeyPacket;
-  signaturePacket = new window.openpgp.packet.Signature();
-  signaturePacket.signatureType = window.openpgp.enums.signature.cert_generic;
-  signaturePacket.publicKeyAlgorithm = window.openpgp.enums.publicKey.rsa_encrypt_sign;
-  signaturePacket.hashAlgorithm = window.openpgp.config.prefer_hash_algorithm;
-  signaturePacket.keyFlags = [window.openpgp.enums.keyFlags.certify_keys | window.openpgp.enums.keyFlags.sign_data];
+  var signaturePacket = new openpgp.Signature();
+  signaturePacket.signatureType = openpgp.enums.signature.cert_generic;
+  signaturePacket.publicKeyAlgorithm = openpgp.enums.publicKey.rsa_encrypt_sign;
+  signaturePacket.hashAlgorithm = openpgp.config.prefer_hash_algorithm;
+  signaturePacket.keyFlags = [openpgp.enums.keyFlags.certify_keys | openpgp.enums.keyFlags.sign_data];
   signaturePacket.preferredSymmetricAlgorithms = [];
-  signaturePacket.preferredSymmetricAlgorithms.push(window.openpgp.enums.symmetric.aes256);
-  signaturePacket.preferredSymmetricAlgorithms.push(window.openpgp.enums.symmetric.aes192);
-  signaturePacket.preferredSymmetricAlgorithms.push(window.openpgp.enums.symmetric.aes128);
-  signaturePacket.preferredSymmetricAlgorithms.push(window.openpgp.enums.symmetric.cast5);
-  signaturePacket.preferredSymmetricAlgorithms.push(window.openpgp.enums.symmetric.tripledes);
+  signaturePacket.preferredSymmetricAlgorithms.push(openpgp.enums.symmetric.aes256);
+  signaturePacket.preferredSymmetricAlgorithms.push(openpgp.enums.symmetric.aes192);
+  signaturePacket.preferredSymmetricAlgorithms.push(openpgp.enums.symmetric.aes128);
+  signaturePacket.preferredSymmetricAlgorithms.push(openpgp.enums.symmetric.cast5);
+  signaturePacket.preferredSymmetricAlgorithms.push(openpgp.enums.symmetric.tripledes);
   signaturePacket.preferredHashAlgorithms = [];
-  signaturePacket.preferredHashAlgorithms.push(window.openpgp.enums.hash.sha256);
-  signaturePacket.preferredHashAlgorithms.push(window.openpgp.enums.hash.sha1);
-  signaturePacket.preferredHashAlgorithms.push(window.openpgp.enums.hash.sha512);
+  signaturePacket.preferredHashAlgorithms.push(openpgp.enums.hash.sha256);
+  signaturePacket.preferredHashAlgorithms.push(openpgp.enums.hash.sha1);
+  signaturePacket.preferredHashAlgorithms.push(openpgp.enums.hash.sha512);
   signaturePacket.preferredCompressionAlgorithms = [];
-  signaturePacket.preferredCompressionAlgorithms.push(window.openpgp.enums.compression.zlib);
-  signaturePacket.preferredCompressionAlgorithms.push(window.openpgp.enums.compression.zip);
-  if (window.openpgp.config.integrity_protect) {
+  signaturePacket.preferredCompressionAlgorithms.push(openpgp.enums.compression.zlib);
+  signaturePacket.preferredCompressionAlgorithms.push(openpgp.enums.compression.zip);
+  if (openpgp.config.integrity_protect) {
     signaturePacket.features = [];
     signaturePacket.features.push(1); // Modification Detection
   }
@@ -160,11 +206,11 @@ function wrapKeyObject(userId, secretKeyPacket, secretSubkeyPacket)
   dataToSign = {};
   dataToSign.key = secretKeyPacket;
   dataToSign.bind = secretSubkeyPacket;
-  subkeySignaturePacket = new window.openpgp.packet.Signature();
-  subkeySignaturePacket.signatureType = window.openpgp.enums.signature.subkey_binding;
-  subkeySignaturePacket.publicKeyAlgorithm = window.openpgp.enums.publicKey.rsa_encrypt_sign;
-  subkeySignaturePacket.hashAlgorithm = window.openpgp.config.prefer_hash_algorithm;
-  subkeySignaturePacket.keyFlags = [window.openpgp.enums.keyFlags.encrypt_communication | window.openpgp.enums.keyFlags.encrypt_storage];
+  var subkeySignaturePacket = new openpgp.Signature();
+  subkeySignaturePacket.signatureType = openpgp.enums.signature.subkey_binding;
+  subkeySignaturePacket.publicKeyAlgorithm = openpgp.enums.publicKey.rsa_encrypt_sign;
+  subkeySignaturePacket.hashAlgorithm = openpgp.config.prefer_hash_algorithm;
+  subkeySignaturePacket.keyFlags = [openpgp.enums.keyFlags.encrypt_communication | openpgp.enums.keyFlags.encrypt_storage];
   subkeySignaturePacket.sign(secretKeyPacket, dataToSign);
 
   packetlist.push(secretKeyPacket);
@@ -173,20 +219,20 @@ function wrapKeyObject(userId, secretKeyPacket, secretSubkeyPacket)
   packetlist.push(secretSubkeyPacket);
   packetlist.push(subkeySignaturePacket);
 
-  return new window.openpgp.key.Key(packetlist);
+  return new openpgp.Key(packetlist);
 }
 
 function createSecretKey(key)
 {
   var mpiList = createMPIList(key);
-  var packet = createSecretKeyPacketFromList(mpiList, window.openpgp.packet.SecretKey);
+  var packet = createSecretKeyPacketFromList(mpiList, openpgp.SecretKeyPacket);
   return packet;
 }
 
 function createSecretSubKey(key)
 {
   var mpiList = createMPIList(key);
-  var packet = createSecretKeyPacketFromList(mpiList, window.openpgp.packet.SecretSubkey);
+  var packet = createSecretKeyPacketFromList(mpiList, openpgp.SecretSubkeyPacket);
   return packet;
 }
 
@@ -195,7 +241,7 @@ function createSecretKeyPacketFromList(mpiList, PacketType)
   var secretKeyPacket = new PacketType();
   secretKeyPacket.mpi = mpiList;
   secretKeyPacket.isDecrypted = true;
-  secretKeyPacket.algorithm = window.openpgp.enums.read(window.openpgp.enums.publicKey, window.openpgp.enums.publicKey.rsa_encrypt_sign);
+  secretKeyPacket.algorithm = openpgp.enums.read(openpgp.enums.publicKey, openpgp.enums.publicKey.rsa_encrypt_sign);
   return secretKeyPacket;
 }
 
@@ -218,13 +264,13 @@ function createMPIList(privateKey)
 
 function createMPI(value, radix)
 {
-  var BigInteger = window.openpgp.crypto.publicKey.jsbn;
+  var BigInteger = openpgp.crypto.publicKey.jsbn;
   var bn = new BigInteger(value, radix);
   return createMPIFromBI(bn);
 }
 
 function createMPIFromBI(bigIntegeger) {
-  var mpi = new window.openpgp.MPI();
+  var mpi = new openpgp.MPI();
   mpi.fromBigInteger(bigIntegeger);
   return mpi;
 }
@@ -248,7 +294,7 @@ function sendError(err) {
 function SecureRandom() {
   function nextBytes(byteArray) {
     for (var n = 0; n < byteArray.length; n++) {
-      byteArray[n] = window.openpgp.crypto.random.getSecureRandomOctet();
+      byteArray[n] = openpgp.crypto.random.getSecureRandomOctet();
     }
   }
   this.nextBytes = nextBytes;
@@ -261,26 +307,8 @@ function debug(msg) {
 
 function send(content) {
   if(self.postMessage != undefined) {
-    self.postMessage(content);
+    self.postMessage(content, '*');
   } else {
-    postMessage(content);
+    postMessage(content, '*');
   }
-}
-
-function execute(cmd, errMsg) {
-  // wrap the sync cmd in a promise
-  var promise = new Promise(function(resolve) {
-    var result = cmd();
-    resolve(result);
-  });
-
-  // handler error globally
-  return promise.catch(onError.bind(null, errMsg));
-}
-
-function onError(message, error) {
-  // log the stack trace
-  console.error(error.stack);
-  // rethrow new high level error for api users
-  throw new Error(message);
 }

package/lib/uploadWorker.js

@@ -1,56 +1,39 @@
-if(typeof window === 'undefined') {
-  window = {};
-}
-
-window.crypto = {
-    getRandomValues: function (buf) {
-        if(self.ivCounter + buf > self.iv.size)
-        {
-            self.send({'cmd': 'randBuff'});
-        }
-        for(var i = 0; i<buf.length; i++)
-        {
-            buf[i] = self.iv[self.ivCounter++].charCodeAt();
-        }
+try {
+    if (window === undefined) {
+        window = globalThis;
     }
-};
+} catch (err) {
+    window = {};
+}
 
-self.ivCounter = 0;
 self.log = "";
 
 self.addEventListener('message', function(e) {
-	var data = e.data;
-	switch (data.cmd) {
-		case 'start':
-      self.ivCounter = 0;
-      self.csrf = data.csrf;
-			self.serverSecret = data.serverSecret;
-			self.packageId = data.packageId;
-      self.directoryId = data.directoryId;
-			self.file = data.file;
-			self.fileId = data.fileId;
-			self.uploadUrl = data.uploadUrl;
-			self.keycode = data.keycode;
-			self.iv = data.iv;
-      self.name = data.name;
-			self.browser = data.browser;
-			self.uploadedBytes = 0;
-			self.SEGMENT_SIZE = data.SEGMENT_SIZE;
-			self.filePart = data.filePart;
-			self.totalFileSize = data.totalFileSize;
-			self.totalParts = data.parts;
-      self.id = data.id;
-      self.boundary = data.boundary;
-			
-			// Add file
-			self.postMessage({'cmd': 'state', 'fileId': self.fileId, 'name': self.name, 'state': 'ENCRYPTION_STARTED', 'part': self.filePart, 'filesize': self.totalFileSize},'*');
-			
-			self.start();
-      break;
-
-        case 'randBuff':
-            self.iv = data.iv;
-            self.ivCounter = 0;
+    var data = e.data;
+    switch (data.cmd) {
+        case 'start':
+            self.csrf = data.csrf;
+            self.serverSecret = data.serverSecret;
+            self.packageId = data.packageId;
+            self.directoryId = data.directoryId;
+            self.file = data.file;
+            self.fileId = data.fileId;
+            self.uploadUrl = data.uploadUrl;
+            self.keycode = data.keycode;
+            self.name = data.name;
+            self.browser = data.browser;
+            self.uploadedBytes = 0;
+            self.SEGMENT_SIZE = data.SEGMENT_SIZE;
+            self.filePart = data.filePart;
+            self.totalFileSize = data.totalFileSize;
+            self.totalParts = data.parts;
+            self.id = data.id;
+            self.boundary = data.boundary;
+
+            // Add file
+            self.postMessage({'cmd': 'state', 'fileId': self.fileId, 'name': self.name, 'state': 'ENCRYPTION_STARTED', 'part': self.filePart, 'filesize': self.totalFileSize}, '*');
+
+            self.start();
             break;
 
         case 'encrypt_message':
@@ -60,14 +43,14 @@ self.addEventListener('message', function(e) {
             self.cspUrl = data.cspUrl;
             self.keycode = data.keycode;
             self.salt = data.salt;
-            self.iv = data.iv;
             self.workerId = data.workerId;
+
             self.debug('Starting to encrypt');
             self.encryptMessage();
 
             break;
         case 'decrypt_message':
-
+            self.debug('Starting to decrypt message');
             self.serverSecret = data.serverSecret;
             self.message = data.message;
             self.cspUrl = data.cspUrl;
@@ -75,14 +58,12 @@ self.addEventListener('message', function(e) {
             self.workerId = data.workerId;
 
             self.salt = data.salt;
-            self.iv = data.iv;
 
             self.decryptMessage();
 
             break;
         case 'decrypt_file':
-            self.ivCounter = 0;
-            self.iv = data.randomness;
+            self.debug('Starting to decrypt file');
             self.decryptionKey = data.decryptionKey;
             self.fileId = data.fileId;
             self.file = data.file;
@@ -97,9 +78,10 @@ self.addEventListener('message', function(e) {
 }, false);
 
 function decryptFile()
-{	
+{
+
     self.pgpDecryptMessage(self.file, self.decryptionKey, function(decryptedData) {
-      self.postMessage({'cmd': 'decrypted', 'fileId': self.fileId, 'data': decryptedData, 'part': self.part},'*');
+        self.postMessage({'cmd': 'decrypted', 'fileId': self.fileId, 'workerId': self.workerId, 'data': decryptedData, 'part': self.part}, '*');
     });
 }
 
@@ -123,7 +105,7 @@ function decryptMessage() {
         var decoded = base64Decode(self.message);
         self.pgpDecryptMessage(decoded, decryptionKey, function (decryptedMsg) {
             var plaintextString = typedArrayToUnicodeString(decryptedMsg); // Uint8Array([0x01, 0x01, 0x01])
-            self.postMessage({'cmd': 'done', data: plaintextString},'*');
+            self.postMessage({'cmd': 'done', data: plaintextString}, '*');
         });
     } catch(e) {
         throw(e);
@@ -133,23 +115,33 @@ function decryptMessage() {
 
 function encryptMessage() {
     var encryptionKey = self.serverSecret + self.keycode;
+
     self.pgpEncryptMessage(encryptionKey, self.message, 'msg.txt', function (encryptedMsg) {
         var base64EncodedResponse = base64EncodeArray(encryptedMsg);
-        self.postMessage({'cmd': 'done', data: base64EncodedResponse},'*');
+        self.postMessage({'cmd': 'done', data: base64EncodedResponse}, '*');
     });
 }
 
 function pgpEncryptMessage(encryptionKey, data, filename, callback)
 {
-    var options = {
-        message: openpgp.message.fromText(data), // input as Uint8Array (or String)
-        passwords: [encryptionKey],              // multiple passwords possible
-        armor: false                              // don't ASCII armor (for Uint8Array output)
-    };
-    openpgp.encrypt(options).then(function(ciphertext) {
-        //var encrypted =  // get raw encrypted packets as Uint8Array
-        callback(ciphertext.message.packets.write());
-    });
+    // Create open PGP message
+    openpgp.createMessage({ "text": data })
+        .then(function (message) {
+            var options = {
+                message,                         // input as message obj per openPGPv6
+                passwords: [encryptionKey],      // multiple passwords possible
+                format: 'object',
+                config: {
+                    s2kIterationCountByte: 96
+                }
+            };
+
+            // Encrypt open PGP message
+            openpgp.encrypt(options)
+                .then(function(ciphertext) {
+                    callback(ciphertext.packets.write());
+                });
+        });
 }
 
 function typedArrayToUnicodeString(ua) {
@@ -166,19 +158,27 @@ function typedArrayToUnicodeString(ua) {
     return decodeURIComponent(escstr);
 }
 
-async function pgpDecryptMessage(encryptedString, passphrase, callback)
+function pgpDecryptMessage(encryptedString, passphrase, callback)
 {
-    var options = {
-            message: await openpgp.message.read(encryptedString), // input as Uint8Array (or String)
-            passwords: [passphrase],              // multiple passwords possible
-            format: 'binary'
-        };
-    
-
-    openpgp.decrypt(options).then(function(plaintext) {
-        callback(plaintext.data); // String
-        plaintext = undefined; //Free up for GC
-    });
+    // Read in string as message
+    openpgp.readMessage({"binaryMessage": encryptedString})
+        .then(function(message) {
+            var options = {
+                message,                    // parse encrypted bytes
+                passwords: [passphrase],    // decrypt with password
+                format: 'binary',
+                config: {
+                    s2kIterationCountByte: 96
+                }
+            };
+
+            // And decrypt message with openPGP
+            openpgp.decrypt(options)
+                .then(function(plaintext) {
+                    callback(plaintext.data); // String
+                    plaintext = undefined; //Free up for GC
+                });
+        });
 }
 
 function base64EncodeArray(t,o)
@@ -262,23 +262,28 @@ function base64Decode(t)
 }
 
 function start() {
-    debug("Using browser: " + self.browser);
 
     var encryptionKey = self.serverSecret + self.keycode;
-    //var reader = new FileReaderSync();
     var typedArray = new Uint8Array(self.file);
 
-    var options = {
-        message: openpgp.message.fromBinary(typedArray), // input as Uint8Array (or String)
-        passwords: [encryptionKey],              // multiple passwords possible
-        armor: false                              // don't ASCII armor (for Uint8Array output)
-    };
-
-    openpgp.encrypt(options).then(function(ciphertext) {
-        encrypted = ciphertext.message.packets.write(); // get raw encrypted packets as Uint8Array
-        self.postMessage({'cmd': 'state', 'name': self.name, 'fileId': self.fileId, 'state': 'FILE_ENCRYPTED', 'part': self.filePart},'*');
-        self.postMessage({'cmd': 'upload', 'packageId': self.packageId, 'id': self.id, 'boundary': self.boundary, 'file': encrypted, 'name': self.name, 'fileId': self.fileId, 'part': self.filePart, 'parts': self.totalParts, 'filesize': self.totalFileSize},'*');
-    });
+    openpgp.createMessage({ "binary": typedArray })
+        .then(function (message) {
+            var options = {
+                message,                        // input as messageObj per openPGPv6 update
+                passwords: [encryptionKey],     // multiple passwords possible
+                format: 'binary',
+                config: {
+                    s2kIterationCountByte: 96
+                }
+            };
+
+            // Encrypt file with new message obj in options
+            openpgp.encrypt(options)
+                .then(function(ciphertext) {
+                    self.postMessage({'cmd': 'state', 'name': self.name, 'fileId': self.fileId, 'state': 'FILE_ENCRYPTED', 'part': self.filePart}, '*');
+                    self.postMessage({'cmd': 'upload', 'packageId': self.packageId, 'id': self.id, 'boundary': self.boundary, 'file': ciphertext, 'name': self.name, 'fileId': self.fileId, 'part': self.filePart, 'parts': self.totalParts, 'filesize': self.totalFileSize}, '*');
+                });
+        });
 }
 
 function updateProgress(type, number) {
@@ -292,9 +297,9 @@ function debug(msg) {
 
 function send(content) {
     if(self.postMessage != undefined) {
-        self.postMessage(content,'*');
+        self.postMessage(content, '*');
     } else {
-        postMessage(content,'*');
+        postMessage(content, '*');
     }
 }
 
@@ -304,8 +309,8 @@ function fatalError(msg, err) {
         self.debug(err.stack);
     }
 
-    self.postMessage({'cmd': 'fatal', 'msg': msg, 'debug': self.log});
-    throw new Error('Aborting execution due to error');
+    self.postMessage({'cmd': 'fatal', 'msg': msg, 'debug': self.log, 'workerId': self.workerId});
+    throw new Error(msg + ': ' + err.stack);
 }
 
 self.updateProgres = updateProgress;
@@ -319,4 +324,4 @@ self.encryptMessage = encryptMessage;
 self.base64EncodeArray = base64EncodeArray;
 self.base64Decode = base64Decode;
 self.pgpEncryptMessage = pgpEncryptMessage;
-self.pgpDecryptMessage = pgpDecryptMessage;
+self.pgpDecryptMessage = pgpDecryptMessage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendsafely/sendsafely",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "main": "./lib/SendSafely.js",
   "engines": {
     "node": ">=18"
@@ -15,7 +15,7 @@
     "jquery": "^3.4.1",
     "jsdom": "^26.0.0",
     "make-fetch-happen": "^11.1.1",
-    "openpgp": "4.10.11",
+    "openpgp": "6.1.1",
     "sjcl": "1.0.8",
     "xmlhttprequest": "^1.8.0"
   },