mailauth 5.0.2 → 6.0.0

package/lib/tools.js

@@ -76,14 +76,47 @@ const writeToStream = async (stream, input, chunkSize) => {
     });
 };
 
+// Lowercases a 'binary' string the way RFC 6376 section 3.4.2 means it. String.prototype
+// toLowerCase() is Unicode aware and maps the latin1 bytes 0xC0-0xDE to 0xE0-0xFE, which
+// corrupts a UTF-8 sequence and folds two distinct header names onto one. Only a string
+// that has such a byte needs the slower per character mapping
+const NON_ASCII = /[^\x00-\x7f]/;
+const lowerCaseASCII = str => (NON_ASCII.test(str) ? str.replace(/[A-Z]/g, c => c.toLowerCase()) : str.toLowerCase());
+
+// RFC 5322 section 3.6.8: field-name = 1*ftext, and ftext is printable US-ASCII except
+// the colon. A fold, and the obsolete syntax of section 4.5.8, may put whitespace between
+// the name and the colon
+const FIELD_START = /^[\x21-\x39\x3b-\x7e]+[ \t\r\n]*:/;
+
+// Whether a row opens a header of its own. Anything else is appended to the row above,
+// which is wider than the CRLF-then-WSP fold of RFC 5322 section 2.2.3 and deliberately
+// so: a line that is not a well formed field is read differently by different parsers,
+// some mail readers append whitespace-looking lines to the value above them. Asking what
+// a field looks like instead of what whitespace looks like
+// covers every spelling of it, including the multi-byte ones a leading byte test misses,
+// such as UTF-8 NBSP (C2 A0) and the ideographic space (E3 80 80). Appending a line can
+// only add bytes to a signed value, so it can only ever turn a pass into a fail; reading
+// the line the other way round is what cannot be undone. formatRelaxedLine is not lenient
+// in the same way, what a signature covers is RFC 6376 section 3.4.2 alone
+const startsField = row =>
+    // only the start of the row decides this, and a fold can push the colon no further
+    // than onto the line after the name
+    FIELD_START.test(row.length > 1 ? `${row[0]}\r\n${row[1]}` : row[0]);
+
 const parseHeaders = buf => {
     let rows = buf
         .toString('binary')
         .replace(/[\r\n]+$/, '')
         .split(/\r?\n/)
         .map(row => [row]);
-    for (let i = rows.length - 1; i >= 0; i--) {
-        if (i > 0 && /^\s/.test(rows[i][0])) {
+
+    if (rows.length === 1 && !rows[0][0]) {
+        // nothing to parse, rather than one row that is not a header
+        return { parsed: [], original: buf };
+    }
+
+    for (let i = rows.length - 1; i > 0; i--) {
+        if (!startsField(rows[i])) {
             rows[i - 1] = rows[i - 1].concat(rows[i]);
             rows.splice(i, 1);
         }
@@ -94,8 +127,15 @@ const parseHeaders = buf => {
         let key = row.match(/^[^:]+/);
         let casedKey;
         if (key) {
-            casedKey = key[0].trim();
-            key = casedKey.toLowerCase();
+            // a fold may sit between the field name and the colon, and the CRLF it leaves
+            // behind is not part of the name. Without this the key of a header folded that
+            // way matches nothing, and a From read by every MUA stops being a From here
+            casedKey = key[0];
+            if (casedKey.indexOf('\n') >= 0) {
+                casedKey = casedKey.replace(/\r?\n/g, '');
+            }
+            casedKey = casedKey.replace(/^[ \t]+|[ \t]+$/g, '');
+            key = lowerCaseASCII(casedKey);
         }
 
         return { key, casedKey, line: Buffer.from(row, 'binary') };
@@ -104,12 +144,21 @@ const parseHeaders = buf => {
     return { parsed: rows, original: buf };
 };
 
-const getSigningHeaderLines = (parsedHeaders, fieldNames, verify) => {
-    fieldNames = (typeof fieldNames === 'string' ? fieldNames : defaultDKIMFieldNames)
+// Normalizes an h= tag, or a configured header list, exactly as parseHeaders normalizes a
+// field name. Anything else and an entry names a key no parsed row can ever equal
+const normalizeFieldNames = fieldNames =>
+    fieldNames
         .split(':')
-        .map(key => key.trim().toLowerCase())
+        .map(key => lowerCaseASCII(key.replace(/^[ \t]+|[ \t]+$/g, '')))
         .filter(key => key);
 
+const defaultDKIMFieldNamesNormalized = normalizeFieldNames(defaultDKIMFieldNames);
+
+const getSigningHeaderLines = (parsedHeaders, fieldNames, verify) => {
+    // an h= tag is attacker controlled on inbound mail, so only the constant default list
+    // is normalized ahead of time
+    fieldNames = typeof fieldNames === 'string' ? normalizeFieldNames(fieldNames) : defaultDKIMFieldNamesNormalized;
+
     let signingList = [];
 
     if (verify) {
@@ -154,7 +203,7 @@ const formatSignatureHeaderLine = (type, values, folded) => {
             values = Object.assign(
                 {
                     v: 1,
-                    t: Math.round(Date.now() / 1000),
+                    t: Math.floor(Date.now() / 1000),
                     q: 'dns/txt'
                 },
                 values
@@ -166,7 +215,7 @@ const formatSignatureHeaderLine = (type, values, folded) => {
             keyOrdering = keyOrderingARC;
             values = Object.assign(
                 {
-                    t: Math.round(Date.now() / 1000),
+                    t: Math.floor(Date.now() / 1000),
                     q: 'dns/txt'
                 },
                 values
@@ -178,7 +227,7 @@ const formatSignatureHeaderLine = (type, values, folded) => {
             keyOrdering = keyOrderingAS;
             values = Object.assign(
                 {
-                    t: Math.round(Date.now() / 1000)
+                    t: Math.floor(Date.now() / 1000)
                 },
                 values
             );
@@ -194,7 +243,10 @@ const formatSignatureHeaderLine = (type, values, folded) => {
             .filter(key => values[key] !== false && typeof values[key] !== 'undefined' && values[key] !== null && keyOrdering.includes(key))
             .sort((a, b) => keyOrdering.indexOf(a) - keyOrdering.indexOf(b))
             .map(key => {
-                let val = values[key] || '';
+                // the filter above already dropped false, null and undefined, so a falsy
+                // value left here is a meaningful one. `l=0` is a valid sig-l-tag (RFC 6376
+                // section 3.5, 1*76DIGIT) and must not be serialized as a valueless `l=`
+                let val = values[key];
                 if (key === 'b' && folded && val) {
                     // fold signature value
                     return `${key}=${val}`.replace(/.{75}/g, '$& ').trim();
@@ -210,6 +262,7 @@ const formatSignatureHeaderLine = (type, values, folded) => {
                 }
 
                 if (key === 'i' && type === 'DKIM') {
+                    val = val.toString();
                     let atPos = val.indexOf('@');
                     if (atPos >= 0) {
                         let domainPart = val.substr(atPos + 1);
@@ -449,21 +502,35 @@ const formatAuthHeaderRow = (method, status) => {
     return parts.join(' ');
 };
 
+// RFC 6376 section 3.4.2. Only SP and HTAB are whitespace here: the line is a
+// 'binary' string, so a byte such as 0xA0 (the second byte of a UTF-8
+// non-breaking space) must not be collapsed or trimmed
 const formatRelaxedLine = (line, suffix) => {
     let result =
-        line
-            ?.toString('binary')
+        // a missing line is nothing to canonicalize. Optional chaining would resolve the
+        // whole chain to undefined and the concatenation below would then hash the
+        // 9 byte string "undefined" as if it were a header
+        (line || '')
+            .toString('binary')
             // unfold
             .replace(/\r?\n/g, '')
             // key to lowercase, trim around :
-            .replace(/^([^:]*):\s*/, (m, k) => k.toLowerCase().trim() + ':')
+            .replace(/^([^:]*):[ \t]*/, (m, k) => lowerCaseASCII(k).replace(/^[ \t]+|[ \t]+$/g, '') + ':')
             // single WSP
-            .replace(/\s+/g, ' ')
-            .trim() + (suffix ? suffix : '');
+            .replace(/[ \t]+/g, ' ')
+            // no WSP around the value
+            .replace(/^ | $/g, '') + (suffix ? suffix : '');
 
     return Buffer.from(result, 'binary');
 };
 
+// RFC 6376 section 3.7: when the signature header is hashed, its own b= value is treated
+// as empty. The tag can be preceded by WSP and, in a header that has not been unfolded
+// yet, by the CRLF of a fold. Nothing else is whitespace here, for the same reason it is
+// not in formatRelaxedLine: a byte such as 0xA0 in front of b= is content, and matching it
+// would strip a decoy tag and leave the real signature inside the hashed header
+const stripSignatureValue = line => Buffer.from(line.toString('binary').replace(/([;: \t\r\n]+b=)[^;]+/, '$1'), 'binary');
+
 const formatDomain = domain => {
     domain = domain.toLowerCase().trim();
     try {
@@ -568,15 +635,19 @@ function getCurTime(timeValue) {
             return timeValue;
         }
 
+        // `curTime.toString` is the method, never the string, so the guard below used to
+        // pass for every value and handed back an Invalid Date. That silently became a
+        // NaN timestamp in a signature, and a comparison that is false either way in the
+        // verifier, so an unparseable value falls back to the current time instead
         if (typeof timeValue === 'number' || !isNaN(timeValue)) {
             let timestamp = Number(timeValue);
             let curTime = new Date(timestamp);
-            if (curTime.toString !== 'Invalid Date') {
+            if (curTime.toString() !== 'Invalid Date') {
                 return curTime;
             }
         } else if (typeof timeValue === 'string') {
             let curTime = new Date(timeValue);
-            if (curTime.toString !== 'Invalid Date') {
+            if (curTime.toString() !== 'Invalid Date') {
                 return curTime;
             }
         }
@@ -774,6 +845,7 @@ module.exports = {
     getAlignment,
 
     formatRelaxedLine,
+    stripSignatureValue,
     formatDomain,
 
     getPtrHostname,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mailauth",
-    "version": "5.0.2",
+    "version": "6.0.0",
     "description": "Email authentication library for Node.js",
     "main": "lib/mailauth.js",
     "types": "index.d.ts",
@@ -35,27 +35,27 @@
     "homepage": "https://github.com/postalsys/mailauth",
     "devDependencies": {
         "chai": "4.4.1",
-        "eslint": "10.8.0",
+        "eslint": "10.11.0",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "10.1.8",
-        "js-yaml": "5.2.3",
+        "js-yaml": "5.4.2",
         "license-report": "6.8.5",
         "mbox-reader": "1.2.0",
-        "mocha": "11.8.0",
-        "prettier": "3.9.6",
-        "resedit": "3.0.2"
+        "mocha": "12.0.2",
+        "prettier": "3.9.9",
+        "resedit": "3.1.0"
     },
     "dependencies": {
         "@postalsys/vmc": "1.1.5",
         "commander": "15.0.0",
-        "fast-xml-parser": "5.10.1",
+        "fast-xml-parser": "5.11.1",
         "ipaddr.js": "2.5.0",
-        "joi": "18.2.3",
-        "libmime": "5.4.1",
-        "nodemailer": "9.0.4",
+        "joi": "18.2.9",
+        "libmime": "5.4.4",
+        "nodemailer": "10.0.10",
         "punycode.js": "2.3.1",
-        "tldts": "7.4.10",
-        "undici": "8.10.0"
+        "tldts": "7.4.15",
+        "undici": "8.11.2"
     },
     "engines": {
         "node": ">=22.19.0"