/*

 * Copyright (c) 2016, 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.

 */

/* @test

 * @bug 8051408

 * @modules java.base/sun.security.provider

 * @summary check the AbstractDrbg API etc

 */

import java.security.*;

import sun.security.provider.AbstractDrbg;

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

/**

 * This test makes sure the AbstractDrbg API works as specified. It also

 * checks the SecureRandom API.

 */

public class AbstractDrbgSpec {

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

        // getInstance from a provider.

        Provider p = new All("A", 0, "");

        byte[] bytes = new byte[100];

        // A non-DRBG

        iae(() -> SecureRandom.getInstance("S1", null, p));

        nsae(() -> SecureRandom.getInstance("S1",

                new SecureRandomParameters() {}, p));

        SecureRandom s1 = SecureRandom.getInstance("S1", p);

        if (s1.getParameters() != null) {

            throw new Exception();

        }

        iae(() -> s1.nextBytes(bytes, null));

        uoe(() -> s1.nextBytes(bytes, new SecureRandomParameters() {}));

        uoe(() -> s1.reseed());

        iae(() -> s1.reseed(null));

        uoe(() -> s1.reseed(new SecureRandomParameters() {}));

        // A weak DRBG

        iae(() -> SecureRandom.getInstance("S2", null, p));

        nsae(() -> SecureRandom.getInstance("S2",

                new SecureRandomParameters() {}, p));

        nsae(() -> SecureRandom.getInstance("S2",

                DrbgParameters.instantiation(256, NONE, null), p));

        nsae(() -> SecureRandom.getInstance("S2",

                DrbgParameters.instantiation(-1, PR_AND_RESEED, null), p));

        nsae(() -> SecureRandom.getInstance("S2",

                DrbgParameters.instantiation(-1, RESEED_ONLY, null), p));

        SecureRandom s2 = SecureRandom.getInstance("S2",

                DrbgParameters.instantiation(-1, NONE, null), p);

        equals(s2, "S2,SQUEEZE,128,none");

        equals(s2.getParameters(), "128,none,null");

        npe(() -> s2.nextBytes(null));

        iae(() -> s2.nextBytes(bytes, null));

        iae(() -> s2.nextBytes(bytes, new SecureRandomParameters() {}));

        uoe(() -> s2.reseed());

        iae(() -> s2.reseed(null));

        iae(() -> s2.nextBytes(bytes,

                DrbgParameters.nextBytes(-1, false, new byte[101])));

        s2.nextBytes(new byte[101],

                DrbgParameters.nextBytes(-1, false, new byte[100]));

        s2.nextBytes(bytes,

                DrbgParameters.nextBytes(-1, false, new byte[100]));

        // A strong DRBG

        iae(() -> SecureRandom.getInstance("S3", null, p));

        nsae(() -> SecureRandom.getInstance("S3",

                new SecureRandomParameters() {}, p));

        SecureRandom.getInstance("S3",

                DrbgParameters.instantiation(192, PR_AND_RESEED, null), p);

        SecureRandom s3 = SecureRandom.getInstance("S3", p);

        equals(s3, "S3,SQUEEZE,128,reseed_only");

        equals(s3.getParameters(), "128,reseed_only,null");

        iae(() -> s3.nextBytes(bytes,

                DrbgParameters.nextBytes(192, false, null)));

        iae(() -> s3.nextBytes(bytes,

                DrbgParameters.nextBytes(112, true, null)));

        iae(() -> s3.reseed(new SecureRandomParameters() {}));

        SecureRandom s32 = SecureRandom.getInstance(

                "S3", DrbgParameters.instantiation(192, PR_AND_RESEED, null), p);

        equals(s32, "S3,SQUEEZE,192,pr_and_reseed");

        equals(s32.getParameters(), "192,pr_and_reseed,null");

        s32.nextBytes(bytes, DrbgParameters.nextBytes(192, false, null));

        s32.nextBytes(bytes, DrbgParameters.nextBytes(112, true, null));

        s32.reseed();

        s32.reseed(DrbgParameters.reseed(true, new byte[100]));

        // getInstance from competitive providers.

        Provider l = new Legacy("L", 0, "");

        Provider w = new Weak("W", 0, "");

        Provider s = new Strong("S", 0, "");

        Security.addProvider(l);

        Security.addProvider(w);

        Security.addProvider(s);

        SecureRandom s4;

