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]
