test/jdk/sun/security/provider/SecureRandom/DrbgCavp.java

/*
 * Copyright (c) 2016, 2018, 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 sun.security.provider.EntropySource;
import sun.security.provider.MoreDrbgParameters;

import javax.crypto.Cipher;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.lang.*;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.DrbgParameters;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Queue;
import java.util.stream.Stream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;

import static java.security.DrbgParameters.Capability.*;

/**
 * The Known-output DRBG test. The test vector can be downloaded from
 * https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/drbg/drbgtestvectors.zip.
 * The test is described on https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Random-Number-Generators.
 *
 * Manually run this test with
 *
 *   java DrbgCavp drbgtestvectors.zip
 *
 */
public class DrbgCavp {

    // the current nonce
    private static byte[] nonce;

    // A buffer to store test materials for the current call and
    // can be printed out of an error occurs.
    private static ByteArrayOutputStream bout = new ByteArrayOutputStream();

    // Save err for restoring
    private static PrintStream err = System.err;

    private static final int AES_LIMIT;

    static {
        try {
            AES_LIMIT = Cipher.getMaxAllowedKeyLength("AES");
        } catch (Exception e) {
            // should not happen
            throw new AssertionError("Cannot detect AES");
        }
    }

    public static void main(String[] args) throws Exception {

        if (args.length != 1) {
            System.out.println("Usage: java DrbgCavp drbgtestvectors.zip");
            return;
        }
        File tv = new File(args[0]);

        EntropySource es = new TestEntropySource();
        System.setErr(new PrintStream(bout));

        // The testsuite is a zip file containing more zip files for different
        // working modes. Each internal zip file contains test materials for
        // different mechanisms.

        try (ZipFile zf = new ZipFile(tv)) {
            String[] modes = {"no_reseed", "pr_false", "pr_true"};
            for (String mode : modes) {
                try (ZipInputStream zis = new ZipInputStream(zf.getInputStream(
                        zf.getEntry("drbgvectors_" + mode + ".zip")))) {
                    while (true) {
                        ZipEntry ze = zis.getNextEntry();
                        if (ze == null) {
                            break;
                        }
                        String fname = ze.getName();
                        if (fname.equals("Hash_DRBG.txt")
                                || fname.equals("HMAC_DRBG.txt")
                                || fname.equals("CTR_DRBG.txt")) {
                            String algorithm
                                    = fname.substring(0, fname.length() - 4);
                            test(mode, algorithm, es, zis);
                        }
                    }
                }
            }
        } finally {
            System.setErr(err);
        }
    }

    /**
     * A special entropy source you can set entropy input at will.
     */
    private static class TestEntropySource implements EntropySource {

        private static Queue<byte[]> data = new ArrayDeque<>();

        @Override
        public byte[] getEntropy(int minEntropy, int minLength,
                                 int maxLength, boolean pr) {
            byte[] result = data.poll();
            if (result == null
                    || result.length < minLength
                    || result.length > maxLength) {
                throw new RuntimeException("Invalid entropy: " +
                        "need [" + minLength + ", " + maxLength + "], " +
                        (result == null ? "none" : "has " + result.length));
            }
            return result;
        }

        private static void setEntropy(byte[] input) {
            data.offer(input);
        }

        private static void clearEntropy() {
            data.clear();
        }
    }

