MimeUtility.decodeText() incorrectly decodes base64/utf8 atttachment file name divided into two parts with Chinese characters

[underenveloped]

Describe the bug
MimeUtility.decodeText() incorrectly decodes base64/utf8 atttachment file name divided into two parts.
Example:
Content-Type: application/octet-stream;
name="=?utf-8?B?MV90b18xX2NoYXRfMjE5ODMxMjRfMTkwMzIwMjRf5p2O55SzX+Wwj+ax?=
=?utf-8?B?h+axh0nlj7fmnLouanNvbg==?="
Content-Transfer-Encoding: base64
Content-Disposition: attachment*/

To Reproduce
Steps to reproduce the behavior:

1. Execute: MimeUtility.decodeText("=?utf-8?B?MV90b18xX2NoYXRfMjE5ODMxMjRfMTkwMzIwMjRf5p2O55SzX+Wwj+ax?= =?utf-8?B?h+axh0nlj7fmnLouanNvbg==?=");

Expected behavior
Decoded result: "1_to_1_chat_21983124_19032024_李申_小汇汇I号机.json" (according to any mail client)

Actual Behaviour
Decoded result: "1_to_1_chat_21983124_19032024_李申_小��汇I号机.json"
(Hieroglyph 汇 decoded as ��)

If to concatinate two parts of encoded name in advance we receive correct value. It seems that MimeUtility should concatinate encoded parts first and only after that to decode them.
MimeUtility.decodeText("=?utf-8?B?MV90b18xX2NoYXRfMjE5ODMxMjRfMTkwMzIwMjRf5p2O55SzX+Wwj+axh+axh0nlj7fmnLouanNvbg==?=");

jakarta.mail-api:2.1.3

[underenveloped]

This is a screenshot from Apple Mail where it is possible to see that file name decoded correctly

[underenveloped]

`X-ZLAuthOn:
Received: from root@fgfgf.com (EHLO a301-5135-6188.ldn.fgfgfg.com a301-5135-6188.ldn.fgfgf.com [00.00.00.00] )
by 10.33.116.26 with ESMTP id L11K3UYOFEEQZICU252VWHEDSA0Q0KR4B
for <>; Tue, 19 Mar 2024 15:42:39 +0800 (SGT)
Received: by a301-5135-6188.ldn.sdsdsd.com (Postfix)
id EBB7C4ECD5; Tue, 19 Mar 2024 07:42:38 +0000 (GMT)
Delivered-To: ziplipcfets@sdsdsd.com
Received: by a301-5135-6188.ldn.sdsds.com (Postfix, from userid 0)
id E4D6B4ECC4; Tue, 19 Mar 2024 07:42:38 +0000 (GMT)
Received: from nsha19120uap (nsha19120uap.dfdfprod.msad.fgfg.net [00.00.00.00])
by a301-5135-6188.ldn.sdsd.com (Postfix) with ESMTP id 10AB44ECD5;
Tue, 19 Mar 2024 07:42:25 +0000 (GMT)
X-CFETS-Participants: dfdf@dfdf.com,dfdf@clientdfd.CFETS
X-CFETS-GroupName: NA
charset: UTF-8
X-Journal-Only: True
X-CFETS-ConversationID: 21983124
X-CFETS-StartTime: Mon, 18 Mar 2024 05:16:00
X-CFETS-EndTime: Mon, 18 Mar 2024 05:31:00
X-CFETS-ContentType: IM
X-CFETS-NetworkName: CFETS External
MIME-Version: 1.0
From: cfets@ddf.com
To: fdfds@dfd.com, fdfdfdf@clientfdf.CFETS
Date: 19 Mar 2024 15:42:26 +0800
Subject: 1-1 Interaction for CFETS External messaging with 21983124 (1)
Content-Type: multipart/mixed;
boundary=--boundary_6_64b83386-7e0a-4a97-8bf5-0f04533c6ec6
X-$Switch: Processed="1"
Message-Id: 20240319074226.10AB44ECD5@a301-5135-6188.ldn.dfdf.com

----boundary_6_64b83386-7e0a-4a97-8bf5-0f04533c6ec6
Content-Type: multipart/alternative;
boundary=--boundary_5_5bcefded-7a97-450f-9beb-15ffa0d3a76b

----boundary_6_64b83386-7e0a-4a97-8bf5-0f04533c6ec6
Content-Type: multipart/mixed;
boundary=--boundary_7_74cfe6d9-c3ea-4174-9582-2be2d2987530

----boundary_7_74cfe6d9-c3ea-4174-9582-2be2d2987530
Content-Type: application/octet-stream;
name="=?utf-8?B?MV90b18xX2NoYXRfMjE5ODMxMjRfMTkwMzIwMjRf5p2O55SzX+Wwj+ax?=
=?utf-8?B?h+axh0nlj7fmnLouanNvbg==?="
Content-Transfer-Encoding: base64
Content-Disposition: attachment
`

