/*

 * 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.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * 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.

 */

package java.security;

import java.util.*;

import java.security.Provider.Service;

import sun.security.jca.*;

import sun.security.jca.GetInstance.Instance;

/**

 * This class provides a cryptographically strong random number

 * generator (RNG).

 *

 * <p>A cryptographically strong random number

 * minimally complies with the statistical random number generator tests

 * specified in <a href="http://csrc.nist.gov/cryptval/140-2.htm">

 * <i>FIPS 140-2, Security Requirements for Cryptographic Modules</i></a>,

 * section 4.9.1.

 * Additionally, SecureRandom must produce non-deterministic output.

 * Therefore any seed material passed to a SecureRandom object must be

 * unpredictable, and all SecureRandom output sequences must be

 * cryptographically strong, as described in

 * <a href="http://www.ietf.org/rfc/rfc1750.txt">

 * <i>RFC 1750: Randomness Recommendations for Security</i></a>.

 *

 * <p>A caller obtains a SecureRandom instance via the

 * no-argument constructor or one of the <code>getInstance</code> methods:

 *

 * <pre>

 *      SecureRandom random = new SecureRandom();

 * </pre>

 *

 * <p> Many SecureRandom implementations are in the form of a pseudo-random

 * number generator (PRNG), which means they use a deterministic algorithm

 * to produce a pseudo-random sequence from a true random seed.

 * Other implementations may produce true random numbers,

 * and yet others may use a combination of both techniques.

 *

 * <p> Typical callers of SecureRandom invoke the following methods

 * to retrieve random bytes:

 *

 * <pre>

 *      SecureRandom random = new SecureRandom();

 *      byte bytes[] = new byte[20];

 *      random.nextBytes(bytes);

 * </pre>

 *

 * <p> Callers may also invoke the <code>generateSeed</code> method

 * to generate a given number of seed bytes (to seed other random number

 * generators, for example):

 * <pre>

 *      byte seed[] = random.generateSeed(20);

 * </pre>

 *

 * Note: Depending on the implementation, the <code>generateSeed</code> and

 * <code>nextBytes</code> methods may block as entropy is being gathered,

 * operating systems.

 *

 * @see java.security.SecureRandomSpi

 * @see java.util.Random

 *

 * @author Benjamin Renaud

 * @author Josh Bloch

 */

public class SecureRandom extends java.util.Random {

    /**

     * The provider.

     *

     * @serial

     * @since 1.2

     */

    private Provider provider = null;

    /**

     * The provider implementation.

     *

     * @serial

     * @since 1.2

     */

    private SecureRandomSpi secureRandomSpi = null;

    /*

     * The algorithm name of null if unknown.

     *

     * @serial

     * @since 1.5

     */

    private String algorithm;

    // Seed Generator

    private static volatile SecureRandom seedGenerator = null;

    /**

     * Constructs a secure random number generator (RNG) implementing the

     * default random number algorithm.

     *

     * <p> This constructor traverses the list of registered security Providers,

     * starting with the most preferred Provider.

     * A new SecureRandom object encapsulating the

     * SecureRandomSpi implementation from the first

     * Provider that supports a SecureRandom (RNG) algorithm is returned.

     * If none of the Providers support a RNG algorithm,

     * then an implementation-specific default is returned.

     *

     * <p> Note that the list of registered providers may be retrieved via

     * the {@link Security#getProviders() Security.getProviders()} method.

     *

     * <p> See the SecureRandom section in the <a href=

     * "{@docRoot}/../technotes/guides/security/StandardNames.html#SecureRandom">

     * Java Cryptography Architecture Standard Algorithm Name Documentation</a>

     * for information about standard RNG algorithm names.

     *

     * <p> The returned SecureRandom object has not been seeded.  To seed the

     * returned object, call the <code>setSeed</code> method.

     * If <code>setSeed</code> is not called, the first call to

     * <code>nextBytes</code> will force the SecureRandom object to seed itself.

     * This self-seeding will not occur if <code>setSeed</code> was

     * previously called.

     */

    public SecureRandom() {

        /*

         * This call to our superclass constructor will result in a call

         * to our own <code>setSeed</code> method, which will return

         * immediately when it is passed zero.

         */

        super(0);

        getDefaultPRNG(false, null);

    }