        try {

            s4 = SecureRandom.getInstance("S");

            if (s4.getProvider() != l) {

                throw new Exception();

            }

            nsae(() -> SecureRandom.getInstance(

                    "S", DrbgParameters.instantiation(256, NONE, null)));

            s4 = SecureRandom.getInstance(

                    "S", DrbgParameters.instantiation(192, NONE, null));

            if (s4.getProvider() != s) {

                throw new Exception();

            }

            s4 = SecureRandom.getInstance(

                    "S", DrbgParameters.instantiation(128, PR_AND_RESEED, null));

            if (s4.getProvider() != s) {

                throw new Exception();

            }

            s4 = SecureRandom.getInstance(

                    "S", DrbgParameters.instantiation(128, RESEED_ONLY, null));

            if (s4.getProvider() != s) {

                throw new Exception();

            }

            s4 = SecureRandom.getInstance(

                    "S", DrbgParameters.instantiation(128, NONE, null));

            if (s4.getProvider() != w) {

                throw new Exception();

            }

        } finally {

            Security.removeProvider("L");

            Security.removeProvider("W");

            Security.removeProvider("S");

        }

    }

    public static class All extends Provider {

        protected All(String name, double version, String info) {

            super(name, version, info);

            put("SecureRandom.S1", S1.class.getName());

            put("SecureRandom.S2", S2.class.getName());

            put("SecureRandom.S3", S3.class.getName());

        }

    }

    // Providing S with no params support

    public static class Legacy extends Provider {

        protected Legacy(String name, double version, String info) {

            super(name, version, info);

            put("SecureRandom.S", S1.class.getName());

        }

    }

    public static class Weak extends Provider {

        protected Weak(String name, double version, String info) {

            super(name, version, info);

            put("SecureRandom.S", S2.class.getName());

        }

    }

    public static class Strong extends Provider {

        protected Strong(String name, double version, String info) {

            super(name, version, info);

            put("SecureRandom.S", S3.class.getName());

        }

    }

    // This is not a DRBG.

    public static class S1 extends SecureRandomSpi {

        @Override

        protected void engineSetSeed(byte[] seed) {

        }

        @Override

        protected void engineNextBytes(byte[] bytes) {

        }

        @Override

        protected byte[] engineGenerateSeed(int numBytes) {

            return new byte[numBytes];

        }

    }

    // This is a strong DRBG.

    public static class S3 extends AbstractDrbg {

        public S3(SecureRandomParameters params) {

            supportPredictionResistance = true;

            supportReseeding = true;

            highestSupportedSecurityStrength = 192;

            mechName = "S3";

            algorithm = "SQUEEZE";

            configure(params);

        }

        protected void chooseAlgorithmAndStrength() {

            if (requestedInstantiationSecurityStrength < 0) {

                securityStrength = DEFAULT_STRENGTH;

            } else {

                securityStrength = requestedInstantiationSecurityStrength;

            }

            minLength = securityStrength / 8;

            maxAdditionalInputLength = maxPersonalizationStringLength = 100;

        }

        @Override

        protected void initEngine() {

        }

        @Override

        protected void instantiateAlgorithm(byte[] ei) {

        }

        @Override

        protected void generateAlgorithm(byte[] result, byte[] additionalInput) {

        }

        @Override

        protected void reseedAlgorithm(byte[] ei, byte[] additionalInput) {

        }

    }

    // This is a weak DRBG. maximum strength is 128 and does

    // not support prediction resistance or reseed.

    public static class S2 extends S3 {

        public S2(SecureRandomParameters params) {

            super(null);

            mechName = "S2";

            highestSupportedSecurityStrength = 128;

            supportPredictionResistance = false;

            supportReseeding = false;

            configure(params);

        }

    }

    static void nsae(RunnableWithException r) throws Exception {

        checkException(r, NoSuchAlgorithmException.class);

    }

    static void iae(RunnableWithException r) throws Exception {

        checkException(r, IllegalArgumentException.class);

    }

    static void uoe(RunnableWithException r) throws Exception {

        checkException(r, UnsupportedOperationException.class);

    }

    static void npe(RunnableWithException r) throws Exception {

        checkException(r, NullPointerException.class);

    }

    interface RunnableWithException {

        void run() throws Exception;

    }

    static void checkException(RunnableWithException r, Class ex)

            throws Exception {

        try {

            r.run();

        } catch (Exception e) {

            if (ex.isAssignableFrom(e.getClass())) {

                return;

            }

            throw e;

        }

        throw new Exception("No exception thrown");

    }

    static void equals(Object o, String s) throws Exception {

        if (!o.toString().equals(s)) {

            throw new Exception(o.toString() + " is not " + s);

        }

    }

}