FindHeaderEndVsManifestDigesterFindFirstSection.java

/*
 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

import java.io.ByteArrayOutputStream;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.List;
import sun.security.util.ManifestDigester;

import org.testng.annotations.Test;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Factory;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;

import static java.nio.charset.StandardCharsets.UTF_8;
import static org.testng.Assert.*;

/**
 * @test
 * @bug 8217375
 * @modules java.base/sun.security.util
 * @run testng FindHeaderEndVsManifestDigesterFindFirstSection
 * @summary Checks that {@link JarSigner#findHeaderEnd} (moved to now
 * {@link #findHeaderEnd} in this test) can be replaced with
 * {@link ManifestDigester#findSection}
 * (first invocation will identify main attributes)
 * without making a difference.
 */
/*
 * Note to future maintainer:
 * While it might look at first glance like this test ensures backwards-
 * compatibility between JarSigner.findHeaderEnd and
 * ManifestDigester.findSection's first invocation that find the main
 * attributes section, at the time of that change, this test continues to
 * verify main attributes digestion now with ManifestDigester.findSection as
 * opposed to previous implementation in JarSigner.findHeaderEnd.
 * Before completely removing this test, make sure that main attributes
 * digestion is covered appropriately with tests. After JarSigner.findHeaderEnd
 * has been removed digests should still continue to match.
 *
 * See also
 * - jdk/test/jdk/sun/security/tools/jarsigner/PreserveRawManifestEntryAndDigest.java
 * for some end-to-end tests utilizing the jarsigner tool,
 * - jdk/test/jdk/sun/security/util/ManifestDigester/FindSection.java and
 * - jdk/test/jdk/sun/security/util/ManifestDigester/DigestInput.java
 * for much more detailed tests at api level
 *
 * Both test mentioned above, however, originally were created when removing
 * confusion of "Manifest-Main-Attributes" individual section with actual main
 * attributes whereas the test here is about changes related to raw manifest
 * reproduction and in the end test pretty much the same behavior.
 */
public class FindHeaderEndVsManifestDigesterFindFirstSection {

    static final boolean FIXED_8217375 = true; // FIXME

    /**
     * from former {@link JarSigner#findHeaderEnd}, subject to verification if
     * it can be replaced with {@link ManifestDigester#findSection}
     */
    @SuppressWarnings("fallthrough")
    private int findHeaderEnd(byte[] bs) {
        // Initial state true to deal with empty header
        boolean newline = true;     // just met a newline
        int len = bs.length;
        for (int i = 0; i < len; i++) {
            switch (bs[i]) {
                case '\r':
                    if (i < len - 1 && bs[i + 1] == '\n') i++;
                    // fallthrough
                case '\n':
                    if (newline) return i + 1;    //+1 to get length
                    newline = true;
                    break;
                default:
                    newline = false;
            }
        }
        // If header end is not found, it means the MANIFEST.MF has only
        // the main attributes section and it does not end with 2 newlines.
        // Returns the whole length so that it can be completely replaced.
        return len;
    }

    @DataProvider(name = "parameters")
    public static Object[][] parameters() {
        List<Object[]> tests = new ArrayList<>();
        for (String lineBreak : new String[] { "\n", "\r", "\r\n" }) {
            if ("\r".equals(lineBreak) && !FIXED_8217375) continue;
            for (int numLBs = 0; numLBs <= 3; numLBs++) {
                for (String addSection : new String[] { null, "Ignore" }) {
                    tests.add(new Object[] { lineBreak, numLBs, addSection });
                }
            }
        }
        return tests.toArray(new Object[tests.size()][]);
    }

    @Factory(dataProvider = "parameters")
    public static Object[] createTests(String lineBreak, int numLineBreaks,
            String individualSectionName) {
        return new Object[]{new FindHeaderEndVsManifestDigesterFindFirstSection(
                lineBreak, numLineBreaks, individualSectionName
        )};
    }

    final String lineBreak;
    final int numLineBreaks; // number of line breaks after main attributes
    final String individualSectionName; // null means only main attributes
    final byte[] rawBytes;

    FindHeaderEndVsManifestDigesterFindFirstSection(String lineBreak,
            int numLineBreaks, String individualSectionName) {
        this.lineBreak = lineBreak;
        this.numLineBreaks = numLineBreaks;
        this.individualSectionName = individualSectionName;

        rawBytes = (
            "oldStyle: trailing space " + lineBreak +
            "newStyle: no trailing space" + lineBreak.repeat(numLineBreaks) +
            // numLineBreaks < 2 will not properly delimit individual section
            // but it does not hurt to test that anyway
            (individualSectionName != null ?
                    "Name: " + individualSectionName + lineBreak +
                    "Ignore: nothing here" + lineBreak +
                    lineBreak
                : "")
        ).getBytes(UTF_8);
    }

    @BeforeMethod
    public void verbose() {
        System.out.println("lineBreak = " + stringToIntList(lineBreak));
        System.out.println("numLineBreaks = " + numLineBreaks);
        System.out.println("individualSectionName = " + individualSectionName);
    }

    @FunctionalInterface
    interface Callable {
        void call() throws Exception;
    }

