DigestInput.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.io.IOException;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.jar.Attributes.Name;
import java.util.stream.Collectors;

import sun.security.util.ManifestDigester;

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

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

/**
 * @test
 * @bug 8217375
 * @modules java.base/sun.security.util
 * @compile ../../tools/jarsigner/Utils.java
 * @run testng DigestInput
 * @summary Checks that the manifest main attributes and entry digests are the
 * same as before resolution of bug 8217375 which means they treat some white
 * space different for oldStyle or digestWorkaround except for the blank line
 * at the end of the manifest file for digestWorkaround.
 */
public class DigestInput {

    /**
     * Filters some test cases for calibrating expected digests with previous
     * implementation. TODO: Delete this after calibrating with old sources.
     */
    static final boolean FIXED_8217375 = true; // FIXME

    /**
     * {@link ManifestDigester.Entry#digestWorkaround} should not feed the
     * trailing blank line into the digester. Before resolution of 8217375 it
     * fed the trailing blank line into the digest if the second line break
     * was at the end of the file due to <pre>
     * if (allBlank || (i == len-1)) {
     *     if (i == len-1)
     *         pos.endOfSection = i;
     *     else
     *         pos.endOfSection = last;
     * </pre> in {@link ManifestDigester#findSection}. In that case at the end
     * of the manifest file, {@link ManifestDigester.Entry#digestWorkaround}
     * would have produced the same digest as
     * {@link ManifestDigester.Entry#digest} which was wrong and without effect
     * at best.
     * <p>
     * Once this fix is accepted, this flag can be removed along with
     * {@link #assertDigestEqualsCatchWorkaroundBroken}.
     */
    static final boolean FIXED_8217375_EOF_ENDOFSECTION = FIXED_8217375;

    static final String SECTION_NAME = "some individual section name";