[underenveloped]

There is solution proposed by Claude based on this bug explanation. I made overridden version of problematic class in my project and it works for me:

`public static String decodeText(String etext)
throws UnsupportedEncodingException {

String lwsp = " \t\n\r";
StringTokenizer st;

if (!etext.contains("=?"))
    return etext;

// Encoded words found. Start decoding ...

st = new StringTokenizer(etext, lwsp, true);
StringBuilder sb = new StringBuilder();  // decode buffer
StringBuilder wsb = new StringBuilder(); // white space buffer
boolean prevWasEncoded = false;

// Buffer for consecutive encoded words with same charset/encoding
StringBuilder encodedWordsBuffer = new StringBuilder();
String currentCharset = null;
String currentEncoding = null;

while (st.hasMoreTokens()) {
    char c;
    String s = st.nextToken();
    // If whitespace, append it to the whitespace buffer
    if (((c = s.charAt(0)) == ' ') || (c == '\t') ||
            (c == '\r') || (c == '\n'))
        wsb.append(c);
    else {
        // Check if token is an 'encoded-word' ..
        String word;
        try {
            // First check if it's a valid encoded word
            if (s.startsWith("=?") && s.endsWith("?=")) {
                // Parse the encoded word to extract charset and encoding
                int charsetEnd = s.indexOf('?', 2);
                if (charsetEnd > 0) {
                    int encodingEnd = s.indexOf('?', charsetEnd + 1);
                    if (encodingEnd > 0) {
                        String charset = s.substring(2, charsetEnd);
                        String encoding = s.substring(charsetEnd + 1, encodingEnd);
                        String encodedText = s.substring(encodingEnd + 1, s.length() - 2);
                        
                        // Check if this encoded word continues the previous one
                        if (prevWasEncoded && charset.equalsIgnoreCase(currentCharset) 
                                && encoding.equalsIgnoreCase(currentEncoding)) {
                            // Accumulate encoded content
                            encodedWordsBuffer.append(encodedText);
                            continue; // Continue to the next token
                        } else {
                            // Decode any buffered content first
                            if (encodedWordsBuffer.length() > 0) {
                                word = decodeEncodedContent(currentCharset, currentEncoding, 
                                        encodedWordsBuffer.toString());
                                sb.append(word);
                                encodedWordsBuffer.setLength(0);
                            }
                            
                            // Start new buffer
                            currentCharset = charset;
                            currentEncoding = encoding;
                            encodedWordsBuffer.append(encodedText);
                            prevWasEncoded = true;
                            
                            // Skip whitespace as per RFC 2047
                            wsb.setLength(0);
                            continue;
                        }
                    }
                }
            }
            
            // If we get here, either the current token is not an encoded word,
            // or we couldn't parse it correctly - try the original decodeWord
            
            // First decode any buffered content
            if (encodedWordsBuffer.length() > 0) {
                word = decodeEncodedContent(currentCharset, currentEncoding, 
                        encodedWordsBuffer.toString());
                sb.append(word);
                encodedWordsBuffer.setLength(0);
                currentCharset = null;
                currentEncoding = null;
            }
            
            word = decodeWord(s);
            // Yes, this IS an 'encoded-word'.
            if (!prevWasEncoded && wsb.length() > 0) {
                // if the previous word was also encoded, we
                // should ignore the collected whitespace. Else
                // we include the whitespace as well.
                sb.append(wsb);
            }
            prevWasEncoded = true;
        } catch (ParseException pex) {
            // First decode any buffered content
            if (encodedWordsBuffer.length() > 0) {
                try {
                    word = decodeEncodedContent(currentCharset, currentEncoding, 
                            encodedWordsBuffer.toString());
                    sb.append(word);
                } catch (Exception e) {
                    // If we can't decode the buffer, just clear it
                }
                encodedWordsBuffer.setLength(0);
                currentCharset = null;
                currentEncoding = null;
            }
            
            // This is NOT an 'encoded-word'.
            word = s;
            // possibly decode inner encoded words
            if (!decodeStrict) {
                String dword = decodeInnerWords(word);
                if (dword != word) {
                    // if a different String object was returned,
                    // decoding was done.
                    if (prevWasEncoded && word.startsWith("=?")) {
                        // encoded followed by encoded,
                        // throw away whitespace between
                    } else {
                        // include collected whitespace ..
                        if (wsb.length() > 0)
                            sb.append(wsb);
                    }
                    // did original end with encoded?
                    prevWasEncoded = word.endsWith("?=");
                    word = dword;
                } else {
                    // include collected whitespace ..
                    if (wsb.length() > 0)
                        sb.append(wsb);
                    prevWasEncoded = false;
                }
            } else {
                // include collected whitespace ..
                if (wsb.length() > 0)
                    sb.append(wsb);
                prevWasEncoded = false;
            }
            sb.append(word); // append the actual word
        }
        wsb.setLength(0); // reset wsb for reuse
    }
}

// Handle any remaining buffered content
if (encodedWordsBuffer.length() > 0) {
    try {
        String word = decodeEncodedContent(currentCharset, currentEncoding, 
                encodedWordsBuffer.toString());
        sb.append(word);
    } catch (Exception e) {
        // If we can't decode the buffer, just ignore it
    }
}

sb.append(wsb);        // append trailing whitespace
return sb.toString();

}

/**

• Helper method to decode the combined encoded content
  */
  private static String decodeEncodedContent(String charset, String encoding, String encodedText)
  throws UnsupportedEncodingException {
  if (encoding.equalsIgnoreCase("B")) {
  // Base64 encoding
  byte[] bytes = Base64.getDecoder().decode(encodedText);
  return new String(bytes, charset);
  } else if (encoding.equalsIgnoreCase("Q")) {
  // Quoted-Printable encoding
  byte[] bytes = qpDecode(encodedText);
  return new String(bytes, charset);
  } else {
  throw new UnsupportedEncodingException("Unknown encoding: " + encoding);
  }
  }

/**

• Basic implementation of Quoted-Printable decoding
• (You might want to use the actual implementation from Jakarta Mail)
  */
  private static byte[] qpDecode(String encodedText) {
  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  for (int i = 0; i < encodedText.length(); i++) {
  char c = encodedText.charAt(i);
  if (c == '_') {
  baos.write(' ');
  } else if (c == '=' && i < encodedText.length() - 2) {
  try {
  String hex = encodedText.substring(i + 1, i + 3);
  baos.write(Integer.parseInt(hex, 16));
  i += 2;
  } catch (NumberFormatException e) {
  baos.write(c);
  }
  } else {
  baos.write(c);
  }
  }
  return baos.toByteArray();
  }`

[jhumphreys]

I am also facing this problem. It seems like RFC 2047 didn't really anticipate that a single multibyte character would be split across two encoded-words. But it doesn't explicitly forbid it, as far as I can see. Outlook and Gmail seem to support it.

The suggested solution above does not work if the base64 encoded text in the first word ends with padding characters. For example, it fails with this input:

=?utf-8?B?4piD4piD4g==?=  =?utf-8?B?mIPimIPimIM=?=