This is an automated email from the ASF dual-hosted git repository.

chibenwa pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-mime4j.git

commit 87de46594d00d32ed9395c10c3b03dd076f176ed
Author: Benoit TELLIER <[email protected]>
AuthorDate: Fri Nov 13 14:04:22 2026 +0100

    [FIX] MessageMatcher: header fields are bounded, and maxTotalHeaderLen 
bounds a field when maxHeaderLen is off
    
    MessageMatcher, which James uses on untrusted mail for the Sieve body test
    and the in-memory BODY / TEXT search, parsed with setMaxHeaderLen(-1).
    MimeEntity#readRawField derives its line bound from maxHeaderLen, so a
    single field of N bytes, on one line or folded over many, was held whole
    in the line buffer and the field builder, each doubling, then decoded to a
    String, before maxTotalHeaderLen rejected it once the field was built.
    
    MessageMatcher now keeps body lines unbounded but bounds header fields at
    the MimeConfig.PERMISSIVE header length (64 KB), and a field over it ends
    the search without a match instead of failing the caller.
    
    In core, when maxHeaderLen is turned off, maxTotalHeaderLen, which a
    single field cannot exceed either, bounds the header line read and the
    default field builder: the message wide limit stops the buffering instead
    of applying once the field is built.
---
 .../org/apache/james/mime4j/stream/MimeEntity.java | 25 ++++++++--
 .../james/mime4j/stream/MimeTokenStream.java       |  2 +-
 .../james/mime4j/stream/HeaderLineBoundTest.java   | 55 ++++++++++++++++++++++
 .../james/mime4j/utils/search/MessageMatcher.java  | 10 +++-
 .../mime4j/utils/search/MessageMatcherTest.java    | 35 ++++++++++++++
 5 files changed, 122 insertions(+), 5 deletions(-)

diff --git a/core/src/main/java/org/apache/james/mime4j/stream/MimeEntity.java 
b/core/src/main/java/org/apache/james/mime4j/stream/MimeEntity.java
index fc54b8f2..215efa3b 100644
--- a/core/src/main/java/org/apache/james/mime4j/stream/MimeEntity.java
+++ b/core/src/main/java/org/apache/james/mime4j/stream/MimeEntity.java
@@ -131,7 +131,7 @@ class MimeEntity implements EntityStateMachine {
         this(lineSource, instream, config,
                 EntityState.T_START_MESSAGE, EntityState.T_END_MESSAGE,
                 config.isStrictParsing() ? DecodeMonitor.STRICT : 
DecodeMonitor.SILENT,
-                new DefaultFieldBuilder(config.getMaxHeaderLen()),
+                new DefaultFieldBuilder(fieldLengthLimit(config)),
                 bodyDescBuilder);
     }
 
@@ -230,6 +230,23 @@ class MimeEntity implements EntityStateMachine {
         }
     }
 
