Added properties for base64 formatting

pom.xml

@@ -551,6 +551,80 @@
                         <LANGUAGE>en_US:us</LANGUAGE>
                     </environmentVariables>
                 </configuration>
+                <executions>
+                    <execution>
+                        <id>formatting-ignore-line-breaks</id>
+                        <goals>
+                            <goal>test</goal>
+                        </goals>
+                        <configuration>
+                            <groups>formattingTest</groups>
+                            <systemPropertiesFile>
+                                ${project.build.testOutputDirectory}/formatting/ignore-line-breaks.properties
+                            </systemPropertiesFile>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <id>formatting-ignore-line-breaks-override</id>
+                        <goals>
+                            <goal>test</goal>
+                        </goals>
+                        <configuration>
+                            <groups>formattingTest</groups>
+                            <systemPropertiesFile>
+                                ${project.build.testOutputDirectory}/formatting/ignore-line-breaks-override.properties
+                            </systemPropertiesFile>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <id>formatting-ignore-base64-line-breaks</id>
+                        <goals>
+                            <goal>test</goal>
+                        </goals>
+                        <configuration>
+                            <groups>formattingTest</groups>
+                            <systemPropertiesFile>
+                                ${project.build.testOutputDirectory}/formatting/ignore-base64-line-breaks.properties
+                            </systemPropertiesFile>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <id>formatting-ignore-base64-line-breaks-override</id>
+                        <goals>
+                            <goal>test</goal>
+                        </goals>
+                        <configuration>
+                            <groups>formattingTest</groups>
+                            <systemPropertiesFile>
+                                ${project.build.testOutputDirectory}/formatting/ignore-base64-line-breaks-override.properties
+                            </systemPropertiesFile>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <id>formatting-base64-custom-formatting</id>
+                        <goals>
+                            <goal>test</goal>
+                        </goals>
+                        <configuration>
+                            <groups>formattingTest</groups>
+                            <systemPropertiesFile>
+                                ${project.build.testOutputDirectory}/formatting/base64-custom-formatting.properties
+                            </systemPropertiesFile>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <id>formatting-illegal</id>
+                        <goals>
+                            <goal>test</goal>
+                        </goals>
+                        <configuration>
+                            <groups>formattingTest</groups>
+                            <systemPropertiesFile>
+                                ${project.build.testOutputDirectory}/formatting/illegal.properties
+                            </systemPropertiesFile>
+                        </configuration>
+                    </execution>
+                </executions>
             </plugin>
             <plugin>
                 <artifactId>maven-failsafe-plugin</artifactId>

src/main/java/org/apache/xml/security/signature/XMLSignature.java

@@ -684,11 +684,7 @@ private void setSignatureValueElement(byte[] bytes) {
             signatureValueElement.removeChild(signatureValueElement.getFirstChild());
         }
 
-        String base64codedValue = XMLUtils.encodeToString(bytes);
-
-        if (base64codedValue.length() > 76 && !XMLUtils.ignoreLineBreaks()) {
-            base64codedValue = "\n" + base64codedValue + "\n";
-        }
+        String base64codedValue = XMLUtils.encodeElementValue(bytes);
 
         Text t = createText(base64codedValue);
         signatureValueElement.appendChild(t);

src/main/java/org/apache/xml/security/stax/impl/processor/output/AbstractEncryptOutputProcessor.java

@@ -40,8 +40,6 @@
 import javax.xml.stream.XMLStreamConstants;
 import javax.xml.stream.XMLStreamException;
 
-import org.apache.commons.codec.binary.Base64;
-import org.apache.commons.codec.binary.Base64OutputStream;
 import org.apache.xml.security.algorithms.JCEMapper;
 import org.apache.xml.security.encryption.XMLCipherUtil;
 import org.apache.xml.security.exceptions.XMLSecurityException;
@@ -176,14 +174,7 @@ public void init(OutputProcessorChain outputProcessorChain) throws XMLSecurityEx
                 symmetricCipher.init(Cipher.ENCRYPT_MODE, encryptionPartDef.getSymmetricKey(), parameterSpec);
 
                 characterEventGeneratorOutputStream = new CharacterEventGeneratorOutputStream();