    /**

     * Constructs a secure random number generator (RNG) implementing the

     * default random number algorithm.

     * The SecureRandom instance is seeded with the specified seed bytes.

     *

     * <p> This constructor traverses the list of registered security Providers,

     * starting with the most preferred Provider.

     * A new SecureRandom object encapsulating the

     * SecureRandomSpi implementation from the first

     * Provider that supports a SecureRandom (RNG) algorithm is returned.

     * If none of the Providers support a RNG algorithm,

     * then an implementation-specific default is returned.

     *

     * <p> Note that the list of registered providers may be retrieved via

     * the {@link Security#getProviders() Security.getProviders()} method.

     *

     * <p> See the SecureRandom section in the <a href=

     * "{@docRoot}/../technotes/guides/security/StandardNames.html#SecureRandom">

     * Java Cryptography Architecture Standard Algorithm Name Documentation</a>

     * for information about standard RNG algorithm names.

     *

     * @param seed the seed.

     */

    public SecureRandom(byte seed[]) {

        super(0);

        getDefaultPRNG(true, seed);

    }

    private void getDefaultPRNG(boolean setSeed, byte[] seed) {

        String prng = getPrngAlgorithm();

        if (prng == null) {

            // bummer, get the SUN implementation

            prng = "SHA1PRNG";

            this.secureRandomSpi = new sun.security.provider.SecureRandom();

            this.provider = Providers.getSunProvider();

            if (setSeed) {

                this.secureRandomSpi.engineSetSeed(seed);

            }

        } else {

            try {

                SecureRandom random = SecureRandom.getInstance(prng);

                this.secureRandomSpi = random.getSecureRandomSpi();

                this.provider = random.getProvider();

                if (setSeed) {

                    this.secureRandomSpi.engineSetSeed(seed);

                }

            } catch (NoSuchAlgorithmException nsae) {

                // never happens, because we made sure the algorithm exists

                throw new RuntimeException(nsae);

            }

        }

        // JDK 1.1 based implementations subclass SecureRandom instead of

        // SecureRandomSpi. They will also go through this code path because

        // they must call a SecureRandom constructor as it is their superclass.

        // If we are dealing with such an implementation, do not set the

        // algorithm value as it would be inaccurate.

        if (getClass() == SecureRandom.class) {

            this.algorithm = prng;

        }

    }

    /**

     * Creates a SecureRandom object.

     *

     * @param secureRandomSpi the SecureRandom implementation.

     * @param provider the provider.

     */

    protected SecureRandom(SecureRandomSpi secureRandomSpi,

                           Provider provider) {

        this(secureRandomSpi, provider, null);

    }

    private SecureRandom(SecureRandomSpi secureRandomSpi, Provider provider,

            String algorithm) {

        super(0);

        this.secureRandomSpi = secureRandomSpi;

        this.provider = provider;

        this.algorithm = algorithm;

    }

    /**

     * Returns a SecureRandom object that implements the specified

     * Random Number Generator (RNG) algorithm.

     *

     * <p> This method traverses the list of registered security Providers,

     * starting with the most preferred Provider.

     * A new SecureRandom object encapsulating the

     * SecureRandomSpi implementation from the first

     * Provider that supports the specified algorithm is returned.

     *

     * <p> Note that the list of registered providers may be retrieved via

     * the {@link Security#getProviders() Security.getProviders()} method.

     *

     * <p> The returned SecureRandom object has not been seeded.  To seed the

     * returned object, call the <code>setSeed</code> method.

     * If <code>setSeed</code> is not called, the first call to

     * <code>nextBytes</code> will force the SecureRandom object to seed itself.

     * This self-seeding will not occur if <code>setSeed</code> was

     * previously called.

     *

     * @param algorithm the name of the RNG algorithm.

     * See the SecureRandom section in the <a href=

     * "{@docRoot}/../technotes/guides/security/StandardNames.html#SecureRandom">

     * Java Cryptography Architecture Standard Algorithm Name Documentation</a>

     * for information about standard RNG algorithm names.

     *

     * @return the new SecureRandom object.

     *

     * @exception NoSuchAlgorithmException if no Provider supports a

     *          SecureRandomSpi implementation for the

     *          specified algorithm.

     *

     * @see Provider

     *

     * @since 1.2

     */

