mailauth 7.1.1 → 7.3.0

package/lib/arc/index.d.ts

@@ -44,6 +44,10 @@ export function verifyASChain(data: ARCData, opts: ARCOptions & { warnings?: str
  *
  * @param input - RFC822 formatted message or false for pre-calculated data
  * @param data - Seal creation data
- * @returns Seal headers, empty if the ARC-Message-Signature could not be signed, and any errors
+ * @returns Seal headers, empty if the ARC-Message-Signature could not be signed, any errors, and
+ *          the instance (i=) of a created set
  */
-export function createSeal(input: MessageInput | false, data: ARCCreateSealData): Promise<{ headers: string[]; errors: ARCSealError[]; warnings: string[] }>;
+export function createSeal(
+    input: MessageInput | false,
+    data: ARCCreateSealData
+): Promise<{ headers: string[]; errors: ARCSealError[]; warnings: string[]; instance?: number }>;

package/lib/arc/index.js

@@ -14,7 +14,8 @@ const {
     addWarning,
     KEY_ERROR_COMMENTS,
     splitAlgorithm,
-    createKeyCache
+    createKeyCache,
+    isHostNameDomain
 } = require('../../lib/tools');
 const { TIMESTAMP, BODY_LENGTH, MAX_ARC_INSTANCE, ARC_HEADER_KEYS } = require('../dkim/syntax');
 const crypto = require('node:crypto');
@@ -472,6 +473,15 @@ const getARChain = (headers, opts) => {
             checkTagList(arcInstance, 'arc-message-signature', strict, warn);
         }
 
+        // A d= that is not a host name does not name the zone of its key record (RFC 6376
+        // section 3.5), so its key is never looked up and the chain fails in every mode
+        for (let headerKey of isNewest ? ['arc-seal', 'arc-message-signature'] : ['arc-seal']) {
+            let signingDomain = (arcInstance[headerKey].parsed?.d?.value || '').toString();
+            if (signingDomain && !isHostNameDomain(signingDomain)) {
+                throw createError(`i=${arcInstance.i} ${SHORT_NAMES[headerKey]} invalid d=`, 'invalid_arc_tags');
+            }
+        }
+
         let cv = getCv(arcInstance);
 
         if (i === 0 && cv !== 'none') {
@@ -605,8 +615,11 @@ const arc = async (data, opts) => {
         // all failures are permanent in the scope of ARC
         result.i = data?.lastEntry?.i || false;
         status.result = 'fail';
-        // if last entry was listed as passing then add our seal even if the validation failed
-        status.shouldSeal = ['pass', 'none'].includes(getCv(data?.lastEntry));
+        // RFC 8617 section 5.1 step 2: a failed chain is sealed with cv=fail unless its newest
+        // seal already says cv=fail. The DKIM verifier reads the newest seal from the header
+        // fields (latestCv), so a chain that failed the structure checks and could not be
+        // parsed is sealed as well. Data from elsewhere only has the parsed chain
+        status.shouldSeal = data?.latestCv !== undefined ? data.latestCv !== 'fail' : ['pass', 'none'].includes(getCv(data?.lastEntry));
 
         switch (err.code) {
             case 'invalid_arc_seal':
@@ -699,8 +712,8 @@ const arc = async (data, opts) => {
 
 const sealError = (seal, err) => ({
     type: 'ARC',
-    selector: seal?.selector,
-    signingDomain: seal?.signingDomain,
+    selector: seal.selector,
+    signingDomain: seal.signingDomain,
     err
 });
 
@@ -713,14 +726,17 @@ const isSet = value => typeof value !== 'undefined' && value !== null && value !
  * @param {ReadableStream|Buffer|String|false} input The message, or false to use `data.headers`
  *        and `seal.bodyHash` instead
  * @param {Object} data { headers, arc, seal, strict }
- * @returns {Object} { headers, errors, warnings }. `headers` is empty when no set was created,
- *          and `errors` says why
+ * @returns {Object} { headers, errors, warnings, instance }. `headers` is empty when no set was
+ *          created, and `errors` says why. `instance` is the i= of a created set
  */
 const createSeal = async (input, data) => {
-    let { headers, arc, seal } = data;
-    let bodyHash = seal?.bodyHash;
+    let { headers, arc } = data;
+    // a copy, the instance chosen below is stored on it and the caller's object, which may be
+    // reused for the next message, stays unchanged
+    let seal = Object.assign({}, data.seal);
+    let bodyHash = seal.bodyHash;
 
-    const strict = !!(data.strict || seal?.strict);
+    const strict = !!(data.strict || seal.strict);
     const warnings = [];
     const warn = warning => addWarning(warnings, warning);
 
@@ -761,6 +777,19 @@ const createSeal = async (input, data) => {
         }
     }
 
+    // RFC 8617 section 4.1.1, the payload of the ARC-Authentication-Results header. A line break
+    // is only allowed as folding (CRLF followed by whitespace and more content), anything else
+    // would start a new header field or end the header block
+    let authResults = isSet(seal.authResults) ? String(seal.authResults) : '';
+    if (!/\S/.test(authResults)) {
+        return refuse('The authResults value for the ARC-Authentication-Results header is missing', 'EINVALIDAUTHRESULTS');
+    }
+    // a CR that does not start folding, or an LF without a CR. A search for the bad line break,
+    // a pattern that matches the whole value runs out of stack on a large one
+    if (/\r(?!\n[ \t]+[^ \t\r\n])|(?<!\r)\n/.test(authResults)) {
+        return refuse('The authResults value contains a line break that is not header folding', 'EINVALIDAUTHRESULTS');
+    }
+
     // Step 1. Calculate ARC-Message-Signature
     dkimSigner = new DkimSigner({
         // headers and bodyHash are prepared values if we do not have the source message anymore
@@ -869,7 +898,7 @@ const createSeal = async (input, data) => {
         return { headers: [], errors: dkimSigner.errors, warnings: collectWarnings() };
     }
 
-    const authResults = `ARC-Authentication-Results: i=${seal.i}; ${seal.authResults}`;
+    const authResultsHeader = `ARC-Authentication-Results: i=${seal.i}; ${authResults}`;
 
     // the ARC-Seal uses the algorithm of the ARC-Message-Signature, which follows the key type
     // when no algorithm was given
@@ -881,7 +910,7 @@ const createSeal = async (input, data) => {
         arcSeal = await signAS(
             arc?.chain || [],
             {
-                'arc-authentication-results': authResults,
+                'arc-authentication-results': authResultsHeader,
                 'arc-message-signature': messageSignature
             },
             {
@@ -900,9 +929,10 @@ const createSeal = async (input, data) => {
     }
 
     return {
-        headers: [arcSeal, messageSignature, authResults],
+        headers: [arcSeal, messageSignature, authResultsHeader],
         errors: dkimSigner.errors,
-        warnings: collectWarnings()
+        warnings: collectWarnings(),
+        instance: seal.i
     };
 };
 
@@ -911,4 +941,4 @@ const sealMessage = async (input, seal) => {
     return headers.length ? Buffer.from(headers.join('\r\n') + '\r\n') : Buffer.from('');
 };
 
-module.exports = { getARChain, verifyASChain, arc, createSeal, sealMessage };
+module.exports = { getARChain, getHighestArcInstance, verifyASChain, arc, createSeal, sealMessage };