mailauth 5.0.2 → 6.0.0

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "5.0.2"
+    ".": "6.0.0"
 }

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [6.0.0](https://github.com/postalsys/mailauth/compare/v5.0.3...v6.0.0) (2026-09-26)
+
+
+### ⚠ BREAKING CHANGES
+
+* **dmarc:** DMARC verdicts can change. A subdomain whose parent publishes no record is now its own Organizational Domain, so a signature or SPF domain of the parent no longer aligns with it. Subdomains of names the Public Suffix List lists as suffixes but that publish a DMARC record (for example blogspot.com) now inherit that policy. The result's domain is the Tree Walk Organizational Domain, and is the author domain when no record is found.
+
+### Features
+
+* **dmarc:** find policies and organizational domains with the RFC 9989 DNS Tree Walk ([8ab1da2](https://github.com/postalsys/mailauth/commit/8ab1da24aa5f1be7939393bd79a9834802aa911d))
+
+## [5.0.3](https://github.com/postalsys/mailauth/compare/v5.0.2...v5.0.3) (2026-09-03)
+
+
+### Bug Fixes
+
+* **dkim:** canonicalize a CR that is not a line ending as body content ([68dfb42](https://github.com/postalsys/mailauth/commit/68dfb4262fdae1bedb17019ab8c3c59bc2f4cf8d))
+* **dkim:** canonicalize a lone CR as body content in the simple algorithm ([aa54b0e](https://github.com/postalsys/mailauth/commit/aa54b0e75f65a274d2f56ea4df6f58bc86c080fc))
+* **dkim:** fold a header line that is not a well formed field ([227cf48](https://github.com/postalsys/mailauth/commit/227cf48fb42dbb93bcebfd1acbc8484032e03db9))
+* **dkim:** read the signature timestamp once per signature ([c8c6cd8](https://github.com/postalsys/mailauth/commit/c8c6cd8d41fd176d59522bde85022b7ab0f1e324))
+* **dkim:** sign and verify a message that has no body ([0b7c6ed](https://github.com/postalsys/mailauth/commit/0b7c6ed6723a8cdf2f65334af7d0783a373ab5e8))
+* **dkim:** stop emitting signatures and seals that cover nothing ([4eefa97](https://github.com/postalsys/mailauth/commit/4eefa9793fa6755d2e11b1fcaa4581b7f1b32515))
+* **dkim:** treat only SP and HTAB as whitespace in header canonicalization ([734db62](https://github.com/postalsys/mailauth/commit/734db62d09376c631e548f6c8b44a56ba38659c5))
+
 ## [5.0.2](https://github.com/postalsys/mailauth/compare/v5.0.1...v5.0.2) (2026-08-19)
 
 

package/README.md

@@ -433,7 +433,7 @@ See [DMARC Result Reference](docs/dmarc.md) for details on the result object str
 
 ##### `getDmarcRecord(domain [, resolver])`
 
-Fetches and parses the DMARC DNS record for a domain or subdomain. Returns `false` if no record exists.
+Fetches and parses the DMARC record that applies to a domain, found with the DNS Tree Walk of RFC 9989 section 4.10. That is the domain's own record, or else the record of its Organizational Domain, or else a record published with `psd=y` above it. Returns `false` if no record applies.
 
 ###### Syntax
 
@@ -469,10 +469,14 @@ console.log(dmarcRecord);
     "sp": "none",
     "aspf": "r",
     "rr": "v=DMARC1; p=none; pct=100; rua=mailto:re+joqy8fpatm3@dmarc.postmarkapp.com; sp=none; aspf=r;",
-    "isOrgRecord": false
+    "isOrgRecord": false,
+    "recordDomain": "ethereal.email",
+    "orgDomain": "ethereal.email"
 }
 ```
 
+`isOrgRecord` is `true` when the record was inherited from the Organizational Domain or a PSD, and `recordDomain` is where it was published. `orgDomain` is `null` when the record was found at the domain itself but the rest of the Tree Walk failed.
+
 ### BIMI
 
 Brand Indicators for Message Identification (BIMI) support is based on [draft-blank-ietf-bimi-02](https://tools.ietf.org/html/draft-blank-ietf-bimi-02). BIMI information is resolved during the authentication step, provided the message passes DMARC validation with a policy other than "none".

package/docs/dmarc.md

@@ -6,6 +6,8 @@ This document describes the result object returned by DMARC verification.
 
 DMARC (Domain-based Message Authentication, Reporting, and Conformance) is verified during the authentication process. The DMARC result depends on both SPF and DKIM verification results.
 
+Policy discovery and Organizational Domains follow the DNS Tree Walk of RFC 9989 section 4.10, not the Public Suffix List. The policy is taken from the record of the author domain, or else from the record of its Organizational Domain, or else from a record published with `psd=y` above it. Relaxed alignment compares the Organizational Domains of the author domain and of each authenticated identifier, which can take further walks. A walk makes at most eight queries, lookups are shared within a message, only identifiers at or below the author's Organizational Domain are walked, and at most ten identifiers per message are walked.
+
 ```javascript
 const { authenticate } = require('mailauth');
 
@@ -21,7 +23,7 @@ const { dmarc } = await authenticate(message, {
 | Field       | Type     | Presence     | Description                                                |
 | ----------- | -------- | ------------ | ---------------------------------------------------------- |
 | `status`    | `object` | Always       | Verification status object (see below)                     |
-| `domain`    | `string` | Always       | Organizational domain used for DMARC lookup                |
+| `domain`    | `string` | Always       | Organizational Domain of the author domain (Tree Walk)     |
 | `policy`    | `string` | Record found | Effective policy (`"reject"`, `"quarantine"`, or `"none"`) |
 | `p`         | `string` | Record found | Policy from `p=` tag                                       |
 | `sp`        | `string` | Record found | Subdomain policy from `sp=` tag (defaults to `p` value)    |
@@ -29,7 +31,9 @@ const { dmarc } = await authenticate(message, {
 | `rr`        | `string` | Record found | Raw DMARC DNS TXT record                                   |
 | `alignment` | `object` | Record found | SPF and DKIM alignment details (see below)                 |
 | `error`     | `string` | On temperror | Error message                                              |
-| `info`      | `string` | Always       | Formatted Authentication-Results header value              |
+
+On a `temperror` that happens after a record was found, because a Tree Walk needed for relaxed alignment failed and no other identifier aligned, `policy`, `p`, `sp`, `rr` and `alignment` are still set.
+| `info` | `string` | Always | Formatted Authentication-Results header value |
 
 ## status Object
 
@@ -41,10 +45,10 @@ const { dmarc } = await authenticate(message, {
 
 ### status.header Object
 
-| Field  | Type     | Description                         |
-| ------ | -------- | ----------------------------------- |
-| `from` | `string` | Domain of the From header address   |
-| `d`    | `string` | Domain where DMARC record was found |
+| Field  | Type     | Description                                                                             |
+| ------ | -------- | --------------------------------------------------------------------------------------- |
+| `from` | `string` | Domain of the From header address                                                       |
+| `d`    | `string` | Domain where the applied DMARC record was found (author, Organizational Domain, or PSD) |
 
 ## alignment Object
 
@@ -72,12 +76,12 @@ const { dmarc } = await authenticate(message, {
 
 ## Result Values
 
-| Result      | Description                                           |
-| ----------- | ----------------------------------------------------- |
-| `pass`      | Message passed DMARC (SPF or DKIM aligned and passed) |
-| `fail`      | Message failed DMARC (neither SPF nor DKIM aligned)   |
-| `none`      | No DMARC record found                                 |
-| `temperror` | Temporary error during DNS lookup                     |
+| Result      | Description                                                    |
+| ----------- | -------------------------------------------------------------- |
+| `pass`      | Message passed DMARC (SPF or DKIM aligned and passed)          |
+| `fail`      | Message failed DMARC (neither SPF nor DKIM aligned)            |
+| `none`      | No DMARC record found                                          |
+| `temperror` | Temporary error during a DNS lookup that the result depends on |
 
 ## Policy Values
 
@@ -168,7 +172,7 @@ For example: `"p=REJECT sp=REJECT arc=pass"`
             "from": "no-dmarc.example.com"
         }
     },
-    "domain": "example.com",
+    "domain": "no-dmarc.example.com",
     "info": "dmarc=none header.from=no-dmarc.example.com"
 }
 ```

package/index.d.ts

@@ -180,7 +180,9 @@ export interface DKIMResult {
      */
     status: AuthStatus & {
         /**
-         * Signing domain if it aligns with the From domain, false otherwise
+         * Signing domain if it aligns with the From domain, false otherwise. For a passing
+         * signature this follows the DMARC verdict once DMARC found a record, before that it
+         * only guesses relaxed alignment from the Public Suffix List.
          */
         aligned?: string | false;
 
@@ -348,6 +350,12 @@ export interface ARCResult {
      */
     authResults?: string;
 
+    /**
+     * Why sealing failed, when a seal was requested but could not be created.
+     * The message is left unsealed in that case
+     */
+    sealErrors?: Error[];
+
     /**
      * ARC chain entries (non-enumerable property)
      * Access with result.chain or Object.getOwnPropertyDescriptor()
@@ -360,7 +368,7 @@ export interface ARCResult {
  */
 export interface DMARCResult {
     /**
-     * Organization domain
+     * Organizational Domain of the author domain, found with the DNS Tree Walk (RFC 9989 4.10)
      */
     domain: string;
 
@@ -1089,9 +1097,9 @@ export function verifyASChain(data: ARCData, opts: ARCOptions): Promise<boolean>
  *
  * @param input - RFC822 formatted message or false for pre-calculated data
  * @param data - Seal creation data
- * @returns Seal headers
+ * @returns Seal headers, empty if the ARC-Message-Signature could not be signed, and any errors
  */
-export function createSeal(input: MessageInput | false, data: any): Promise<{ headers: string[] }>;
+export function createSeal(input: MessageInput | false, data: any): Promise<{ headers: string[]; errors: Error[] }>;
 
 // ============================================================================
 // BIMI

package/lib/arc/index.d.ts

@@ -42,6 +42,6 @@ export function verifyASChain(data: ARCData, opts: ARCOptions): Promise<boolean>
  *
  * @param input - RFC822 formatted message or false for pre-calculated data
  * @param data - Seal creation data
- * @returns Seal headers
+ * @returns Seal headers, empty if the ARC-Message-Signature could not be signed, and any errors
  */
-export function createSeal(input: MessageInput | false, data: any): Promise<{ headers: string[] }>;
+export function createSeal(input: MessageInput | false, data: any): Promise<{ headers: string[]; errors: Error[] }>;

package/lib/arc/index.js

@@ -4,6 +4,7 @@ const { Buffer } = require('node:buffer');
 const {
     parseDkimHeaders,
     formatRelaxedLine,
+    stripSignatureValue,
     getPublicKey,
     formatAuthHeaderRow,
     formatSignatureHeaderLine,
@@ -36,15 +37,7 @@ const verifyAS = async (chain, opts) => {
                 throw err;
             }
 
-            chunks.push(
-                Buffer.from(
-                    formatRelaxedLine(link['arc-seal'].original)
-                        .toString('binary')
-                        // remove value from b= key
-                        .replace(/([;:\s]+b=)[^;]+/, '$1'),
-                    'binary'
-                )
-            );
+            chunks.push(stripSignatureValue(formatRelaxedLine(link['arc-seal'].original)));
         }
     }
 
@@ -118,7 +111,7 @@ const signAS = async (chain, entry, signatureData) => {
 
         if (Object.prototype.toString.call(signTime) === '[object Date]' && signTime.toString() !== 'Invalid Date') {
             // we need a unix timestamp value
-            signTime = Math.round(signTime.getTime() / 1000);
+            signTime = Math.floor(signTime.getTime() / 1000);
             headerOpts.t = signTime;
         }
     }
@@ -135,15 +128,7 @@ const signAS = async (chain, entry, signatureData) => {
         true
     );
 
-    chunks.push(
-        Buffer.from(
-            formatRelaxedLine(canonSignatureHeaderLine)
-                .toString('binary')
-                // remove value from b= key
-                .replace(/([;:\s]+b=)[^;]+/, '$1'),
-            'binary'
-        )
-    );
+    chunks.push(stripSignatureValue(formatRelaxedLine(canonSignatureHeaderLine)));
 
     let canonicalizedHeader = Buffer.concat(chunks);
 
@@ -504,6 +489,15 @@ const createSeal = async (input, data) => {
 
     seal.i = seal.i || 1;
 
+    const messageSignature = dkimSigner.arc?.messageSignature;
+    if (!messageSignature) {
+        // The ARC-Message-Signature is missing whenever signing it failed, an unusable key
+        // being the usual reason. There is no ARC set to seal then: sealing anyway hashes
+        // a header that does not exist and puts an empty line into the header block, which
+        // ends it early for everything downstream
+        return { headers: [], errors: dkimSigner.errors };
+    }
+
     const authResults = `ARC-Authentication-Results: i=${seal.i}; ${seal.authResults}`;
 
     // Step 2. Calculate ARC-Seal
@@ -511,7 +505,7 @@ const createSeal = async (input, data) => {
         arc.chain,
         {
             'arc-authentication-results': authResults,
-            'arc-message-signature': dkimSigner.arc?.messageSignature
+            'arc-message-signature': messageSignature
         },
         {
             instance: seal.i,
@@ -526,7 +520,8 @@ const createSeal = async (input, data) => {
     );
 
     return {
-        headers: [arcSeal, dkimSigner?.arc?.messageSignature, authResults].map(v => v)
+        headers: [arcSeal, messageSignature, authResults],
+        errors: dkimSigner.errors
     };
 };
 

package/lib/dkim/body/line-endings.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { Buffer } = require('node:buffer');
+
+const CHAR_CR = 0x0d;
+const CHAR_LF = 0x0a;
+
+// A run of line endings at the end of the body is held back until it is known whether any
+// content follows it, because RFC 6376 drops it if none does. Both canonicalizations count
+// the CRLF pairs in that run instead of keeping the buffers they arrived in: the message
+// parser hands over one small buffer per line, and each of those pins the whole pool it
+// was allocated from, so a body of nothing but line breaks was retained about two hundred
+// times over. The pairs are written back out from this one shared buffer, which is built
+// with Buffer.alloc because Buffer.from would pool it and pin a slab for the same reason
+const EMPTY_LINE_BATCH = 512;
+const CRLF_RUN = Buffer.alloc(EMPTY_LINE_BATCH * 2);
+for (let i = 0; i < CRLF_RUN.length; i += 2) {
+    CRLF_RUN[i] = CHAR_CR;
+    CRLF_RUN[i + 1] = CHAR_LF;
+}
+
+const CRLF = CRLF_RUN.subarray(0, 2);
+
+// Calls back with every held back CRLF pair, in batches. The caller owns the counter and
+// has to clear it
+const eachHeldLineBreak = (count, fn) => {
+    while (count > 0) {
+        let batch = Math.min(count, EMPTY_LINE_BATCH);
+        fn(CRLF_RUN.subarray(0, batch * 2));
+        count -= batch;
+    }
+};
+
+module.exports = { CHAR_CR, CHAR_LF, CRLF, eachHeldLineBreak };

package/lib/dkim/body/relaxed.js

@@ -6,8 +6,8 @@ const { Buffer } = require('node:buffer');
 const crypto = require('node:crypto');
 const { MimeStructureStartFinder } = require('../mime-structure-start-finder');
 
-const CHAR_CR = 0x0d;
-const CHAR_LF = 0x0a;
+const { CHAR_CR, CHAR_LF, CRLF, eachHeldLineBreak } = require('./line-endings');
+
 const CHAR_SPACE = 0x20;
 const CHAR_TAB = 0x09;
 
@@ -40,7 +40,9 @@ class RelaxedHash {
 
         this.maxSizeReached = maxBodyLength === 0;
 
-        this.emptyLinesQueue = [];
+        // number of empty lines seen at the end of the body so far. They are hashed only
+        // once it is known that more content follows them
+        this.pendingLineBreaks = 0;
 
         this.mimeStructureStartFinder = new MimeStructureStartFinder();
     }
@@ -85,12 +87,8 @@ class RelaxedHash {
     }
 
     _drainPendingEmptyLines() {
-        if (this.emptyLinesQueue.length) {
-            for (let emptyLine of this.emptyLinesQueue) {
-                this._updateBodyHash(emptyLine);
-            }
-            this.emptyLinesQueue = [];
-        }
+        eachHeldLineBreak(this.pendingLineBreaks, lineBreaks => this._updateBodyHash(lineBreaks));
+        this.pendingLineBreaks = 0;
     }
 
     _pushBodyHash(chunk) {
@@ -98,28 +96,24 @@ class RelaxedHash {
             return;
         }
 
-        // remove line endings
-        let foundNonLn = false;
-
-        // buffer line endings and empty lines
-        for (let i = chunk.length - 1; i >= 0; i--) {
-            if (chunk[i] !== CHAR_LF && chunk[i] !== CHAR_CR) {
-                this._drainPendingEmptyLines();
-                if (i < chunk.length - 1) {
-                    this.emptyLinesQueue.push(chunk.subarray(i + 1));
-                    chunk = chunk.subarray(0, i + 1);
-                }
-                foundNonLn = true;
-                break;
-            }
+        // Count the line endings at the end of the chunk: these are the empty lines that
+        // are dropped if no more content follows. Everything that reaches this method has
+        // already been canonicalized, so the run is always whole CRLF pairs, see
+        // ./line-endings for why they are counted rather than kept
+        let end = chunk.length;
+        while (end >= 2 && chunk[end - 2] === CHAR_CR && chunk[end - 1] === CHAR_LF) {
+            end -= 2;
         }
 
-        if (!foundNonLn) {
-            this.emptyLinesQueue.push(chunk);
+        if (!end) {
+            this.pendingLineBreaks += chunk.length / 2;
             return;
         }
 
-        this._updateBodyHash(chunk);
+        this._drainPendingEmptyLines();
+        this.pendingLineBreaks = (chunk.length - end) / 2;
+
+        this._updateBodyHash(chunk.subarray(0, end));
     }
 
     /**
@@ -142,16 +136,16 @@ class RelaxedHash {
 
         for (let i = line.length - 1; i >= 0; i--) {
             if (line[i] === CHAR_LF) {
-                lineBuf[writePos--] = line[i];
-                if (i === 0 || line[i - 1] !== CHAR_CR) {
-                    // add missing carriage return
-                    lineBuf[writePos--] = CHAR_CR;
+                lineBuf[writePos--] = CHAR_LF;
+                lineBuf[writePos--] = CHAR_CR;
+                if (i > 0 && line[i - 1] === CHAR_CR) {
+                    // the <CR> of the line ending, any other <CR> is content
+                    i--;
                 }
-                continue;
-            }
-
-            if (line[i] === CHAR_CR) {
-                lineBuf[writePos--] = line[i];
+                // the scan has crossed into the previous line, whose own trailing
+                // whitespace has to go the same way
+                nonWspFound = false;
+                prevWsp = false;
                 continue;
             }
 
@@ -278,13 +272,16 @@ class RelaxedHash {
         if (final) {
             let chunkPart = (cursorPos && chunk && chunk.subarray(cursorPos)) || chunk;
             if (chunkPart && chunkPart.length) {
-                this._pushBodyHash(lineNeedsFixing ? this.fixLineBuffer(chunkPart) : chunkPart);
-                lineNeedsFixing = false;
+                // The last line has no line ending, so the scan above never looked at its
+                // trailing whitespace. A single trailing space is the only thing it can
+                // have missed: a run of them, and an HTAB anywhere, both set
+                // lineNeedsFixing, and nothing clears it again before the end of the line
+                this._pushBodyHash(lineNeedsFixing || chunkPart[chunkPart.length - 1] === CHAR_SPACE ? this.fixLineBuffer(chunkPart) : chunkPart);
             }
 
             if (this.bodyHashedBytes) {
                 // terminating line break for non-empty messages
-                this._updateBodyHash(Buffer.from([CHAR_CR, CHAR_LF]));
+                this._updateBodyHash(CRLF);
             }
         }
     }

package/lib/dkim/body/simple.js

@@ -4,6 +4,8 @@ const { Buffer } = require('node:buffer');
 const crypto = require('node:crypto');
 const { MimeStructureStartFinder } = require('../mime-structure-start-finder');
 
+const { CHAR_CR, CHAR_LF, CRLF, eachHeldLineBreak } = require('./line-endings');
+
 /**
  * Class for calculating body hash of an email message body stream
  * using the "simple" canonicalization
@@ -19,7 +21,10 @@ class SimpleHash {
         algorithm = (algorithm || 'sha256').split('-').pop();
         this.bodyHash = crypto.createHash(algorithm);
 
+        // line endings at the end of the body, held back until it is known whether content
+        // follows them. Whole CRLF pairs are only counted, see ./line-endings
         this.remainder = [];
+        this.pendingLineBreaks = 0;
 
         // total body size
         this.byteLength = 0;
@@ -31,8 +36,6 @@ class SimpleHash {
         this.maxBodyLength = maxBodyLength;
         this.maxSizeReached = maxBodyLength === 0;
 
-        this.lastNewline = false;
-
         this.mimeStructureStartFinder = new MimeStructureStartFinder();
     }
 
@@ -76,56 +79,89 @@ class SimpleHash {
     }
 
     update(chunk) {
-        this.byteLength += (chunk && chunk.length) || 0;
+        if (!chunk || !chunk.length) {
+            return;
+        }
+
+        this.byteLength += chunk.length;
         if (this.maxSizeReached) {
             return;
         }
 
-        if (this.remainder.length) {
-            // see if we can release the last remainder
-            for (let i = 0; i < chunk.length; i++) {
-                let c = chunk[i];
-                if (c !== 0x0a && c !== 0x0d) {
-                    // found non-line terminator byte, can release previous chunk
-                    for (let remainderChunk of this.remainder) {
-                        this._updateBodyHash(remainderChunk);
-                    }
-                    this.remainder = [];
-                }
-            }
+        // Find the line endings at the end of the chunk. They may be the *CRLF that ends
+        // the body, which digest() collapses, and a trailing <CR> may still pair up with
+        // an <LF> that opens the next chunk, so whether they are line endings is only
+        // known once something follows them. Peeling whole CRLF pairs first is what tells
+        // _holdBack the run can be counted rather than kept, without a second pass over it
+        let pairEnd = chunk.length;
+        while (pairEnd >= 2 && chunk[pairEnd - 2] === CHAR_CR && chunk[pairEnd - 1] === CHAR_LF) {
+            pairEnd -= 2;
         }
 
-        // find line terminators from the end of chunk
-        let matchStart = false;
-        for (let i = chunk.length - 1; i >= 0; i--) {
-            let c = chunk[i];
-            if (c === 0x0a || c === 0x0d) {
-                // stop looking
-                matchStart = i;
-            } else {
-                break;
-            }
+        let end = pairEnd;
+        while (end > 0 && (chunk[end - 1] === CHAR_LF || chunk[end - 1] === CHAR_CR)) {
+            end -= 1;
+        }
+
+        if (end) {
+            this._drainHeldLineEndings();
+            this._updateBodyHash(chunk.subarray(0, end));
         }
 
-        if (matchStart === 0) {
-            // nothing but newlines in this chunk
-            this.remainder.push(chunk);
+        if (end < chunk.length) {
+            this._holdBack(chunk, end, pairEnd);
+        }
+    }
+
+    _holdBack(chunk, end, pairEnd) {
+        if (!this.remainder.length && end === pairEnd) {
+            // nothing but whole CRLF pairs, and nothing kept before them to stay behind
+            this.pendingLineBreaks += (chunk.length - pairEnd) / 2;
             return;
-        } else if (matchStart !== false) {
-            this.remainder.push(chunk.slice(matchStart));
-            chunk = chunk.slice(0, matchStart);
         }
 
-        this._updateBodyHash(chunk);
-        this.lastNewline = chunk[chunk.length - 1] === 0x0a;
+        // a lone <CR> or <LF> the counter can not stand in for, so keep the exact bytes.
+        // Anything counted so far stays counted, it comes first either way
+        this.remainder.push(chunk.subarray(end));
+    }
+
+    _drainHeldLineEndings() {
+        eachHeldLineBreak(this.pendingLineBreaks, lineBreaks => this._updateBodyHash(lineBreaks));
+        this.pendingLineBreaks = 0;
+
+        for (let heldChunk of this.remainder) {
+            this._updateBodyHash(heldChunk);
+        }
+        this.remainder = [];
     }
 
     digest(encoding) {
-        if (!this.lastNewline || !this.bodyHashedBytes) {
-            // emit empty line buffer to keep the stream flowing
-            this._updateBodyHash(Buffer.from('\r\n'));
+        // RFC 6376 section 3.4.3: "simple" makes no changes to the body beyond converting
+        // the *CRLF at its end to a single CRLF. A <CR> that no <LF> follows does not end
+        // a line, so it is body content and stays where it is. A lone <LF> is taken as a
+        // line ending, the same way RelaxedHash takes it, and mailauth's message parser
+        // has already rewritten those to CRLF for anything read off the wire
+        let trailer = this.remainder.length === 1 ? this.remainder[0] : Buffer.concat(this.remainder);
+        let end = trailer.length;
+        while (end > 0 && trailer[end - 1] === CHAR_LF) {
+            end -= 1;
+            if (end > 0 && trailer[end - 1] === CHAR_CR) {
+                end -= 1;
+            }
         }
 
+        if (end) {
+            // content survived among the kept bytes, so the pairs counted before them are
+            // inside the body rather than at its end and have to be hashed after all
+            eachHeldLineBreak(this.pendingLineBreaks, lineBreaks => this._updateBodyHash(lineBreaks));
+            this._updateBodyHash(trailer.subarray(0, end));
+        }
+        // whatever is still held is the *CRLF at the end of the body, and collapses below
+        this.pendingLineBreaks = 0;
+
+        // a body with no trailing CRLF, and an empty body, both get one
+        this._updateBodyHash(CRLF);
+
         return this.bodyHash.digest(encoding);
     }
 

package/lib/dkim/dkim-signer.js

@@ -184,6 +184,22 @@ class DkimSigner extends MessageParser {
 
             let signingHeaderLines = getSigningHeaderLines(this.headers.parsed, this.headerList);
 
+            if (!signingHeaderLines.headers.some(header => header.key === 'from')) {
+                // RFC 6376 section 5.4: the From header field MUST be signed, and section
+                // 6.1.1 makes a signature that does not cover it a PERMFAIL for every
+                // verifier. Without this an input with no header at all is signed with an
+                // empty h= tag, which is not even valid sig-h-tag syntax
+                let err = new Error('Can not sign a message that has no From header');
+                err.code = 'ENOFROM';
+                this.errors.push({
+                    type: signatureData.type,
+                    selector: signatureData.selector,
+                    signingDomain: signatureData.signingDomain,
+                    err
+                });
+                continue;
+            }
+
             let { algorithm, signAlgo, hashAlgo } = this.getAlgorithm(signatureData);
             let { canonicalization, bodyCanon } = this.getCanonicalization(signatureData);
 

package/lib/dkim/dkim-verifier.js

@@ -124,8 +124,11 @@ class DkimVerifier extends MessageParser {
             signatureHeader.expiration =
                 signatureHeader.parsed?.x && !isNaN(signatureHeader.parsed?.x?.value) ? new Date(signatureHeader.parsed?.x?.value * 1000) : null;
 
+            // `l=0` is a valid sig-l-tag and means that no body byte is covered by the
+            // signature, so the value has to be tested for being a number, not for being
+            // truthy, or a zero length limit would be read as no limit at all
             signatureHeader.maxBodyLength =
-                signatureHeader.parsed?.l?.value && !isNaN(signatureHeader.parsed?.l?.value) ? signatureHeader.parsed?.l?.value : '';
+                typeof signatureHeader.parsed?.l?.value === 'number' && !isNaN(signatureHeader.parsed?.l?.value) ? signatureHeader.parsed?.l?.value : '';
 
             const validSignAlgo = ['rsa', 'ed25519'];
             const validHeaderAlgo = signatureHeader.type === 'DKIM' ? ['sha256', 'sha1'] : ['sha256'];
@@ -336,12 +339,6 @@ class DkimVerifier extends MessageParser {
                 signatureHeader.canonicalizedLength = this.bodyHashes.get(signatureHeader.bodyHashKey)?.canonicalizedLength;
                 signatureHeader.sourceBodyLength = this.bodyHashes.get(signatureHeader.bodyHashKey)?.byteLength;
 
-                if (typeof signatureHeader.maxBodyLength === 'number' && signatureHeader.maxBodyLength !== signatureHeader.bodyHashedBytes) {
-                    console.log('TOTAL', signatureHeader.bodyHashedBytes, 'EXPECTING', signatureHeader.maxBodyLength);
-                    //status.result = 'fail';
-                    //status.comment = `invalid body length ${signatureHeader.bodyHashedBytes}`;
-                }
-
                 let result = {
                     id: signatureHeader.parsed?.b?.value
                         ? crypto.createHash('sha256').update(Buffer.from(signatureHeader.parsed?.b?.value, 'base64')).digest('hex')