    @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 addLB = 0; addLB <= 4; addLB++) {
                for (int numSecs = 0; numSecs <= 4; numSecs++) {
                    for (boolean otherSec : new Boolean[] { false, true }) {
                        for (boolean oldStyle : new Boolean[] { false, true }) {
                            for (boolean workaround :
                                    new Boolean[] { false, true }) {
                                tests.add(new Object[] {
                                    lineBreak, addLB, numSecs, otherSec,
                                            oldStyle, workaround
                                });
                            }
                        }
                    }
                }
            }
        }
        return tests.toArray(new Object[tests.size()][]);
    }

    @Factory(dataProvider = "parameters")
    public static Object[] createTests(
            String lineBreak, int additionalLineBreaks,
            int numberOfSections, boolean hasOtherSection,
            boolean oldStyle, boolean digestWorkaround) {
        return new Object[] { new DigestInput(lineBreak,
                additionalLineBreaks, numberOfSections, hasOtherSection,
                oldStyle, digestWorkaround)
        };
    }

    final String lineBreak;
    final int additionalLineBreaks; // number of blank lines delimiting section
    final int numberOfSections;
    final boolean hasOtherSection;
    final boolean oldStyle;
    final boolean digestWorkaround;

    public DigestInput(
            String lineBreak, int additionalLineBreaks,
            int numberOfSections, boolean hasOtherSection,
            boolean oldStyle, boolean digestWorkaround) {
        this.lineBreak = lineBreak;
        this.additionalLineBreaks = additionalLineBreaks;
        this.numberOfSections = numberOfSections;
        this.hasOtherSection = hasOtherSection;
        this.oldStyle = oldStyle;
        this.digestWorkaround = digestWorkaround;
    }

    @BeforeMethod
    public void verbose() {
        System.out.println("-".repeat(72));
        System.out.println("lineBreak = " +
                Utils.escapeStringWithNumbers(lineBreak));
        System.out.println("additionalLineBreaks = " + additionalLineBreaks);
        System.out.println("numberOfSections = " + numberOfSections);
        System.out.println("hasOtherSection = " + hasOtherSection);
        System.out.println("oldStyle = " + oldStyle);
        System.out.println("digestWorkaround = " + digestWorkaround);
        System.out.println("-".repeat(72));
    }

    byte[] rawManifestBytes() {
        return (
            Name.MANIFEST_VERSION + ": 1.0" + lineBreak +
            "OldStyle0: no trailing space" + lineBreak +
            "OldStyle1: trailing space " + lineBreak +
            "OldStyle2: two trailing spaces  " + lineBreak +
                    lineBreak.repeat(additionalLineBreaks) +
            (
                "Name: " + SECTION_NAME + lineBreak +
                "OldStyle0: no trailing space" + lineBreak +
                "OldStyle1: trailing space " + lineBreak +
                "OldStyle2: two trailing spaces  " + lineBreak +
                lineBreak.repeat(additionalLineBreaks)
            ).repeat(numberOfSections) +
            (hasOtherSection ?
                "Name: unrelated trailing section" + lineBreak +
                "OldStyle0: no trailing space" + lineBreak +
                "OldStyle1: trailing space " + lineBreak +
                "OldStyle2: two trailing spaces  " + lineBreak +
                lineBreak.repeat(additionalLineBreaks)
            : "")
        ).getBytes(UTF_8);
    }

    byte[] expectedMainAttrsDigest(boolean digestWorkaround) {
        return (
            Name.MANIFEST_VERSION + ": 1.0" + lineBreak +
            "OldStyle0: no trailing space" + lineBreak +
            "OldStyle1: trailing space" +
                (!oldStyle || !lineBreak.startsWith("\r") || digestWorkaround ?
                    " " : "") + lineBreak +
            "OldStyle2: two trailing spaces " +
                (!oldStyle || !lineBreak.startsWith("\r") || digestWorkaround ?
                        " " : "") + lineBreak +
            (
                     (
                                 !digestWorkaround
                         || (
                                 additionalLineBreaks == 1
                              && numberOfSections == 0
                              && !hasOtherSection
                              && (
                                      digestWorkaround
                                   && !FIXED_8217375_EOF_ENDOFSECTION
                                 )
                         )
                ) && (
                            additionalLineBreaks > 0
                         || numberOfSections > 0
                         || hasOtherSection
                )
            ? lineBreak : "")
        ).getBytes(UTF_8);
    }

    byte[] expectedIndividualSectionDigest(boolean digestWorkaround) {
        if (numberOfSections == 0) return null;
        return (
            (
                "Name: " + SECTION_NAME + lineBreak +
                "OldStyle0: no trailing space" + lineBreak +
                "OldStyle1: trailing space" +
                    (!oldStyle || !lineBreak.startsWith("\r")
                            || digestWorkaround ? " " : "") + lineBreak +
                "OldStyle2: two trailing spaces " +
                    (!oldStyle || !lineBreak.startsWith("\r")
                            || digestWorkaround ? " " : "") + lineBreak +
                (
                    (
                           !digestWorkaround
                    ) && (
                           additionalLineBreaks > 0
                    )
                ? lineBreak : "")
            ).repeat(numberOfSections) +
            (
                   additionalLineBreaks == 1
                && !hasOtherSection
                && digestWorkaround
                && !FIXED_8217375_EOF_ENDOFSECTION
            ? lineBreak : "")
        ).getBytes(UTF_8);
    }

    class EchoMessageDigest extends MessageDigest {

        ByteArrayOutputStream buf;

        EchoMessageDigest() {
            super("echo");
        }

        @Override
        protected void engineReset() {
            buf = new ByteArrayOutputStream();
        }

        @Override
        protected void engineUpdate(byte input) {
            buf.write(input);
        }

        @Override
        protected void engineUpdate(byte[] i, int o, int l) {
            buf.write(i, o, l);
        }

        @Override protected byte[] engineDigest() {
            return buf.toByteArray();
        }

    }

    byte[] digestMainAttributes(byte[] mfBytes) throws Exception {
        Utils.echoManifest(mfBytes, "going to digest main attributes of");

        ManifestDigester md = new ManifestDigester(mfBytes);
        ManifestDigester.Entry entry =
                md.get(ManifestDigester.MF_MAIN_ATTRS, oldStyle);
        MessageDigest digester = new EchoMessageDigest();
        return digestWorkaround ?
                entry.digestWorkaround(digester) : entry.digest(digester);
    }

    byte[] digestIndividualSection(byte[] mfBytes) throws Exception {
        Utils.echoManifest(mfBytes,
                "going to digest section " + SECTION_NAME + " of");

        ManifestDigester md = new ManifestDigester(mfBytes);
        ManifestDigester.Entry entry = md.get(SECTION_NAME, oldStyle);
        if (entry == null) {
            return null;
        }
        MessageDigest digester = new EchoMessageDigest();
        return digestWorkaround ?
                entry.digestWorkaround(digester) : entry.digest(digester);
    }


    /**
     * Checks that the manifest main attributes digest is the same as before.
     */
    @Test
    public void testMainAttributesDigest() throws Exception {
        byte[] mfRaw = rawManifestBytes();
        byte[] digest = digestMainAttributes(mfRaw);
        byte[] expectedDigest = expectedMainAttrsDigest(digestWorkaround);

        // the individual section will be digested along with the main
        // attributes if not properly delimited with a blank line
        if (additionalLineBreaks == 0
                && (numberOfSections > 0 || hasOtherSection)) {
            assertNotEquals(digest, expectedDigest);
            return;
        }

        byte[] expectedDigestNoWorkaround = expectedMainAttrsDigest(false);

//        assertDigestEquals(digest, expectedDigest); // FIXME
        assertDigestEqualsCatchWorkaroundBroken(
                digest, expectedDigest, expectedDigestNoWorkaround);
    }

    /**
     * Checks that an individual section digest is the same as before.
     */
    @Test
    public void testIndividualSectionDigest() throws Exception {
        byte[] mfRaw = rawManifestBytes();
        byte[] digest = digestIndividualSection(mfRaw);

        // no digest will be produced for an individual section that is not
        // properly section delimited with a blank line.
        byte[] expectedDigest =
                additionalLineBreaks == 0 ? null :
                    expectedIndividualSectionDigest(digestWorkaround);

        byte[] expectedDigestNoWorkaround =
                additionalLineBreaks == 0 ? null :
                    expectedIndividualSectionDigest(false);

//      assertDigestEquals(digest, expectedDigest); // FIXME
        assertDigestEqualsCatchWorkaroundBroken(
                digest, expectedDigest, expectedDigestNoWorkaround);
    }

    static int firstDiffPos = Integer.MAX_VALUE;

    /**
     * @see FIXED_8217375_EOF_ENDOFSECTION
     */
    void assertDigestEqualsCatchWorkaroundBroken(
            byte[] actual, byte[] expected, byte[] expectedNoWorkaround)
                    throws IOException {
        try {
            assertDigestEquals(actual, expected);
        } catch (AssertionError e) {
            if (digestWorkaround && FIXED_8217375_EOF_ENDOFSECTION &&
                    Arrays.equals(expected, expectedNoWorkaround)) {
                // if digests with and without workaround are the same anyway
                // the workaround has failed and could not have worked with
                // the same digest as produced without workaround before
                // which would not match either because equal.
                return;
            }
            fail("failed also without digestWorkaound", e);
        }
    }

    void assertDigestEquals(byte[] actual, byte[] expected) throws IOException {
        if (actual == null && expected == null) return;
        Utils.echoManifest(actual, "actual digest");
        Utils.echoManifest(expected, "expected digest");
        for (int i = 0; i < actual.length && i < expected.length; i++) {
            if (actual[i] != expected[i]) {
                firstDiffPos = Math.min(firstDiffPos, i);
                verbose();
                fail("found first difference in current test"
                        + " at position " + i);
            }
        }
        if (actual.length != expected.length) {
            int diffPos = Math.min(actual.length, expected.length);
            firstDiffPos = Math.min(firstDiffPos, diffPos);
            verbose();
            fail("found first difference in current test"
                    + " at position " + diffPos + " after one digest end");
        }
        assertEquals(actual, expected);
    }

    @AfterTest
    public void reportFirstDiffPos() {
        System.err.println("found first difference in all tests"
                + " at position " + firstDiffPos);
    }

}