@mavogel/awscdk-rootmail 0.1.22 → 0.1.24

package/.jsii

@@ -14,11 +14,11 @@
     "@aws-sdk/client-ses": "^3.1152.0",
     "@aws-sdk/client-ssm": "^3.1152.0",
     "cdk-nag": "^3.0.1",
-    "mailparser": "^3.9.39",
+    "mailparser": "^3.9.40",
     "uuid": "^14.0.3"
   },
   "dependencies": {
-    "@mavogel/mvc-projen": "^0.0.60",
+    "@mavogel/mvc-projen": "^0.0.61",
     "aws-cdk-lib": "^2.263.0",
     "constructs": "^10.5.1"
   },
@@ -9620,6 +9620,6 @@
       "symbolId": "src/ses-receive:SESReceiveProps"
     }
   },
-  "version": "0.1.22",
-  "fingerprint": "yVkAiOChDR563/v1x8I2vx1yVpLq5RvYhIUE5purNYA="
+  "version": "0.1.24",
+  "fingerprint": "VsXTNX+CbDEHj6QL4Wk23mv6Fvtf5IcmZ+EaZ822B68="
 }

package/lib/rootmail.js

@@ -11,7 +11,7 @@ const ses_receive_1 = require("./ses-receive");
  * Rootmail construct
  */
 class Rootmail extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@mavogel/awscdk-rootmail.Rootmail", version: "0.1.22" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@mavogel/awscdk-rootmail.Rootmail", version: "0.1.24" };
     /**
      * The name parameter in SSM to store the domain name server.
      */

package/lib/ses-receive.js