    /**
     * The test.
     *
     * // Algorithm line, might contain usedf flag
     * [AES-128 use df]
     * // Ignored, use mode argument
     * [PredictionResistance = True]
     * // Ignored, just read EntropyInput
     * [EntropyInputLen = 128]
     * // Ignored, just read Nonce
     * [NonceLen = 64]
     * // Ignored, just read PersonalizationString
     * [PersonalizationStringLen = 128]
     * // Ignored, just read AdditionalInput
     * [AdditionalInputLen = 128]
     * // Used to allocate buffer for nextBytes() call
     * [ReturnedBitsLen = 512]
     *
     * // A sign we can ignore old unused entropy input
     * COUNT = 0
     *
     * // Instantiate
     * EntropyInput = 92898f...
     * Nonce = c2a4d9...
     * PersonalizationString = ea65ee...  // Enough to call getInstance()
     *
     * // Reseed
     * EntropyInputReseed = bfd503...
     * AdditionalInputReseed = 009e0b... // Enough to call reseed()
     *
     * // Generation
     * AdditionalInput = 1a40fa....  // Enough to call nextBytes() for PR off
     * EntropyInputPR = 20728a...  // Enough to call nextBytes() for PR on
     * ReturnedBits = 5a3539...  // Compare this to last nextBytes() output
     *
     * @param mode one of "no_reseed", "pr_false", "pr_true"
     * @param mech one of "Hash_DRBG", "HMAC_DRBG", "CTR_DRBG"
     * @param es our own entropy source
     * @param is test material
     */
    private static void test(String mode, String mech, EntropySource es,
            InputStream is) throws Exception {

        SecureRandom hd = null;

        // Expected output length in bits as in [ReturnedBitsLen]
        int outLen = 0;

        // DRBG algorithm as in the algorithm line
        String algorithm = null;

        // When CTR_DRBG uses a derivation function as in the algorithm line
        boolean usedf = false;

        // Additional input as in "AdditionalInput"
        byte[] additional = null;

        // Random bits generated
        byte[] output = null;

        // Prediction resistance flag, determined by mode
        boolean isPr = false;

        StringBuilder sb = new StringBuilder();

        int lineno = 0;

        System.out.println(mode + "/" + mech);

        try (Stream<String> lines =
                     new BufferedReader(new InputStreamReader(is)).lines()) {
            for (String s: (Iterable<String>) lines::iterator) {
                lineno++;
                err.print(hd == null ? '-' : '*');
                Line l = new Line(s);
                if (l.key.contains("no df") || l.key.contains("use df") ||
                        l.key.startsWith("SHA-")) {
                    sb = new StringBuilder();
                    bout.reset();
                }
                sb.append(String.format(
                        "%9s %4s %5d %s\n", mode, mech, lineno, s));
                switch (l.key) {
                    case "3KeyTDEA no df":
                    case "AES-128 no df":
                    case "AES-192 no df":
                    case "AES-256 no df":
                    case "3KeyTDEA use df":
                    case "AES-128 use df":
                    case "AES-192 use df":
                    case "AES-256 use df":
                        algorithm = l.key.split(" ")[0];
                        usedf = l.key.contains("use df");
                        break;
                    case "ReturnedBitsLen":
                        outLen = l.vint();
                        output = new byte[outLen / 8];
                        break;
                    case "EntropyInput":
                        TestEntropySource.setEntropy(l.vdata());
                        break;
                    case "Nonce":
                        nonce = l.vdata();
                        break;
                    case "COUNT":
                        // Remove unused entropy (say, when AES-256 is skipped)
                        TestEntropySource.clearEntropy();
                        break;
                    case "PersonalizationString":
                        try {
                            isPr = mode.equals("pr_true");
                            byte[] ps = null;
                            if (l.vdata().length != 0) {
                                ps = l.vdata();
                            }

                            // MoreDrbgParameters must be used because we
                            // want to set entropy input and nonce. Since
                            // it can also set mechanism, algorithm and usedf,
                            // we don't need to touch securerandom.drbg.config.
                            hd = SecureRandom.getInstance("DRBG",
                                    new MoreDrbgParameters(es, mech, algorithm,
                                            nonce, usedf,
                                            DrbgParameters.instantiation(
                                                    -1,
                                                    isPr ? PR_AND_RESEED
                                                            : RESEED_ONLY,
                                                    ps)),
                                    "SUN");
                        } catch (NoSuchAlgorithmException iae) {
                            // We don't support SHA-1 and 3KeyTDEA. AES-192 or
                            // AES-256 might not be available. This is OK.
                            if (algorithm.equals("SHA-1") ||
                                    algorithm.equals("3KeyTDEA") ||
                                    ((algorithm.equals("AES-192")
                                    || algorithm.equals("AES-256"))
                                    && AES_LIMIT == 128)) {
                                hd = null;
                            } else {
                                throw iae;
                            }
                        }
                        break;
                    case "EntropyInputReseed":
                        TestEntropySource.setEntropy(l.vdata());
                        break;
                    case "AdditionalInputReseed":
                        if (l.vdata().length == 0) {
                            additional = null;
                        } else {
                            additional = l.vdata();
                        }
                        if (hd != null) {
                            if (additional == null) {
                                hd.reseed();
                            } else {
                                hd.reseed(DrbgParameters.reseed(
                                        isPr, additional));
                            }
                        }
                        break;
                    case "EntropyInputPR":
                        if (l.vdata().length != 0) {
                            TestEntropySource.setEntropy(l.vdata());
                        }
                        if (mode.equals("pr_true")) {
                            if (hd != null) {
                                if (additional == null) {
                                    hd.nextBytes(output);
                                } else {
                                    hd.nextBytes(output,
                                            DrbgParameters.nextBytes(
                                                    -1, isPr, additional));
                                }
                            }
                        }
                        break;
                    case "AdditionalInput":
                        if (l.vdata().length == 0) {
                            additional = null;
                        } else {
                            additional = l.vdata();
                        }
                        if (!mode.equals("pr_true")) {
                            if (hd != null) {
                                if (additional == null) {
                                    hd.nextBytes(output);
                                } else {
                                    hd.nextBytes(output,
                                            DrbgParameters.nextBytes(
                                                    -1, isPr, additional));
                                }
                            }
                        }
                        break;
                    case "ReturnedBits":
                        if (hd != null) {
                            if (!Arrays.equals(output, l.vdata())) {
                                throw new Exception("\nExpected: " +
                                        l.value + "\n  Actual: " + hex(output));
                            }
                        }
                        break;
                    default:
                        // Algorithm line for Hash_DRBG and HMAC_DRBG
                        if (l.key.startsWith("SHA-")) {
                            algorithm = l.key;
                        }
                }
            }
            err.println();
        } catch (Exception e) {
            err.println();
            err.println(sb.toString());
            err.println(bout.toString());
            throw e;
        }
    }

    /**
     * Parse a line from test material.
     *
     * Brackets are removed. Key and value separated.
     */
    static class Line {

        final String key;
        final String value;

        Line(String s) {
            s = s.trim();
            if (s.length() >= 2) {
                if (s.charAt(0) == '[') {
                    s = s.substring(1, s.length() - 1);
                }
            }
            if (s.indexOf('=') < 0) {
                key = s;
                value = null;
            } else {
                key = s.substring(0, s.indexOf('=')).trim();
                value = s.substring(s.indexOf('=') + 1).trim();
            }
        }

        int vint() {
            return Integer.parseInt(value);
        }

        byte[] vdata() {
            return xeh(value);
        }
    }

    // Bytes to HEX
    private static String hex(byte[] in) {
        StringBuilder sb = new StringBuilder();
        for (byte b: in) {
            sb.append(String.format("%02x", b&0xff));
        }
        return sb.toString();
    }

    // HEX to bytes
    private static byte[] xeh(String in) {
        in = in.replaceAll(" ", "");
        int len = in.length() / 2;
        byte[] out = new byte[len];
        for (int i = 0; i < len; i++) {
            out[i] = (byte) Integer.parseInt(
                    in.substring(i * 2, i * 2 + 2), 16);
        }
        return out;
    }
}