+    /**
+     * The length over which a header field cannot be accepted: maxHeaderLen, 
or when it is turned
+     * off, maxTotalHeaderLen, which a single field cannot exceed either. 
Without it, turning off
+     * maxHeaderLen (as MessageMatcher did) let one field be buffered whole, 
several times over,
+     * before the message wide limit rejected it.
+     *
+     * @return the limit, or -1 when there is none.
+     */
+    static int fieldLengthLimit(final MimeConfig config) {
+        int maxHeaderLen = config.getMaxHeaderLen();
+        if (maxHeaderLen > 0) {
+            return maxHeaderLen;
+        }
+        long maxTotalHeaderLen = config.getMaxTotalHeaderLen();
+        return maxTotalHeaderLen > 0 ? (int) Math.min(maxTotalHeaderLen, 
Integer.MAX_VALUE) : -1;
+    }
+
     /**
      * The length of a header line as {@link DefaultFieldBuilder#append} 
counts it: a CRLF line end
      * counts as one byte.
@@ -248,7 +265,7 @@ class MimeEntity implements EntityStateMachine {
         LineReaderInputStream instream = getDataStream();
         // A line of more than maxHeaderLen bytes cannot belong to an accepted 
field: stop
         // buffering it there, even when the line length is not bounded 
(MimeConfig.PERMISSIVE)
-        int maxHeaderLen = config.getMaxHeaderLen();
+        int maxHeaderLen = fieldLengthLimit(config);
         int lineBound = maxHeaderLen > 0 && maxHeaderLen < Integer.MAX_VALUE ? 
maxHeaderLen + 1 : -1;
         try {
             for (;;) {
@@ -265,7 +282,9 @@ class MimeEntity implements EntityStateMachine {
                 // field before it is never emitted, whatever the read sizes
                 if (lineBound > 0 && measuredLength(linebuf) > maxHeaderLen) {
                     linebuf.clear();
-                    throw new MaxHeaderLengthLimitException("Maximum header 
length limit (" + maxHeaderLen + ") exceeded");
+                    throw new 
MaxHeaderLengthLimitException(config.getMaxHeaderLen() > 0
+                        ? "Maximum header length limit (" + maxHeaderLen + ") 
exceeded"
+                        : "Maximum total header length limit (" + maxHeaderLen 
+ ") exceeded");
                 }
                 if (read == -1) {
                     if (!stopped) {
diff --git 
a/core/src/main/java/org/apache/james/mime4j/stream/MimeTokenStream.java 
b/core/src/main/java/org/apache/james/mime4j/stream/MimeTokenStream.java
index d60a95ee..7445ae6f 100644
--- a/core/src/main/java/org/apache/james/mime4j/stream/MimeTokenStream.java
+++ b/core/src/main/java/org/apache/james/mime4j/stream/MimeTokenStream.java
@@ -136,7 +136,7 @@ public class MimeTokenStream {
         super();
         this.config = config != null ? config : MimeConfig.DEFAULT;
         this.fieldBuilder = fieldBuilder != null ? fieldBuilder :
-            new DefaultFieldBuilder(this.config.getMaxHeaderLen());
+            new DefaultFieldBuilder(MimeEntity.fieldLengthLimit(this.config));
         this.monitor = monitor != null ? monitor :
             (this.config.isStrictParsing() ? DecodeMonitor.STRICT : 
DecodeMonitor.SILENT);
         this.bodyDescBuilder = bodyDescBuilder != null ? bodyDescBuilder :
diff --git 
a/core/src/test/java/org/apache/james/mime4j/stream/HeaderLineBoundTest.java 
b/core/src/test/java/org/apache/james/mime4j/stream/HeaderLineBoundTest.java
index 4af1eeaf..47120eb0 100644
--- a/core/src/test/java/org/apache/james/mime4j/stream/HeaderLineBoundTest.java
+++ b/core/src/test/java/org/apache/james/mime4j/stream/HeaderLineBoundTest.java
@@ -166,4 +166,59 @@ public class HeaderLineBoundTest {
         }
         Assert.assertEquals(1024 * 1024, body.served);
     }
+
+    /** Serves the same folded line, "\r\n " and 98 bytes of 'a', 
<code>count</code> times. */
+    private static class FoldedLines extends InputStream {
+        private static final byte[] LINE = ("\r\n " + new String(new 
char[98]).replace('\0', 'a'))
+            .getBytes(StandardCharsets.US_ASCII);
+        private final long size;
+        private long served;
+
+        FoldedLines(long count) {
+            this.size = count * LINE.length;
+        }
+
+        @Override
+        public int read() {
+            return served < size ? LINE[(int) (served++ % LINE.length)] : -1;
+        }
+    }
+
+    private static final MimeConfig NO_FIELD_LIMIT = MimeConfig.custom()
+        .setMaxLineLen(-1)
+        .setMaxHeaderLen(-1)
+        .build(); // maxTotalHeaderLen 1 MB
+
+    @Test
+    public void 
withoutFieldLimitAHugeHeaderLineShouldStopAtTheTotalHeaderLimit() throws 
Exception {
+        LongLine line = new LongLine(TEN_MB);
+        try {
+            parseAll(NO_FIELD_LIMIT, new SequenceInputStream(ascii("X-A: "), 
line));
+            Assert.fail("Expected MaxHeaderLengthLimitException");
+        } catch (MaxHeaderLengthLimitException expected) {
+            long maxTotalHeaderLen = NO_FIELD_LIMIT.getMaxTotalHeaderLen();
+            Assert.assertTrue("read " + line.served + " bytes of the line", 
line.served < maxTotalHeaderLen + 64 * 1024);
+        }
+    }
+
+    @Test
+    public void 
withoutFieldLimitAHugeFoldedFieldShouldStopAtTheTotalHeaderLimit() throws 
Exception {
+        FoldedLines lines = new FoldedLines(TEN_MB / 100);
+        try {
+            parseAll(NO_FIELD_LIMIT, new SequenceInputStream(ascii("X-A: b"), 
lines));
+            Assert.fail("Expected MaxHeaderLengthLimitException");
+        } catch (MaxHeaderLengthLimitException expected) {
+            long maxTotalHeaderLen = NO_FIELD_LIMIT.getMaxTotalHeaderLen();
+            Assert.assertTrue("read " + lines.served + " bytes", lines.served 
< maxTotalHeaderLen + 64 * 1024);
+        }
+    }
+
+    @Test
+    public void withoutFieldLimitAFieldUnderTheTotalHeaderLimitIsAccepted() 
throws Exception {
+        StringBuilder sb = new StringBuilder("X-A: ");
+        for (int i = 0; i < 512 * 1024; i++) {
+            sb.append('a');
+        }
+        parseAll(NO_FIELD_LIMIT, ascii(sb.append("\r\n\r\nbody").toString()));
+    }
 }