@@ -11,7 +11,7 @@ const ses_receipt_ruleset_activation_1 = require("./ses-receipt-ruleset-activati
  * SES Receive construct
  */
 class SESReceive extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@mavogel/awscdk-rootmail.SESReceive", version: "0.1.22" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@mavogel/awscdk-rootmail.SESReceive", version: "0.1.24" };
     constructor(scope, id, props) {
         super(scope, id);
         const filteredEmailSubjects = props.filteredEmailSubjects || [];

package/node_modules/@zone-eu/mailsplit/lib/headers.js

@@ -392,18 +392,29 @@ class Headers {
             lines.push({ key: this._normalizeHeader(first.substr(0, first.indexOf(':'))), line: first });
         }
 
+        // Set while the last entry has no colon yet, so that its key may still come from a
+        // continuation line. Only the new line is searched then: searching the whole
+        // accumulated line again for every continuation was quadratic on a keyless block
+        let keyPending = false;
+
         for (; i < rawLines.length; i++) {
             let currentLine = rawLines[i];
             if (this._isFoldingChar(currentLine.charAt(0))) {
                 // the loop starts on a non-folded line, so there is always a last entry here
                 let entry = lines[lines.length - 1];
-                entry.line += '\r\n' + currentLine;
-                if (!entry.key) {
+                if (keyPending) {
                     // the key comes from the first colon, which may only appear in a continuation
-                    entry.key = this._normalizeHeader(entry.line.substr(0, entry.line.indexOf(':')));
+                    let colon = currentLine.indexOf(':');
+                    if (colon >= 0) {
+                        entry.key = this._normalizeHeader(entry.line + '\r\n' + currentLine.substr(0, colon));
+                        keyPending = false;
+                    }
                 }
+                entry.line += '\r\n' + currentLine;
             } else {
-                lines.push({ key: this._normalizeHeader(currentLine.substr(0, currentLine.indexOf(':'))), line: currentLine });
+                let colon = currentLine.indexOf(':');
+                lines.push({ key: this._normalizeHeader(currentLine.substr(0, colon)), line: currentLine });
+                keyPending = colon < 0;
             }
         }
 

package/node_modules/@zone-eu/mailsplit/lib/message-splitter.js

@@ -94,6 +94,9 @@ class MessageSplitter extends Transform {
         // set once the closing delimiter of the current node's multipart has been seen, so
         // that any later boundary line of that node counts as epilogue. Reset per node.
         this.inEpilogue = false;
+        // the open ancestor multipart whose boundary the last delimiter line matched, set
+        // by checkBoundary() for a sibling (3) or closing (4) delimiter
+        this.delimiterOwner = /** @type {MimeNodeType | false} */ (false);
         this.newNode();
         // incomplete trailing line of the previous chunk, kept as a list of chunks so
         // that a long line without a line break is not copied over for every write
@@ -452,15 +455,38 @@ class MessageSplitter extends Transform {
             return boundary;
         }
 
-        if (this.node._parentBoundary && (boundary = this.compareBoundary(line, startpos, this.node._parentBoundary))) {
-            // 3: next sibling
-            // 4: parent end
-            return /** @type {3 | 4} */ (boundary + 2);
+        // A delimiter of any open ancestor multipart, not only the parent, ends everything
+        // below it. An inner multipart that is never closed would otherwise swallow the
+        // rest of the message as body text of its last part, while other parsers and mail
+        // clients show the parts that follow the outer delimiter
+        for (let owner = this.node._parentBoundaryOwner; owner; owner = owner._parentBoundaryOwner) {
+            if (owner._boundary && (boundary = this.compareBoundary(line, startpos, owner._boundary))) {
+                // 3: next sibling under the owner
+                // 4: the owner's multipart ends
+                this.delimiterOwner = owner;
+                return /** @type {3 | 4} */ (boundary + 2);
+            }
         }
 
         return false;
     }
 
+    /**
+     * Longest boundary a delimiter line on the current node could carry: the node's own
+     * boundary or that of any open ancestor multipart.
+     *
+     * @returns {number} Boundary length in bytes, 0 when no boundary applies.
+     */
+    maxBoundaryLength() {
+        let max = this.node._boundary ? this.node._boundary.length : 0;
+        for (let owner = this.node._parentBoundaryOwner; owner; owner = owner._parentBoundaryOwner) {
+            if (owner._boundary && owner._boundary.length > max) {
+                max = owner._boundary.length;
+            }
+        }
+        return max;
+    }
+
     /**
      * Checks the header bytes collected for the current node against maxHeadSize.
      *
@@ -488,12 +514,7 @@ class MessageSplitter extends Transform {
             return null;
         }
 
-        let maxBoundaryLength = Math.max(
-            this.node._boundary ? this.node._boundary.length : 0,
-            this.node._parentBoundary ? this.node._parentBoundary.length : 0
-        );
-
-        if (this.lineLength <= maxBoundaryLength + BOUNDARY_LINE_OVERHEAD) {
+        if (this.lineLength <= this.maxBoundaryLength() + BOUNDARY_LINE_OVERHEAD) {
             // might still turn out to be a boundary delimiter line
             return null;
         }
@@ -571,8 +592,8 @@ class MessageSplitter extends Transform {
                     // reached end of children, keep current node
                     break;
                 case 3: {
-                    // next sibling
-                    this.newNode(this.parentMultipartNode());
+                    // next sibling under the multipart that owns the matched boundary
+                    this.newNode(this.delimiterOwner);
                     flush = true;
                     break;
                 }
@@ -583,7 +604,7 @@ class MessageSplitter extends Transform {
                         this.push(this.node);
                     }
                     // move up to the multipart node this closing delimiter belongs to
-                    let parentNode = this.parentMultipartNode();
+                    let parentNode = this.delimiterOwner;
                     if (parentNode) {
                         this.node = parentNode;
                         // the closing delimiter of this multipart was just processed, so any
@@ -662,16 +683,6 @@ class MessageSplitter extends Transform {
         next(null, false);
     }
 
-    /**
-     * Resolves the multipart node that owns the boundary of the current node, ie. the
-     * node a sibling delimiter or a closing delimiter of _parentBoundary refers to.
-     *
-     * @returns {MimeNodeType | false} Owner of _parentBoundary or false for the root node.
-     */
-    parentMultipartNode() {
-        return this.node._parentBoundaryOwner || false;
-    }
-
     /**
      * @param {MimeNodeType | false} [parent]
      * @returns {void}

package/node_modules/@zone-eu/mailsplit/lib/mime-node.js

@@ -44,6 +44,55 @@ function stripComments(value) {
         .join('');
 }
 
+/**
+ * Lists the parameters a header value gives in RFC 2231 form (`name*=`, `name*0=` or
+ * `name*0*=`). libmime decodes those while parsing the header, so the result must not
+ * go through `decodeWords` as well: a value like `filename*=utf-8''a%3D%3Futf-8%3FQ%3F%3D2Eexe%3F%3D`
+ * would otherwise come out as `a.exe` while a parser that decodes once sees the encoded word.
+ *
+ * @param {string} value Raw header value.
+ * @returns {Set<string>} Lowercased parameter names.
+ */
+function rfc2231ParamNames(value) {
+    let names = new Set();
+    let quote = false;
+    let escaped = false;
+    let start = 0;
+
+    /**
+     * @param {number} end End offset of the segment starting at `start`.
+     * @returns {void}
+     */
+    let addSegment = end => {
+        let segment = value.substring(start, end);
+        let eq = segment.indexOf('=');
+        if (eq < 0) {
+            return;
+        }
+        let match = segment.substring(0, eq).trim().toLowerCase().match(/^(.+?)\*(\d+\*?)?$/);
+        if (match) {
+            names.add(match[1]);
+        }
+    };
+
+    for (let i = 0; i < value.length; i++) {
+        let chr = value.charAt(i);
+        if (escaped) {
+            escaped = false;
+        } else if (chr === '\\') {
+            escaped = true;
+        } else if (chr === '"') {
+            quote = !quote;
+        } else if (chr === ';' && !quote) {
+            addSegment(i);
+            start = i + 1;
+        }
+    }
+    addSegment(value.length);
+
+    return names;
+}
+
 /**
  * Parsed MIME node with mutable headers and transfer-encoding helpers.
  */
@@ -142,7 +191,8 @@ class MimeNode {
         this.headers = new Headers(Buffer.concat(this._headersLines, this._headerlen), this.config);
         let headers = this.headers;
 
-        this._parsedContentDisposition = this.libmime.parseHeaderValue(headers.getFirst('Content-Disposition'));
+        let dispositionHeader = headers.getFirst('Content-Disposition');
+        this._parsedContentDisposition = this.libmime.parseHeaderValue(dispositionHeader);
         let parsedContentDisposition = /** @type {StructuredHeader} */ (this._parsedContentDisposition);
 
         // if content-type is missing default to plaintext
@@ -192,10 +242,16 @@ class MimeNode {
         }
 
         if (this.filename) {
-            try {
-                this.filename = this.libmime.decodeWords(this.filename);
-            } catch (E) {
-                // failed to parse filename, keep as is (most probably an unknown charset is used)
+            // a parameter given in RFC 2231 form was decoded by libmime already
+            let decoded = parsedContentDisposition.params.filename
+                ? rfc2231ParamNames(dispositionHeader).has('filename')
+                : rfc2231ParamNames(contentHeader).has('name');
+            if (!decoded) {
+                try {
+                    this.filename = this.libmime.decodeWords(this.filename);
+                } catch (E) {
+                    // failed to parse filename, keep as is (most probably an unknown charset is used)
+                }
             }
         }
 

package/node_modules/@zone-eu/mailsplit/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zone-eu/mailsplit",
-    "version": "5.4.21",
+    "version": "5.4.23",
     "description": "Split email messages into an object stream",
     "main": "index.js",
     "types": "index.d.ts",
@@ -16,8 +16,8 @@
     "license": "(MIT OR EUPL-1.1+)",
     "dependencies": {
         "libbase64": "1.3.3",
-        "libmime": "5.4.8",
-        "libqp": "2.1.2"
+        "libmime": "5.4.9",
+        "libqp": "2.1.3"
     },
     "devDependencies": {
         "@types/eslint": "9.6.1",

package/node_modules/libmime/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [5.4.9](https://github.com/nodemailer/libmime/compare/v5.4.8...v5.4.9) (2026-10-16)
+
+
+### Bug Fixes
+
+* bump libqp to 2.1.3 ([6cee51c](https://github.com/nodemailer/libmime/commit/6cee51c9f39367e762e05e07046abbd7b0e34399))
+* encode long non-ASCII words in linear time, refuse transfer-encoding codecs as charsets and mark RFC 2231 parameters as decoded ([60b3a88](https://github.com/nodemailer/libmime/commit/60b3a8881c2ff460573ee359e9d3148fcf766325))
+
 ## [5.4.8](https://github.com/nodemailer/libmime/compare/v5.4.7...v5.4.8) (2026-10-14)
 
 

package/node_modules/libmime/lib/charset.js

@@ -5,6 +5,13 @@ const iconv = require('iconv-lite');
 const encodingJapanese = require('encoding-japanese');
 const charsets = require('./charsets');
 
+// iconv-lite codecs that are not character sets a message could be written in. UTF-7 is a known
+// way to smuggle markup past filters (=?utf-7?Q?+ADw-script+AD4-?= decodes to "<script>"), base64
+// and hex are transfer encodings. A name resolving to one of them is treated like a charset
+// iconv-lite does not know. Compared in the canonical form iconv-lite itself resolves names in
+const UNSUPPORTED_CODECS = new Set(['utf7', 'utf7imap', 'base64', 'hex']);
+const isUnsupportedCodec = name => UNSUPPORTED_CODECS.has(name.toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, ''));
+
 /**
  * Character set encoding and decoding functions
  */
@@ -32,10 +39,15 @@ const charset = (module.exports = {
     decode(buf, fromCharset) {
         fromCharset = charset.normalizeCharset(fromCharset || 'UTF-8');
 
-        if (/^(us-)?ascii|utf-8|7bit$/i.test(fromCharset)) {
+        if (/^(?:(?:us-)?ascii|utf-8|7bit)$/i.test(fromCharset)) {
             return buf.toString('utf-8');
         }
 
+        if (isUnsupportedCodec(fromCharset)) {
+            // enforce utf-8, the same as for a charset iconv-lite does not know
+            return buf.toString();
+        }
+
         try {
             if (/^jis|^iso-?2022-?jp|^EUCJP/i.test(fromCharset)) {
                 if (typeof buf === 'string') {
@@ -76,7 +88,7 @@ const charset = (module.exports = {
         let bufString;
 
         if (typeof data !== 'string') {
-            if (/^(us-)?ascii|utf-8|7bit$/i.test(fromCharset)) {
+            if (/^(?:(?:us-)?ascii|utf-8|7bit)$/i.test(fromCharset)) {
                 return data;
             }
 

package/node_modules/libmime/lib/libmime.js

@@ -333,11 +333,6 @@ class Libmime {
         if (!firstMatch) {
             return decodedValue;
         }
-        let lastMatch = decodedValue.match(/([\u0080-\uFFFF][^\s]*)[^\u0080-\uFFFF]*$/);
-        if (!lastMatch) {
-            // should not happen
-            return decodedValue;
-        }
         let startIndex =
             firstMatch.index +
             (
@@ -345,7 +340,16 @@ class Libmime {
                     index: 0
                 }
             ).index;
-        let endIndex = lastMatch.index + (lastMatch[1] || '').length;
+
+        // The encoded part ends with the word that holds the last non ascii char. Found with a scan,
+        // the regex that used to do this rescanned the rest of the word from every non ascii char in
+        // it, which made a long non ascii word quadratic
+        let lastIndex = decodedValue.length - 1;
+        while (lastIndex >= 0 && decodedValue.charCodeAt(lastIndex) < 0x80) {
+            lastIndex--;
+        }
+        let wordEnd = decodedValue.slice(lastIndex + 1).search(/\s/);
+        let endIndex = wordEnd < 0 ? decodedValue.length : lastIndex + 1 + wordEnd;
 
         encodedValue =
             (startIndex ? decodedValue.substr(0, startIndex) : '') +
@@ -515,6 +519,10 @@ class Libmime {
      *     }
      *   }
      *
+     * The result also carries a non-enumerable `decodedParams` array that names the params
+     * assembled from rfc2231 segments (title*=, title*0*=, title*0=). Those values are already
+     * decoded, so a caller that runs decodeWords() over the params has to leave them out
+     *
      * @param {String} str Header value
      * @return {Object} Header value as a parsed structure
      */
@@ -523,6 +531,16 @@ class Libmime {
             value: false,
             params: {}
         };
+
+        // names of the params assembled from rfc2231 segments, see the continuation handling below.
+        // Non-enumerable, so the {value, params} shape callers serialize and compare stays as it is
+        Object.defineProperty(response, 'decodedParams', {
+            value: [],
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+
         let key = false;
         let value = '';
         // Length of the significant part of `value`. Whitespace outside of quotes is
@@ -656,6 +674,12 @@ class Libmime {
                 .map(val => val.value)
                 .join('');
 
+            // Both branches below store a decoded value, so a caller that runs decodeWords() over the
+            // params has to leave this one out. A value that percent-encodes an encoded word would
+            // otherwise be decoded twice: filename*=utf-8''invoice%3D%3Futf-8%3FQ%3F%3D2Eexe%3F%3D
+            // names the file "invoice=?utf-8?Q?=2Eexe?=", not "invoice.exe"
+            response.decodedParams.push(key);
+
             if (!continuation.charset) {
                 setOwnProperty(response.params, key, this.decodeWords(value));
                 continue;

package/node_modules/libmime/package.json

@@ -1,7 +1,7 @@
 {
     "name": "libmime",
     "description": "Encode and decode quoted printable and base64 strings",
-    "version": "5.4.8",
+    "version": "5.4.9",
     "main": "lib/libmime.js",
     "files": [
         "lib",
@@ -27,7 +27,7 @@
         "encoding-japanese": "2.4.0",
         "iconv-lite": "0.7.3",
         "libbase64": "1.3.3",
-        "libqp": "2.1.2"
+        "libqp": "2.1.3"
     },
     "devDependencies": {
         "chai": "4.4.1",

package/node_modules/libqp/.github/VULNERABILITY_REPORT.yml

@@ -0,0 +1,75 @@
+name: "libqp security vulnerability report"
+description: "Report an exploitable security vulnerability in libqp"
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Before reporting, read our
+        [Security Policy](https://github.com/nodemailer/libqp/security/policy).
+
+        Reports must demonstrate a credible security impact.
+        Technically valid bugs without a realistic attack
+        scenario belong in the regular issue tracker.
+
+  - type: textarea
+    id: summary
+    attributes:
+      label: Vulnerability summary
+      description: Describe the vulnerability and affected versions.
+    validations:
+      required: true
+
+  - type: textarea
+    id: attacker
+    attributes:
+      label: Attacker capabilities
+      description: |
+        What can an attacker control without already having
+        privileged access to the application or its configuration?
+    validations:
+      required: true
+      min_length: 100
+
+  - type: textarea
+    id: exploit
+    attributes:
+      label: Realistic exploitation scenario
+      description: |
+        Describe how this can be exploited in a real application.
+        Explain the prerequisites and security boundary crossed.
+    validations:
+      required: true
+      min_length: 150
+
+  - type: textarea
+    id: poc
+    attributes:
+      label: Proof of concept
+      description: Provide reproducible steps or working code.
+    validations:
+      required: true
+
+  - type: textarea
+    id: impact
+    attributes:
+      label: Security impact
+      description: |
+        What can the attacker achieve? Who is affected?
+        Explain why this is a security vulnerability rather
+        than an ordinary bug.
+    validations:
+      required: true
+      min_length: 100
+
+  - type: checkboxes
+    id: confirmation
+    attributes:
+      label: Reporting requirements
+      options:
+        - label: I have read the Security Policy.
+          required: true
+        - label: I have verified the finding against a supported version.
+          required: true
+        - label: I have described a credible attacker-controlled scenario.
+          required: true

package/node_modules/libqp/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [2.1.3](https://github.com/nodemailer/libqp/compare/v2.1.2...v2.1.3) (2026-10-16)
+
+
+### Bug Fixes
+
+* decode trailing whitespace in linear time and never start an encoded line with a hyphen ([9ece8c1](https://github.com/nodemailer/libqp/commit/9ece8c11826b88509afd968d5bc5b83f5f447e18))
+
 ## [2.1.2](https://github.com/nodemailer/libqp/compare/v2.1.1...v2.1.2) (2026-09-28)
 
 

package/node_modules/libqp/SECURITY.md

@@ -0,0 +1,147 @@
+# Security Policy
+
+libqp encodes and decodes quoted-printable strings and streams as defined in RFC
+2045 (MIME). It is used to decode untrusted email content. We welcome
+responsible reports of vulnerabilities that present a credible security risk to
+users. Please distinguish security vulnerabilities from ordinary bugs, unusual
+edge cases, and hardening suggestions.
+
+## Supported Versions
+
+Security fixes are released only against the latest major version. We do not
+backport patches to older majors, so upgrading to the current release line is
+the supported way to receive security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 2.x     | :white_check_mark: |
+| < 2.0   | :x:                |
+
+If you are on an older major, please upgrade. See [CHANGELOG.md](CHANGELOG.md)
+before updating.
+
+## What Qualifies as a Security Vulnerability
+
+A security report should identify a realistic way for an attacker to cross a
+security boundary in a supported version of libqp. Unexpected behavior, a
+failing test, or a technically correct proof of concept is not sufficient on its
+own to establish security impact.
+
+In particular, explain:
+
+- **Attacker capabilities:** Who is the attacker, and what inputs, systems, or
+  responses can they control _without_ already having the privileges or secrets
+  they are trying to gain?
+- **Attack path:** How does attacker-controlled input reach the affected code
+  through a supported public API or a realistic application integration?
+- **Prerequisites:** What configuration and user actions are required? If the
+  attack depends on unusual options or deliberately malformed input, explain why
+  those conditions could arise in a real application.
+- **Impact:** What confidentiality, integrity, or availability boundary is
+  crossed, and what can the attacker achieve as a result?
+
+A vulnerability involving an optional or less common feature can still qualify
+if these conditions are met. Conversely, the existence of a defensive check in
+the code does not, by itself, establish that every bypass of that check has a
+realistic security impact.
+
+## Reporting a Vulnerability
+
+**Do not disclose suspected exploitable vulnerabilities through public GitHub
+issues, pull requests, or discussions before coordinating with the
+maintainers.**
+
+Report privately through one of the following channels:
+
+1. **GitHub Security Advisories (preferred):**
+   <https://github.com/nodemailer/libqp/security/advisories/new>.
+2. **Email:** **andris@reinman.eu**. Encrypt sensitive details if possible (PGP
+   key fingerprint `5D952A46E1D8C931F6364E01DC6C83F4D584D364`).
+
+### Required Information
+
+Please provide enough information to evaluate both the defect and its security
+impact. Reports should include:
+
+1. The affected libqp version or commit, Node.js version, and relevant
+   configuration.
+2. A concise description of the issue and the affected public API or code path.
+3. A minimal, tested reproduction, including steps to run it, expected behavior,
+   and observed behavior.
+4. A concrete threat model: attacker control, prerequisites, trust boundary, and
+   resulting impact. Clearly distinguish what your reproduction proves from what
+   you believe might be possible.
+5. An explanation of why the issue affects real deployments beyond a
+   deliberately constructed test setup, where this is not obvious.
+
+A suggested fix is welcome but does not replace an explanation of
+exploitability. A complete real-world exploit is not always necessary, but the
+report must make a credible security impact clear.
+
+### Reports That May Be Treated as Ordinary Bugs
+
+The following generally do **not** qualify for private security handling unless
+you can demonstrate an additional, meaningful security boundary crossing:
+
+- Issues that require the attacker to control trusted application code,
+  administrator-only configuration, or the secret they supposedly extract.
+- Problems caused solely by application-level misuse, exposed credentials, or
+  insecure deployment choices outside libqp's control.
+- Contrived proof-of-concept setups where the tester controls both sides of a
+  request, without explaining how a separate attacker could trigger the issue.
+- Parser quirks, unexpected behavior, and bypasses of internal checks with no
+  demonstrated security impact.
+- Speculative findings based only on static analysis or an automated tool's
+  assessment, without a verified reproduction and credible attack scenario.
+
+These may still be valid bugs and may be considered through the normal issue
+tracker. Please coordinate before making any potentially exploitable details
+public. Classification as a bug does not guarantee a fix or a particular
+priority.
+
+### Automated and AI-Assisted Reports
+
+Automated analysis and AI tools are welcome as research aids, but the person
+submitting a report is responsible for verifying its claims. **Do not submit
+bulk, unverified, or speculative AI-generated findings.** Test each finding
+against a supported release and establish the actual security impact. Reports
+that do not meet the requirements above may be closed without further
+investigation or individual feedback; they can be resubmitted with stronger
+evidence.
+
+## Triage and Disclosure
+
+libqp is maintained by a single person, and there is **no guaranteed response or
+resolution time**. Reports are prioritized based on demonstrated impact,
+exploitability, affected usage, and available maintenance resources.
+
+A private report does not automatically become a security advisory. Confirmed
+vulnerabilities may be fixed and disclosed through GitHub Security Advisories;
+other findings may be closed, deferred, or handled as ordinary bugs. Please do
+not disclose details of an unresolved, potentially exploitable issue publicly
+without coordinating with the maintainers.
+
+## CVEs and Credit
+
+We do not request or manage CVE identifiers. A report being acknowledged, a bug
+being fixed, or a pull request being merged does **not** mean that libqp has
+confirmed a security vulnerability or endorsed a CVE assignment. We do not
+guarantee advisories, CVE identifiers, or public credit for reports. For
+confirmed vulnerabilities disclosed through an advisory, substantive reporters
+may be credited if they wish.
+
+## Scope
+
+In scope: the libqp source in this repository: the encoder and decoder functions
+and their stream variants. Of particular interest are inputs that crash the
+process, corrupt output beyond the malformed input, or consume resources out of
+proportion to their size.
+
+Out of scope:
+
+- Resource consumption that is proportional to a legitimately large input.
+- Vulnerabilities in your own application code, including how it handles decoded
+  data.
+- Social-engineering reports.
+
+Thank you for helping keep libqp and its users safe.