    public static SecureRandom getInstance(String algorithm)

            throws NoSuchAlgorithmException {

        Instance instance = GetInstance.getInstance("SecureRandom",

            SecureRandomSpi.class, algorithm);

        return new SecureRandom((SecureRandomSpi)instance.impl,

            instance.provider, algorithm);

    }

    /**

     * Returns a SecureRandom object that implements the specified

     * Random Number Generator (RNG) algorithm.

     *

     * <p> A new SecureRandom object encapsulating the

     * SecureRandomSpi implementation from the specified provider

     * is returned.  The specified provider must be registered

     * in the security provider list.

     *

     * <p> Note that the list of registered providers may be retrieved via

     * the {@link Security#getProviders() Security.getProviders()} method.

     *

     * <p> The returned SecureRandom object has not been seeded.  To seed the

     * returned object, call the <code>setSeed</code> method.

     * If <code>setSeed</code> is not called, the first call to

     * <code>nextBytes</code> will force the SecureRandom object to seed itself.

     * This self-seeding will not occur if <code>setSeed</code> was

     * previously called.

     *

     * @param algorithm the name of the RNG algorithm.

     * See the SecureRandom section in the <a href=

     * "{@docRoot}/../technotes/guides/security/StandardNames.html#SecureRandom">

     * Java Cryptography Architecture Standard Algorithm Name Documentation</a>

     * for information about standard RNG algorithm names.

     *

     * @param provider the name of the provider.

     *

     * @return the new SecureRandom object.

     *

     * @exception NoSuchAlgorithmException if a SecureRandomSpi

     *          implementation for the specified algorithm is not

     *          available from the specified provider.

     *

     * @exception NoSuchProviderException if the specified provider is not

     *          registered in the security provider list.

     *

     * @exception IllegalArgumentException if the provider name is null

     *          or empty.

     *

     * @see Provider

     *

     * @since 1.2

     */

    public static SecureRandom getInstance(String algorithm, String provider)

            throws NoSuchAlgorithmException, NoSuchProviderException {

        Instance instance = GetInstance.getInstance("SecureRandom",

            SecureRandomSpi.class, algorithm, provider);

        return new SecureRandom((SecureRandomSpi)instance.impl,

            instance.provider, algorithm);

    }

    /**

     * Returns a SecureRandom object that implements the specified

     * Random Number Generator (RNG) algorithm.

     *

     * <p> A new SecureRandom object encapsulating the

     * SecureRandomSpi implementation from the specified Provider

     * object is returned.  Note that the specified Provider object

     * does not have to be registered in the provider list.

     *

     * <p> The returned SecureRandom object has not been seeded.  To seed the

     * returned object, call the <code>setSeed</code> method.

     * If <code>setSeed</code> is not called, the first call to

     * <code>nextBytes</code> will force the SecureRandom object to seed itself.

     * This self-seeding will not occur if <code>setSeed</code> was

     * previously called.

     *

     * @param algorithm the name of the RNG algorithm.

     * See the SecureRandom section in the <a href=

     * "{@docRoot}/../technotes/guides/security/StandardNames.html#SecureRandom">

     * Java Cryptography Architecture Standard Algorithm Name Documentation</a>

     * for information about standard RNG algorithm names.

     *

     * @param provider the provider.

     *

     * @return the new SecureRandom object.

     *

     * @exception NoSuchAlgorithmException if a SecureRandomSpi

     *          implementation for the specified algorithm is not available

     *          from the specified Provider object.

     *

     * @exception IllegalArgumentException if the specified provider is null.

     *

     * @see Provider

     *

     * @since 1.4

     */

    public static SecureRandom getInstance(String algorithm,

            Provider provider) throws NoSuchAlgorithmException {

        Instance instance = GetInstance.getInstance("SecureRandom",

            SecureRandomSpi.class, algorithm, provider);

        return new SecureRandom((SecureRandomSpi)instance.impl,

            instance.provider, algorithm);

    }

    /**

     * Returns the SecureRandomSpi of this SecureRandom object.

     */