diff --git 
a/james-utils/src/main/java/org/apache/james/mime4j/utils/search/MessageMatcher.java
 
b/james-utils/src/main/java/org/apache/james/mime4j/utils/search/MessageMatcher.java
index 71cb41f0..8e4ad39d 100644
--- 
a/james-utils/src/main/java/org/apache/james/mime4j/utils/search/MessageMatcher.java
+++ 
b/james-utils/src/main/java/org/apache/james/mime4j/utils/search/MessageMatcher.java
@@ -20,6 +20,7 @@ package org.apache.james.mime4j.utils.search;
 
 import com.google.common.collect.ImmutableList;
 import org.apache.james.mime4j.MimeException;
+import org.apache.james.mime4j.io.MaxHeaderLengthLimitException;
 import org.apache.james.mime4j.stream.EntityState;
 import org.apache.james.mime4j.stream.MimeConfig;
 import org.apache.james.mime4j.stream.MimeTokenStream;
@@ -147,7 +148,12 @@ public class MessageMatcher {
 
     private boolean matchBufferInMailBeingMimeAware(final InputStream input, 
final List<NeedleMatcher> matchers) throws IOException, MimeException {
         try {
-            MimeConfig config = 
MimeConfig.custom().setMaxLineLen(-1).setMaxHeaderLen(-1).build();
+            // Body lines are not bounded, but header fields are, as by 
MimeConfig.PERMISSIVE: the
+            // message is untrusted, and a field over the limit ends the search
+            MimeConfig config = MimeConfig.custom()
+                .setMaxLineLen(-1)
+                .setMaxHeaderLen(MimeConfig.PERMISSIVE.getMaxHeaderLen())
+                .build();
 
             MimeTokenStream parser = new MimeTokenStream(config);
             parser.parse(input);
@@ -189,6 +195,8 @@ public class MessageMatcher {
             handle(e);
         } catch (IllegalStateException e) {
             handle(e);
+        } catch (MaxHeaderLengthLimitException e) {
+            handle(e);
         }
         return false;
     }
diff --git 
a/james-utils/src/test/java/org/apache/james/mime4j/utils/search/MessageMatcherTest.java
 
b/james-utils/src/test/java/org/apache/james/mime4j/utils/search/MessageMatcherTest.java
index 0851e075..40a29255 100644
--- 
a/james-utils/src/test/java/org/apache/james/mime4j/utils/search/MessageMatcherTest.java
+++ 
b/james-utils/src/test/java/org/apache/james/mime4j/utils/search/MessageMatcherTest.java
@@ -233,4 +233,39 @@ public class MessageMatcherTest {
         return 
ClassLoader.getSystemClassLoader().getResourceAsStream(resourceName);
     }
 
+
+    private static InputStream messageWithAHugeHeaderField(String header, 
String body) {
+        StringBuilder sb = new StringBuilder("Subject: test\r\nX-A: ");
+        for (int i = 0; i < 2 * 1024 * 1024; i++) {
+            sb.append('a');
+        }
+        sb.append("\r\n").append(header).append("\r\n").append(body);
+        return new 
ByteArrayInputStream(sb.toString().getBytes(StandardCharsets.US_ASCII));
+    }
+
+    @Test(timeout = 10000)
+    public void hugeHeaderFieldShouldEndTheSearchWithoutAMatch() throws 
Exception {
+        MessageMatcher messageMatcher = MessageMatcher.builder()
+            .searchContents(Lists.<CharSequence>newArrayList("needle"))
+            .caseInsensitive(true)
+            .includeHeaders(true)
+            .build();
+        
assertThat(messageMatcher.messageMatches(messageWithAHugeHeaderField("X-B: 
needle", "needle"))).isFalse();
+    }
+
+    @Test
+    public void headerFieldUnderThePermissiveLimitShouldStillBeSearched() 
throws Exception {
+        StringBuilder sb = new StringBuilder("Subject: test\r\nX-A: ");
+        for (int i = 0; i < 60 * 1024; i++) {
+            sb.append('a');
+        }
+        sb.append(" needle\r\n\r\nbody");
+        MessageMatcher messageMatcher = MessageMatcher.builder()
+            .searchContents(Lists.<CharSequence>newArrayList("needle"))
+            .caseInsensitive(true)
+            .includeHeaders(true)
+            .build();
+        assertThat(messageMatcher.messageMatches(
+            new 
ByteArrayInputStream(sb.toString().getBytes(StandardCharsets.US_ASCII)))).isTrue();
+    }
 }


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to