mailauth 7.0.0 → 7.1.0

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "7.0.0"
+    ".": "7.1.0"
 }

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [7.1.0](https://github.com/postalsys/mailauth/compare/v7.0.0...v7.1.0) (2026-09-27)
+
+
+### Features
+
+* **cli:** add --reject-rsa-sha1 to the report command ([#140](https://github.com/postalsys/mailauth/issues/140)) ([fc8e965](https://github.com/postalsys/mailauth/commit/fc8e9651e304ff6d9f3249e2f3c1db7e481c7d8c))
+* **dkim:** add rejectRsaSha1 to reject rsa-sha1 signatures without the strict mode ([#138](https://github.com/postalsys/mailauth/issues/138)) ([92d2c23](https://github.com/postalsys/mailauth/commit/92d2c23027d443dc62dc93a49b54d561beb3f2ed))
+
+
+### Bug Fixes
+
+* **dmarc:** count a subdomain with a dangling CNAME as existing for np ([#137](https://github.com/postalsys/mailauth/issues/137)) ([b38ecef](https://github.com/postalsys/mailauth/commit/b38ecef53b56e479863dd96cae1a6fe24c970353))
+
 ## [7.0.0](https://github.com/postalsys/mailauth/compare/v6.0.0...v7.0.0) (2026-09-27)
 
 

package/README.md

@@ -85,6 +85,7 @@ await authenticate(message [, options])
     - **trustReceived** (`boolean`): If `true`, parses `ip` and `helo` from the latest `Received` header if not provided. The IP address is the connecting address from the TCP-info comment of the `from` clause (RFC 5321 section 4.4), never an address literal the client sent in its HELO. Postfix, Sendmail, Exim (including its `from [ip] (helo=...)` form) and similar formats are understood. Defaults to `false`.
     - **mta** (`string`): Hostname of the server performing the authentication. Defaults to `os.hostname()`. Used as the authserv-id of the Authentication headers, so it should be a host name: an internationalized name is converted to A-labels, and a value that is not a valid token (for example one with a space or a semicolon) is written as a quoted string. With `strict` such a value throws an error with the code `EINVALIDAUTHSERVID` instead.
     - **minBitLength** (`number`): Minimum allowed bits for RSA public keys. Defaults to `1024`. Keys with fewer bits will fail validation.
+    - **rejectRsaSha1** (`boolean`): If `true`, an rsa-sha1 DKIM signature gives `dkim=policy` with `policy.dkim-rules=weak-algorithm`, as in strict mode, and is not counted for DMARC. Every other check keeps the lenient default. It only affects verification. Defaults to `false`, and `strict` implies it.
     - **disableArc** (`boolean`): If `true`, skips ARC checks.
     - **disableDmarc** (`boolean`): If `true`, skips DMARC checks, also disabling dependent checks like BIMI.
     - **disableBimi** (`boolean`): If `true`, skips BIMI checks.
@@ -151,7 +152,7 @@ You can see the full output, including structured data for DKIM, SPF, DMARC, and
 
 By default mailauth is lenient where accepting non-conforming input costs little security, mostly weak signatures that still bind the signing domain to the content. With `strict: true` every check follows its RFC exactly.
 
-Whatever the default mode accepts that strict mode would reject is marked in a `warnings` array on the affected result (for example `dkim.results[0].status.warnings` is `['rsa-sha1']`), so that you can apply your own policy without switching modes. The markers are never written into the generated headers.
+Whatever the default mode accepts that strict mode would reject is marked in a `warnings` array on the affected result (for example `dkim.results[0].status.warnings` is `['rsa-sha1']`), so that you can apply your own policy without switching modes. The markers are never written into the generated headers. For rsa-sha1 verification the `rejectRsaSha1` option applies the strict rule on its own, which also keeps such a signature out of DMARC in `authenticate()`.
 
 Some rules apply in both modes, because breaking them is a defect and not leniency. For DKIM these are: a signature must sign the From header, the key record's `h=` (hash algorithms) and `s=` (service types) restrictions are honored, `ed25519-sha1` is not an algorithm, and signing refuses a domain, selector or identity that would break out of its tag.
 
@@ -296,6 +297,7 @@ const result = await dkimVerify(message [, options]);
 - **options** (optional):
     - **resolver** (`async function`): Custom DNS resolver function. Defaults to `dns.promises.resolve`. A U-label signing domain is converted to A-labels before it is looked up (RFC 8616).
     - **minBitLength** (`number`): Minimum allowed bits for RSA public keys. Defaults to `1024`. A shorter key gives `dkim=policy` with `policy.dkim-rules=weak-key`.
+    - **rejectRsaSha1** (`boolean`): If `true`, an rsa-sha1 signature gives `dkim=policy` with `policy.dkim-rules=weak-algorithm`, as in strict mode, while every other check keeps the lenient default. Signing is not affected. Defaults to `false`, and `strict` implies it.
     - **sender** (`string`): Envelope sender. Defaults to the `Return-Path` header.
     - **curTime** (`Date`): The time to check `t=` and `x=` against. Defaults to now.
     - **strict** (`boolean`): If `true`, follows RFC 6376, RFC 8301 and RFC 8463 exactly. Defaults to `false`. See [Strict mode](#strict-mode).

package/bin/mailauth.js

@@ -104,6 +104,7 @@ program
     .option('-x, --max-lookups <number>', 'Maximum allowed DNS lookups during SPF checks. Defaults to 10.', numberArg, 10)
     .option('-z, --max-void-lookups <number>', 'Maximum allowed DNS lookups that return no data (void lookups) during SPF checks. Defaults to 2.', numberArg, 2)
     .option('--strict', 'Follow the RFCs exactly instead of the lenient defaults (for example, reject rsa-sha1 DKIM signatures).')
+    .option('--reject-rsa-sha1', 'Report rsa-sha1 DKIM signatures as dkim=policy and do not count them for DMARC, while keeping the other lenient defaults.')
     .action(runCommand(commandReport, 'Failed to generate report for the input message.'));
 
 program

package/cli.md

@@ -87,6 +87,7 @@ mailauth report [options] [email]
 - `--max-lookups number`, `-x number`: Sets the maximum number of DNS lookups for SPF checks. Defaults to `10`.
 - `--max-void-lookups number`, `-z number`: Sets the maximum number of void DNS lookups for SPF checks. Defaults to `2`.
 - `--strict`: Follows the RFCs exactly instead of the lenient defaults, for example an `rsa-sha1` DKIM signature is reported as `dkim=policy`. See [Strict mode](README.md#strict-mode).
+- `--reject-rsa-sha1`: Reports an `rsa-sha1` DKIM signature as `dkim=policy` and does not count it for DMARC, as `--strict` does, while every other check keeps the lenient default.
 
 #### Example
 

package/docs/dkim.md

@@ -91,7 +91,7 @@ Each entry in the `results` array has the following structure:
 | `pass`      | Signature verified successfully                                                                                                                                                            |
 | `fail`      | Signature verification failed (bad signature). In strict mode also a body hash mismatch                                                                                                    |
 | `neutral`   | Signature could not be verified (missing key, expired, body hash mismatch in the default mode, invalid signature)                                                                          |
-| `policy`    | Signature failed policy check (a key shorter than `minBitLength`, or rsa-sha1 in strict mode)                                                                                              |
+| `policy`    | Signature failed policy check (a key shorter than `minBitLength`, or rsa-sha1 in strict mode or with `rejectRsaSha1`)                                                                      |
 | `temperror` | Temporary error (DNS failure)                                                                                                                                                              |
 | `none`      | Message not signed. In the default mode also a message whose only signatures use an unknown algorithm or canonicalization, or have no `d=` or `s=`. Strict mode reports those as `neutral` |
 
@@ -112,7 +112,7 @@ Common values for `status.comment`:
 | `"inappropriate hash algorithm"`                    | The key record `h=` tag does not list the hash algorithm of the signature (both modes)               |
 | `"key not for email"`                               | The key record `s=` tag does not list `email` or `*` (both modes)                                    |
 | `"From field not signed"`                           | The `h=` tag does not include From (both modes, RFC 6376 section 6.1.1)                              |
-| `"weak algorithm"`                                  | Strict mode: rsa-sha1 signature (RFC 8301)                                                           |
+| `"weak algorithm"`                                  | Strict mode or `rejectRsaSha1`: rsa-sha1 signature (RFC 8301)                                        |
 | `"signature syntax error"`                          | Strict mode: the signature is not valid RFC 6376 syntax                                              |
 | `"signature missing required tag"`                  | Strict mode: `v=`, `a=`, `b=`, `bh=`, `d=`, `h=` or `s=` is missing                                  |
 | `"incompatible version"`                            | Strict mode: `v=` is not 1                                                                           |

package/docs/dmarc.md

@@ -61,7 +61,7 @@ On a `temperror` that happens after a record was found, `policy`, `p`, `sp`, `rr
 
 `policyDomain` is the domain an RFC 9990 aggregate report lists as the domain of the published policy. By default it is also in `status.header.d`. `domain` is the Organizational Domain, which is a different domain when the policy came from the author domain's own record below it, or from a PSD above it.
 
-`policy` is `p` for the author domain's own record. For a record inherited from the Organizational Domain or a PSD it is `np` when the author domain does not exist (NXDOMAIN, RFC 9989 A.4), otherwise `sp`, both falling back to `p`. The existence query is only made when the record has `np`. When it fails and `np` differs from the other policy, a message that passes still passes, `policy` is the weaker of the two and `policy.dmarc` is left out, and a message that does not pass gets `temperror`. With `t=y` the policy is one level below that, so `reject` becomes `quarantine` and `quarantine` becomes `none`, while `p`, `sp` and `np` stay as published.
+`policy` is `p` for the author domain's own record. For a record inherited from the Organizational Domain or a PSD it is `np` when the author domain does not exist (NXDOMAIN, RFC 9989 A.4), otherwise `sp`, both falling back to `p`. The existence query is only made when the record has `np`. It asks for A, and after an NXDOMAIN for the name's own CNAME, because a name that is a CNAME exists even when its target does not. When it fails and `np` differs from the other policy, a message that passes still passes, `policy` is the weaker of the two and `policy.dmarc` is left out, and a message that does not pass gets `temperror`. With `t=y` the policy is one level below that, so `reject` becomes `quarantine` and `quarantine` becomes `none`, while `p`, `sp` and `np` stay as published.
 
 A record without a valid `p`, or with an invalid `sp` or `np`, is applied as `p=none` when its `rua` lists a syntactically valid URI (RFC 3986, so `mailto:` counts and a bare address does not), and otherwise gets no DMARC processing (result `none`). `pct` is historic in RFC 9989 and is ignored.
 

package/index.d.ts

@@ -55,6 +55,13 @@ export interface AuthenticateOptions {
      */
     minBitLength?: number;
 
+    /**
+     * If true, rsa-sha1 DKIM signatures get `policy` (weak-algorithm) as in strict mode and are
+     * not counted for DMARC, while every other check keeps the lenient default. Verification
+     * only (default: false)
+     */
+    rejectRsaSha1?: boolean;
+
     /**
      * Custom DNS resolver function
      */
@@ -1216,6 +1223,12 @@ export interface DKIMVerifyOptions {
      */
     minBitLength?: number;
 
+    /**
+     * If true, rsa-sha1 signatures get `policy` (weak-algorithm) as in strict mode, while every
+     * other check keeps the lenient default (default: false)
+     */
+    rejectRsaSha1?: boolean;
+
     /**
      * Current time for signature expiration checks
      */

package/lib/commands/report.js

@@ -26,7 +26,8 @@ const cmd = async argv => {
 
     const opts = {
         trustReceived: true,
-        strict: !!argv.strict
+        strict: !!argv.strict,
+        rejectRsaSha1: !!argv.rejectRsaSha1
     };
 
     if (argv.clientIp) {

package/lib/dkim/dkim-verifier.js

@@ -61,6 +61,9 @@ class DkimVerifier extends MessageParser {
         // follow RFC 6376, RFC 8301 and RFC 8463 exactly instead of the lenient defaults
         this.strict = !!this.options.strict;
 
+        // RFC 8301 section 3.1 on its own, without the rest of the strict mode
+        this.rejectRsaSha1 = this.strict || !!this.options.rejectRsaSha1;
+
         this.curTime = getCurTime(this.options.curTime);
 
         this.results = [];
@@ -378,8 +381,8 @@ class DkimVerifier extends MessageParser {
 
             if (signatureHeader.hashAlgo === 'sha1') {
                 // RFC 8301 section 3.1: rsa-sha1 MUST NOT be used for verifying. Only the
-                // strict mode rejects it, the lenient mode lets the key owner opt out of it
-                // with the h= tag of the key record
+                // strict mode and rejectRsaSha1 reject it, the lenient mode lets the key owner
+                // opt out of it with the h= tag of the key record
                 warn('rsa-sha1');
             }
         }
@@ -510,7 +513,7 @@ class DkimVerifier extends MessageParser {
             // The lenient mode keeps reporting neutral, as it always has
             status.result = this.strict ? 'fail' : 'neutral';
             status.comment = `body hash did not verify`;
-        } else if (this.strict && signatureHeader.type === 'DKIM' && signatureHeader.hashAlgo === 'sha1') {
+        } else if (this.rejectRsaSha1 && signatureHeader.type === 'DKIM' && signatureHeader.hashAlgo === 'sha1') {
             // RFC 8301 section 3.1, "rsa-sha1 MUST NOT be used for signing or verifying"
             status.result = 'policy';
             status.comment = 'weak algorithm';

package/lib/dmarc/get-dmarc-record.js

@@ -54,18 +54,32 @@ const getPolicyTags = record => {
 
 // Domain existence test (RFC 9989 A.4): any RR makes a name exist, only NXDOMAIN means it
 // does not. A query for A tells the two apart, NODATA is an existing name without A records.
+// A query for A follows a CNAME and gets the target's NXDOMAIN when the target is gone (RFC 6604 3),
+// so after an NXDOMAIN the name's own CNAME, which is not followed, is looked up as well.
 const domainExists = async (domain, resolver) => {
     if (!isValidName(domain)) {
         return false;
     }
+    resolver = resolver || dns.resolve;
     try {
-        await (resolver || dns.resolve)(domain, 'A');
+        await resolver(domain, 'A');
         return true;
     } catch (err) {
         if (err.code === 'ENODATA') {
             return true;
         }
-        if (err.code === 'ENOTFOUND' || err.code === 'EBADNAME') {
+        if (err.code === 'EBADNAME') {
+            return false;
+        }
+        if (err.code !== 'ENOTFOUND') {
+            throw err;
+        }
+    }
+    try {
+        return ((await resolver(domain, 'CNAME')) || []).length > 0;
+    } catch (err) {
+        if (NO_RECORD_CODES.has(err.code)) {
+            // no CNAME, so the NXDOMAIN for A was the name's own
             return false;
         }
         throw err;

package/lib/mailauth.js

@@ -24,6 +24,7 @@ const { isIP } = require('net');
  * @param {String} [opts.helo] Hostname from EHLO/HELO
  * @param {String} [opts.mta] MTA/MX hostname (defaults to os.hostname)
  * @param {Number} [opts.minBitLength=1024] Minimal allowed length of public keys. If DKIM/ARC key is smaller, then verification fails
+ * @param {Boolean} [opts.rejectRsaSha1=false] If true then rsa-sha1 DKIM signatures get dkim=policy (weak-algorithm) as in strict mode (RFC 8301), the other checks stay lenient
  * @param {Object} [opts.seal] ARC sealing options
  * @param {String} [opts.seal.signingDomain] ARC key domain name
  * @param {String} [opts.seal.selector] ARC key selector
@@ -49,6 +50,7 @@ const authenticate = async (input, opts) => {
         sender: opts.sender, // defaults to Return-Path header
         seal: opts.seal,
         minBitLength: opts.minBitLength,
+        rejectRsaSha1: opts.rejectRsaSha1,
         strict: opts.strict
     });
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mailauth",
-    "version": "7.0.0",
+    "version": "7.1.0",
     "description": "Email authentication library for Node.js",
     "main": "lib/mailauth.js",
     "types": "index.d.ts",