DigestDontIgnoreCase.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.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Map;
import java.util.jar.JarFile;
import java.util.jar.JarOutputStream;
import java.util.jar.JarEntry;
import jdk.test.lib.SecurityTools;
import org.testng.annotations.Test;
import org.testng.annotations.BeforeClass;

import static java.nio.charset.StandardCharsets.UTF_8;

/**
 * @test
 * @bug 8217375
 * @library /test/lib
 * @run testng DigestDontIgnoreCase
 * @summary Check that existing manifest digest entries are taken for valid
 * only if they match the actual digest value also taking upper and lower
 * case of the base64 encoded form of the digests into account.
 */
/*
 * <pre>mfDigest.equalsIgnoreCase(base64Digests[i])</pre>
 * previously in JarSigner.java on on line 985
 * @see jdk.security.jarsigner.JarSigner#updateDigests
 */
public class DigestDontIgnoreCase {

    static final String KEYSTORE_FILENAME = "test.jks";

    static final String DUMMY_FILE1 = "dummy1.txt";
    static final byte[] DUMMY_CONTENTS1 = DUMMY_FILE1.getBytes(UTF_8);
    static final String DUMMY_FILE2 = "dummy2.txt";
    static final byte[] DUMMY_CONTENTS2 = DUMMY_FILE2.getBytes(UTF_8);

    byte[] goodSignedManifest;

    @BeforeClass
    public void prepareCertificate() throws Exception {
        SecurityTools.keytool("-genkeypair -keyalg DSA -keystore "
                + KEYSTORE_FILENAME + " -storepass changeit -keypass changeit"
                + " -alias a -dname CN=X").shouldHaveExitValue(0);
    }

    void prepareJarFile(String filename, Map<String, byte[]> contents)
            throws IOException {
        try (OutputStream out = Files.newOutputStream(Path.of(filename));
                JarOutputStream jos = new JarOutputStream(out)) {
            for (Map.Entry<String, byte[]> entry : contents.entrySet()) {
                JarEntry je = new JarEntry(entry.getKey());
                jos.putNextEntry(je);
                jos.write(entry.getValue());
                jos.closeEntry();
            }
        }
    }

    @BeforeClass(dependsOnMethods = "prepareCertificate")
    public void prepareGoodSignedManifest() throws Exception {
        String filename = "prepare.jar";
        prepareJarFile(filename, Map.of(DUMMY_FILE1, DUMMY_CONTENTS1));
        SecurityTools.jarsigner("-keystore " + KEYSTORE_FILENAME +
                " -storepass changeit -verbose -debug " + filename + " a")
                .shouldHaveExitValue(0);
        goodSignedManifest = Utils.readJarManifestBytes(filename);
        Utils.echoManifest(goodSignedManifest,
                "reference manifest with one file signed");
    }

    void testWithManifest(String filename, byte[] manifestBytes)
            throws Exception {
        Utils.echoManifest(manifestBytes,
                "going to test " + filename + " with manifest");
        prepareJarFile(filename, Map.of(
                JarFile.MANIFEST_NAME, manifestBytes,
                DUMMY_FILE1, DUMMY_CONTENTS1, // with digest already in manifest
                DUMMY_FILE2, DUMMY_CONTENTS2)); // causes manifest update
        Utils.echoManifest(Utils.readJarManifestBytes(filename),
                filename + " created with manifest");
        SecurityTools.jarsigner("-keystore " + KEYSTORE_FILENAME +
                " -storepass changeit -debug -verbose " + filename + " a")
                .shouldHaveExitValue(0);
        Utils.echoManifest(Utils.readJarManifestBytes(filename),
                filename + " signed resulting in manifest");
        SecurityTools.jarsigner("-verify -strict -keystore " +
                KEYSTORE_FILENAME + " -storepass changeit -debug -verbose " +
                filename + " a").shouldHaveExitValue(0);
    }

    @Test
    public void verifyDigestGoodCase() throws Exception {
        testWithManifest("good.jar", goodSignedManifest);
    }

    @Test
    public void testDigestHeaderNameCase() throws Exception {
        byte[] mfBadHeader = new String(goodSignedManifest, UTF_8).
                replace("SHA-256-Digest", "sha-256-dIGEST").getBytes(UTF_8);
        testWithManifest("switch-header-name-case.jar", mfBadHeader);
    }

    @Test
    public void testDigestWrongCase() throws Exception {
        byte[] mfBadDigest = switchCase(goodSignedManifest, "Digest");
        testWithManifest("switch-digest-case.jar", mfBadDigest);
    }

    byte[] switchCase(byte[] manifest, String attrName) {
        byte[] wrongCase = Arrays.copyOf(manifest, manifest.length);
        byte[] name = (attrName + ":").getBytes(UTF_8);
        int matched = 0; // number of bytes before position i matching attrName
        for (int i = 0; i < wrongCase.length; i++) {
            if (wrongCase[i] == '\r' &&
                    (i == wrongCase.length - 1 || wrongCase[i + 1] == '\n')) {
                continue;
            } else if ((wrongCase[i] == '\r' || wrongCase[i] == '\n')
                    && (i == wrongCase.length - 1 || wrongCase[i + 1] != ' ')) {
                matched = 0;
            } else if (matched == name.length) {
                wrongCase[i] = switchCase(wrongCase[i]);
            } else if (name[matched] == wrongCase[i]) {
                matched++;
            } else {
                matched = 0;
            }
        }
        return wrongCase;
    }

    byte switchCase(byte c) {
        if (c >= 'A' && c <= 'Z') {
            return (byte) ('a' + (c - 'A'));
        } else if (c >= 'a' && c <= 'z') {
            return (byte) ('A' + (c - 'a'));
        } else {
            return c;
        }
    }

}