-                Base64OutputStream.Builder builder = Base64OutputStream.builder()
-                        .setOutputStream(characterEventGeneratorOutputStream)
-                        .setEncode(true);
-                if (XMLUtils.isIgnoreLineBreaks()) {
-                    builder.setBaseNCodec(Base64.builder().setLineLength(0).setLineSeparator(null).get());
-                }
-
-                Base64OutputStream base64EncoderStream = builder.get();  //NOPMD
+                OutputStream base64EncoderStream = XMLUtils.encodeStream(characterEventGeneratorOutputStream);  //NOPMD
                 base64EncoderStream.write(iv);
 
                 OutputStream outputStream = new CipherOutputStream(base64EncoderStream, symmetricCipher);   //NOPMD

src/main/java/org/apache/xml/security/utils/ElementProxy.java

@@ -313,9 +313,7 @@ public void addTextElement(String text, String localname) {
      */
     public void addBase64Text(byte[] bytes) {
         if (bytes != null) {
-            Text t = XMLUtils.ignoreLineBreaks()
-                ? createText(XMLUtils.encodeToString(bytes))
-                : createText("\n" + XMLUtils.encodeToString(bytes) + "\n");
+            Text t = createText(XMLUtils.encodeElementValue(bytes));
             appendSelf(t);
         }
     }

src/main/java/org/apache/xml/security/utils/XMLUtils.java

@@ -56,14 +56,38 @@
 /**
  * DOM and XML accessibility and comfort functions.
  *
+ * @implNote
+ * The following system properties affect XML formatting:
+ * <ul>
+ *     <li>{@systemProperty org.apache.xml.security.ignoreLineBreaks} - ignores all line breaks,
+ *     making a single-line document. Overrides all other formatting options. Default: false</li>
+ *     <li>{@systemProperty org.apache.xml.security.base64.ignoreLineBreaks} - ignores line breaks in base64Binary values.
+ *     Takes precedence over line length and separator options (see below). Default: false</li>
+ *     <li>{@systemProperty org.apache.xml.security.base64.lineSeparator} - Sets the line separator sequence in base64Binary values.
+ *     Possible values: crlf, lf. Default: crlf</li>
+ *     <li>{@systemProperty org.apache.xml.security.base64.lineLength} - Sets maximum line length in base64Binary values.
+ *     The value is rounded down to the nearest multiple of 4. Values less than 4 are ignored. Default: 76</li>
+ * </ul>
  */
 public final class XMLUtils {
 
+    private static final Logger LOG = System.getLogger(XMLUtils.class.getName());
+
+    private static final String IGNORE_LINE_BREAKS_PROP = "org.apache.xml.security.ignoreLineBreaks";
+
     private static boolean ignoreLineBreaks =
             AccessController.doPrivileged(
-                    (PrivilegedAction<Boolean>) () -> Boolean.getBoolean("org.apache.xml.security.ignoreLineBreaks"));
+                    (PrivilegedAction<Boolean>) () -> Boolean.getBoolean(IGNORE_LINE_BREAKS_PROP));
 
-    private static final Logger LOG = System.getLogger(XMLUtils.class.getName());
+    private static Base64FormattingOptions base64Formatting =
+            AccessController.doPrivileged(
+                    (PrivilegedAction<Base64FormattingOptions>) () -> new Base64FormattingOptions());
+
+    private static Base64.Encoder base64Encoder = (ignoreLineBreaks || base64Formatting.isIgnoreLineBreaks()) ?
+            Base64.getEncoder() :
+            Base64.getMimeEncoder(base64Formatting.getLineLength(), base64Formatting.getLineSeparator().getBytes());
+
+    private static Base64.Decoder base64Decoder = Base64.getMimeDecoder();
 
     private static XMLParser xmlParserImpl =
             AccessController.doPrivileged(
@@ -515,18 +539,48 @@ public static void addReturnBeforeChild(Element e, Node child) {
     }
 
     public static String encodeToString(byte[] bytes) {
-        if (ignoreLineBreaks) {
-            return Base64.getEncoder().encodeToString(bytes);
+        return base64Encoder.encodeToString(bytes);
+    }
+
+    /**
+     * Encodes bytes using Base64, with or without line breaks, depending on configuration (see {@link XMLUtils}).
+     * @param bytes Bytes to encode
+     * @return      Base64 string
+     */
+    public static String encodeElementValue(byte[] bytes) {
+        String encoded = encodeToString(bytes);
+        if (!ignoreLineBreaks && !base64Formatting.isIgnoreLineBreaks()
+                && encoded.length() > base64Formatting.getLineLength()) {
+            encoded = "\n" + encoded + "\n";
         }
-        return Base64.getMimeEncoder().encodeToString(bytes);
+        return encoded;
+    }
+
+    /**
+     * Wraps output stream for Base64 encoding.
+     * Output data may contain line breaks or not, depending on configuration (see {@link XMLUtils})
+     * @param stream    The underlying output stream to write Base64-encoded data
+     * @return          Stream which writes binary data using Base64 encoder
+     */
+    public static OutputStream encodeStream(OutputStream stream) {
+        return base64Encoder.wrap(stream);
     }
 
     public static byte[] decode(String encodedString) {
-        return Base64.getMimeDecoder().decode(encodedString);
+        return base64Decoder.decode(encodedString);
     }
 
     public static byte[] decode(byte[] encodedBytes) {
-        return Base64.getMimeDecoder().decode(encodedBytes);
+        return base64Decoder.decode(encodedBytes);
+    }
+
+    /**
+     * Wraps input stream for Base64 decoding.
+     * @param stream    Input stream with Base64-encoded data
+     * @return          Input stream with decoded binary data
+     */
+    public static InputStream decodeStream(InputStream stream) {
+        return base64Decoder.wrap(stream);
     }
 
     public static boolean isIgnoreLineBreaks() {
@@ -1068,4 +1122,90 @@ public static byte[] getBytes(BigInteger big, int bitlen) {
 
         return resizedBytes;
     }
+
+    /**
+     * Aggregates formatting options for base64Binary values.
+     */
+    static class Base64FormattingOptions {
+        private static final String BASE64_IGNORE_LINE_BREAKS_PROP = "org.apache.xml.security.base64.ignoreLineBreaks";
+        private static final String BASE64_LINE_SEPARATOR_PROP = "org.apache.xml.security.base64.lineSeparator";
+        private static final String BASE64_LINE_LENGTH_PROP = "org.apache.xml.security.base64.lineLength";
+
+        private boolean ignoreLineBreaks = false;
+        private Base64LineSeparator lineSeparator = Base64LineSeparator.CRLF;
+        private int lineLength = 76;
+
+        /**
+         * Creates new formatting options by reading system properties.
+         */
+        Base64FormattingOptions() {
+            String ignoreLineBreaksProp = System.getProperty(BASE64_IGNORE_LINE_BREAKS_PROP);
+            ignoreLineBreaks = Boolean.parseBoolean(ignoreLineBreaksProp);
+            if (XMLUtils.ignoreLineBreaks && ignoreLineBreaksProp != null && !ignoreLineBreaks) {
+                LOG.log(Level.WARNING, "{0} property takes precedence over {1}, line breaks will be ignored",
+                        IGNORE_LINE_BREAKS_PROP, BASE64_IGNORE_LINE_BREAKS_PROP);
+            }
+
+            String lineSeparatorProp = System.getProperty(BASE64_LINE_SEPARATOR_PROP);
+            if (lineSeparatorProp != null) {
+                try {
+                    lineSeparator = Base64LineSeparator.valueOf(lineSeparatorProp.toUpperCase());
+                    if (XMLUtils.ignoreLineBreaks || ignoreLineBreaks) {
+                        LOG.log(Level.WARNING, "Property {0} has no effect since line breaks are ignored",
+                                BASE64_LINE_SEPARATOR_PROP);
+                    }
+                } catch (IllegalArgumentException e) {
+                    LOG.log(Level.WARNING, "Illegal value of {0} property is ignored: {1}",
+                            BASE64_LINE_SEPARATOR_PROP, lineSeparatorProp);
+                }
+            }
+
+            String lineLengthProp = System.getProperty(BASE64_LINE_LENGTH_PROP);
+            if (lineLengthProp != null) {
+                try {
+                    int lineLength = Integer.parseInt(lineLengthProp);
+                    if (lineLength >= 4) {
+                        this.lineLength = lineLength;
+                        if (XMLUtils.ignoreLineBreaks || ignoreLineBreaks) {
+                            LOG.log(Level.WARNING, "Property {0} has no effect since line breaks are ignored",
+                                    BASE64_LINE_LENGTH_PROP);
+                        }
+                    } else {
+                        LOG.log(Level.WARNING, "Illegal value of {0} property is ignored: {1}",
+                                BASE64_LINE_LENGTH_PROP, lineLengthProp);
+                    }
+                } catch (NumberFormatException e) {
+                    LOG.log(Level.WARNING, "Illegal value of {0} property is ignored: {1}",
+                            BASE64_LINE_LENGTH_PROP, lineLengthProp);
+                }
+            }
+        }
+
+        public boolean isIgnoreLineBreaks() {
+            return ignoreLineBreaks;
+        }
+
+        public Base64LineSeparator getLineSeparator() {
+            return lineSeparator;
+        }
+
+        public int getLineLength() {
+            return lineLength;
+        }
+    }
+
+    enum Base64LineSeparator {
+        CRLF(new byte[]{'\r', '\n'}),
+        LF(new byte[]{'\n'});
+
+        private byte[] bytes;
+
+        Base64LineSeparator(byte[] bytes) {
+            this.bytes = bytes;
+        }
+
+        byte[] getBytes() {
+            return bytes;
+        }
+    }
 }

src/test/java/org/apache/xml/security/formatting/CustomBase64FormattingChecker.java

@@ -0,0 +1,74 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.xml.security.formatting;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+/**
+ * Checks that XML document is 'pretty-printed', including Base64 values.
+ */
+public class CustomBase64FormattingChecker implements FormattingChecker {
+    private int lineLength;
+    private String lineSeparatorRegex;
+
+    /**
+     * Creates new checker.
+     * @param lineLength            Expected base64 maximum line length
+     * @param lineSeparatorRegex    Regex matching line separator used in Base64 values
+     */
+    public CustomBase64FormattingChecker(int lineLength, String lineSeparatorRegex) {
+        this.lineLength = lineLength;
+        this.lineSeparatorRegex = lineSeparatorRegex;
+    }
+
+    @Override
+    public void checkDocument(String document) {
+        assertThat(document, containsString("\n"));
+    }
+
+    @Override
+    public void checkBase64Value(String value) {
+        String[] lines = value.split(lineSeparatorRegex);
+        if (lines.length == 0) return;
+
+        for (int i = 0; i < lines.length - 1; ++i) {
+            assertThat(lines[i], matchesPattern(BASE64_PATTERN));
+            assertEquals(lineLength, lines[i].length());
+        }
+
+        assertThat(lines[lines.length - 1], matchesPattern(BASE64_PATTERN));
+        assertThat(lines[lines.length - 1].length(), lessThanOrEqualTo(lineLength));
+    }
+
+    @Override
+    public void checkBase64ValueWithSpacing(String value) {
+        /* spacing is added only if the value has multiple lines */
+        if (value.length() <= lineLength) {
+            assertThat(value, matchesRegex(BASE64_PATTERN));
+            return;
+        }
+
+        assertThat(value.length(), greaterThanOrEqualTo(2));
+        assertThat(value, startsWith("\n"));
+        assertThat(value, endsWith("\n"));
+        checkBase64Value(value.substring(1, value.length() - 1));
+    }
+}