Fix armor errors

Also, fix error handling in transformPair()

src/encoding/armor.js

@@ -212,16 +212,17 @@ function dearmor(input) {
       let headersDone;
       let text = [];
       let textDone;
+      let resolved = false;
       let checksum;
       let data = base64.decode(stream.transformPair(input, async (readable, writable) => {
         const reader = stream.getReader(readable);
         const writer = stream.getWriter(writable);
         while (true) {
-          await writer.ready;
+          if (resolved) await writer.ready;
+          try {
             let line = await reader.readLine();
             if (line === undefined) {
-            writer.abort('Misformed armored text');
+              throw new Error('Misformed armored text');
-            break;
             }
             // remove trailing whitespace at end of lines
             // remove leading whitespace for compat with older versions of OpenPGP.js
@@ -239,7 +240,10 @@ function dearmor(input) {
               } else {
                 verifyHeaders(lastHeaders);
                 headersDone = true;
-              if (textDone || type !== 2) resolve({ text, data, headers, type });
+                if (textDone || type !== 2) {
+                  resolve({ text, data, headers, type });
+                  resolved = true;
+                }
               }
             } else if (!textDone && type === 2) {
               if (!reSplit.test(line)) {
@@ -255,15 +259,23 @@ function dearmor(input) {
             } else {
               if (!reSplit.test(line)) {
                 if (line[0] !== '=') {
-                writer.write(line);
+                  await writer.write(line);
                 } else {
                   checksum = line.substr(1);
                 }
               } else {
-              writer.close();
+                await writer.close();
                 break;
               }
             }
+          } catch(e) {
+            if (resolved) {
+              await writer.abort(e);
+            } else {
+              reject(e);
+            }
+            break;
+          }
         }
       }));
       data = stream.transformPair(data, async (readable, writable) => {
@@ -275,10 +287,10 @@ function dearmor(input) {
         const writer = stream.getWriter(writable);
         await writer.ready;
         if (checksum !== checksumVerifiedString && (checksum || config.checksum_required)) {
-          writer.abort(new Error("Ascii armor integrity check on message failed: '" + checksum + "' should be '" +
+          await writer.abort(new Error("Ascii armor integrity check on message failed: '" + checksum + "' should be '" +
                   checksumVerifiedString + "'"));
         } else {
-          writer.close();
+          await writer.close();
         }
       });
     } catch(e) {

src/packet/packetlist.js

@@ -38,6 +38,7 @@ function List() {
 List.prototype.read = async function (bytes) {
   this.stream = stream.transformPair(bytes, async (readable, writable) => {
     const writer = stream.getWriter(writable);
+    try {
       while (true) {
         await writer.ready;
         const done = await packetParser.read(readable, async parsed => {
@@ -53,17 +54,20 @@ List.prototype.read = async function (bytes) {
                 parsed.tag === enums.packet.symmetricallyEncrypted ||
                 parsed.tag === enums.packet.literal ||
                 parsed.tag === enums.packet.compressed) {
-            writer.abort(e);
+              await writer.abort(e);
             }
             util.print_debug_error(e);
           }
         });
         if (done) {
           await writer.ready;
-        writer.close();
+          await writer.close();
           return;
         }
       }
+    } catch(e) {
+      await writer.abort(e);
+    }
   });
 
   // Wait until first few packets have been read

src/packet/sym_encrypted_aead_protected.js

@@ -147,6 +147,7 @@ SymEncryptedAEADProtected.prototype.crypt = async function (fn, key, data) {
     return stream.transformPair(data, async (readable, writable) => {
       const reader = stream.getReader(readable);
       const writer = stream.getWriter(writable);
+      try {
         while (true) {
           await writer.ready;
           let chunk = await reader.readBytes(chunkSize + tagLengthIfDecrypting) || new Uint8Array();
@@ -168,8 +169,8 @@ SymEncryptedAEADProtected.prototype.crypt = async function (fn, key, data) {
           cryptedBytes += chunk.length - tagLengthIfDecrypting;
           queuedBytes += chunk.length - tagLengthIfDecrypting;
           // eslint-disable-next-line no-loop-func
-        latestPromise = latestPromise.then(() => cryptedPromise).then(crypted => {
+          latestPromise = latestPromise.then(() => cryptedPromise).then(async crypted => {
-          writer.write(crypted);
+            await writer.write(crypted);
             queuedBytes -= chunk.length;
           }).catch(err => writer.abort(err));
           // console.log(fn, done, queuedBytes, writer.desiredSize);
@@ -179,10 +180,13 @@ SymEncryptedAEADProtected.prototype.crypt = async function (fn, key, data) {
           if (!done) {
             adataView.setInt32(5 + 4, ++chunkIndex); // Should be setInt64(5, ...)
           } else {
-          writer.close();
+            await writer.close();
             break;
           }
         }
+      } catch(e) {
+        await writer.abort(e);
+      }
     });
   } else {
     return modeInstance[fn](await stream.readToEnd(data), this.iv);

src/stream.js

@@ -53,7 +53,7 @@ async function pipe(input, target, options) {
     }
     writer.releaseLock();
   }
-  return input.pipeTo(target, options);
+  return input.pipeTo(target, options).catch(function() {});
 }
 
 function transformRaw(input, options) {
@@ -125,22 +125,13 @@ function transformPair(input, fn) {
     }
   });
 
-  const canceledErr = new Error('Readable side was canceled.');
+  const pipeDonePromise = pipe(input, incoming.writable);
-  const pipeDonePromise = pipe(input, incoming.writable).catch(e => {
-    if (e !== canceledErr) {
-      throw e;
-    }
-  });
 
   const outgoing = transformWithCancel(async function() {
-    incomingTransformController.error(canceledErr);
+    incomingTransformController.error(new Error('Readable side was canceled.'));
     await pipeDonePromise;
   });
-  Promise.resolve(fn(incoming.readable, outgoing.writable)).catch(e => {
+  fn(incoming.readable, outgoing.writable);
-    if (e !== canceledErr) {
-      throw e;
-    }
-  });
   return outgoing.readable;
 }
 
@@ -183,6 +174,7 @@ function passiveClone(input) {
         const transformed = transformPair(input, async (readable, writable) => {
           const reader = getReader(readable);
           const writer = getWriter(writable);
+          try {
             while (true) {
               await writer.ready;
               const { done, value } = await reader.read();
@@ -194,6 +186,9 @@ function passiveClone(input) {
               try { controller.enqueue(value); } catch(e) {}
               await writer.write(value);
             }
+          } catch(e) {
+            await writer.abort(e);
+          }
         });
         overwrite(input, transformed);
       }

test/general/streaming.js

@@ -416,11 +416,7 @@ describe('Streaming', function() {
     let plaintext = [];
     let i = 0;
     let canceled = false;
-    let controller;
     const data = new ReadableStream({
-      start(_controller) {
-        controller = _controller;
-      },
       async pull(controller) {
         await new Promise(setTimeout);
         if (i++ < 10) {
@@ -435,16 +431,22 @@ describe('Streaming', function() {
         canceled = true;
       }
     });
-    data.controller = controller;
 
     const transformed = stream.transformPair(stream.slice(data, 0, 5000), async (readable, writable) => {
       const reader = stream.getReader(readable);
       const writer = stream.getWriter(writable);
+      try {
         while (true) {
           await writer.ready;
           const { done, value } = await reader.read();
-        if (done) return writer.close();
+          if (done) {
-        writer.write(value);
+            await writer.close();
+            break;
+          }
+          await writer.write(value);
+        }
+      } catch(e) {
+        await writer.abort(e);
       }
     });
     await new Promise(resolve => setTimeout(resolve));