    void catchNoLineBreakAfterMainAttributes(Callable test) throws Exception {
        // manifests cannot be parsed and digested if the main attributes do
        // not end in a blank line (double line break) or one line break
        // immediately before eof.
        boolean failureExpected = numLineBreaks == 0
                && individualSectionName == null;
        try {
            test.call();
            if (failureExpected) fail("expected an exception");
        } catch (NullPointerException | IllegalStateException e) {
            if (!failureExpected) fail("unexpected " + e.getMessage(), e);
        }
    }

    /**
     * Checks that the beginning of the manifest until position<ol>
     * <li>{@code Jarsigner.findHeaderEnd} in the previous version
     * and</li>
     * <li>{@code ManifestDigester.getMainAttsEntry().sections[0].
     * lengthWithBlankLine} in the new version</li>
     * </ol>produce the same offset (TODO: or the same error).
     * The beginning of the manifest until that offset (range
     * <pre>0 .. (offset - 1)</pre>) will be reproduced if the manifest has
     * not changed.
     * <p>
     * Getting {@code startOfNext} of {@link ManifestDigester#findSection}'s
     * first invokation returned {@link ManifestDigester.Position} which
     * identifies the end offset of the main attributes is difficulted by
     * {@link ManifestDigester#findSection} being private and therefore not
     * directly accessible.
     */
    @Test
    public void startOfNextLengthWithBlankLine() throws Exception {
        catchNoLineBreakAfterMainAttributes(() ->
            assertEquals(lengthWithBlankLine(), findHeaderEnd(rawBytes))
        );
    }

    /**
     * Due to its private visibility,
     * {@link ManifestDigester.Section#lengthWithBlankLine} is not directly
     * accessible. However, calling {@link ManifestDigester.Entry#digest}
     * reveals {@code lengthWithBlankLine} as third parameter in
     * <pre>md.update(sec.rawBytes, sec.offset, sec.lengthWithBlankLine);</pre>
     * on line ManifestDigester.java:212.
     * <p>
     * This value is the same as {@code startOfNext} of
     * {@link ManifestDigester#findSection}'s first invocation returned
     * {@link ManifestDigester.Position} identifying the end offset of the
     * main attributes because<ol>
     * <li>the end offset of the main attributes is assigned to
     * {@code startOfNext} in
     * <pre>pos.startOfNext = i+1;</pre> in ManifestDigester.java:98</li>
     * <li>which is then passed on as the third parameter to the constructor
     * of a new {@link ManifestDigester.Section#Section} by
     * <pre>new Section(0, pos.endOfSection + 1, pos.startOfNext, rawBytes)));</pre>
     * in in ManifestDigester.java:128</li>
     * <li>where it is assigned to
     * {@link ManifestDigester.Section#lengthWithBlankLine} by
     * <pre>this.lengthWithBlankLine = lengthWithBlankLine;</pre>
     * in ManifestDigester.java:241</li>
     * <li>from where it is picked up by {@link ManifestDigester.Entry#digest}
     * in
     * <pre>md.update(sec.rawBytes, sec.offset, sec.lengthWithBlankLine);</pre>
     * in ManifestDigester.java:212</li>
     * </ol>
     * all of which without any modification.
     */
    int lengthWithBlankLine() {
        int[] lengthWithBlankLine = new int[] { 0 };
        new ManifestDigester(rawBytes).get(ManifestDigester.MF_MAIN_ATTRS,
                false).digest(new MessageDigest("lengthWithBlankLine") {
            @Override protected void engineReset() {
                lengthWithBlankLine[0] = 0;
            }
            @Override protected void engineUpdate(byte b) {
                lengthWithBlankLine[0]++;
            }
            @Override protected void engineUpdate(byte[] b, int o, int l) {
                lengthWithBlankLine[0] += l;
            }
            @Override protected byte[] engineDigest() {
                return null;
            }
        });
        return lengthWithBlankLine[0];
    }

    /**
     * Checks that the replacement of {@link JarSigner#findHeaderEnd} is
     * actually used to reproduce manifest main attributes.
     * <p>
     * {@link #startOfNextLengthWithBlankLine} demonstrates that
     * {@link JarSigner#findHeaderEnd} has been replaced successfully with
     * {@link ManifestDigester#findSection} but does not also show that the
     * main attributes are reproduced with the same offset as before.
     * {@link #startOfNextLengthWithBlankLine} uses
     * {@link ManifestDigester.Entry#digest} to demonstrate an equal offset
     * calculated but {@link ManifestDigester.Entry#digest} is not necessarily
     * the same as reproducing, especially when considering
     * {@link ManifestDigester.Entry#oldStyle}.
     */
    @Test(enabled = FIXED_8217375)
    public void reproduceMainAttributes() throws Exception {
        catchNoLineBreakAfterMainAttributes(() -> {
            ByteArrayOutputStream buf = new ByteArrayOutputStream();
            ManifestDigester md = new ManifestDigester(rawBytes);
            // without 8217375 fixed the following line will not even compile
            // so just remove it and skip the test for regression
            md.getMainAttsEntry().reproduceRaw(buf); // FIXME

            assertEquals(buf.size(), findHeaderEnd(rawBytes));
        });
    }

    static List<Integer> stringToIntList(String string) {
        byte[] bytes = string.getBytes(UTF_8);
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < bytes.length; i++) {
            list.add((int) bytes[i]);
        }
        return list;
    }

}