    SecureRandomSpi getSecureRandomSpi() {

        return secureRandomSpi;

    }

    /**

     * Returns the provider of this SecureRandom object.

     *

     * @return the provider of this SecureRandom object.

     */

    public final Provider getProvider() {

        return provider;

    }

    /**

     * Returns the name of the algorithm implemented by this SecureRandom

     * object.

     *

     * @return the name of the algorithm or <code>unknown</code>

     *          if the algorithm name cannot be determined.

     * @since 1.5

     */

    public String getAlgorithm() {

        return (algorithm != null) ? algorithm : "unknown";

    }

    /**

     * Reseeds this random object. The given seed supplements, rather than

     * replaces, the existing seed. Thus, repeated calls are guaranteed

     * never to reduce randomness.

     *

     * @param seed the seed.

     *

     * @see #getSeed

     */

    synchronized public void setSeed(byte[] seed) {

        secureRandomSpi.engineSetSeed(seed);

    }

    /**

     * Reseeds this random object, using the eight bytes contained

     * in the given <code>long seed</code>. The given seed supplements,

     * rather than replaces, the existing seed. Thus, repeated calls

     * are guaranteed never to reduce randomness.

     *

     * <p>This method is defined for compatibility with

     * <code>java.util.Random</code>.

     *

     * @param seed the seed.

     *

     * @see #getSeed

     */

    public void setSeed(long seed) {

        /*

         * Ignore call from super constructor (as well as any other calls

         * unfortunate enough to be passing 0).  It's critical that we

         * ignore call from superclass constructor, as digest has not

         * yet been initialized at that point.

         */

        if (seed != 0) {

            secureRandomSpi.engineSetSeed(longToByteArray(seed));

        }

    }

    /**

     * Generates a user-specified number of random bytes.

     *

     * <p> If a call to <code>setSeed</code> had not occurred previously,

     * the first call to this method forces this SecureRandom object

     * to seed itself.  This self-seeding will not occur if

     * <code>setSeed</code> was previously called.

     *

     * @param bytes the array to be filled in with random bytes.

     */

    synchronized public void nextBytes(byte[] bytes) {

        secureRandomSpi.engineNextBytes(bytes);

    }

    /**

     * Generates an integer containing the user-specified number of

     * pseudo-random bits (right justified, with leading zeros).  This

     * method overrides a <code>java.util.Random</code> method, and serves

     * to provide a source of random bits to all of the methods inherited

     * from that class (for example, <code>nextInt</code>,

     * <code>nextLong</code>, and <code>nextFloat</code>).

     *

     * @param numBits number of pseudo-random bits to be generated, where

     * 0 <= <code>numBits</code> <= 32.

     *

     * @return an <code>int</code> containing the user-specified number

     * of pseudo-random bits (right justified, with leading zeros).

     */

    final protected int next(int numBits) {

        int numBytes = (numBits+7)/8;

        byte b[] = new byte[numBytes];

        int next = 0;

        nextBytes(b);

            next = (next << 8) + (b[i] & 0xFF);

        return next >>> (numBytes*8 - numBits);

    }

    /**

     * Returns the given number of seed bytes, computed using the seed

     * generation algorithm that this class uses to seed itself.  This

     * call may be used to seed other random number generators.

     *

     * <p>This method is only included for backwards compatibility.

     * The caller is encouraged to use one of the alternative

     * <code>getInstance</code> methods to obtain a SecureRandom object, and

     * then call the <code>generateSeed</code> method to obtain seed bytes

     * from that object.

     *

     * @param numBytes the number of seed bytes to generate.

     *

     * @return the seed bytes.

     *

     * @see #setSeed

     */

    public static byte[] getSeed(int numBytes) {

            seedGenerator = new SecureRandom();

        return seedGenerator.generateSeed(numBytes);

    }

    /**

     * Returns the given number of seed bytes, computed using the seed

     * generation algorithm that this class uses to seed itself.  This

     * call may be used to seed other random number generators.

     *

     * @param numBytes the number of seed bytes to generate.

     *

     * @return the seed bytes.

     */

    public byte[] generateSeed(int numBytes) {

        return secureRandomSpi.engineGenerateSeed(numBytes);

    }