Deterministic SecureRandom (neither secure nor random)

PseudoSecureRandom.java

import java.security.Provider;
import java.security.SecureRandom;
import java.security.SecureRandomSpi;

import org.bouncycastle.crypto.digests.SHA256Digest;
import org.bouncycastle.crypto.engines.Salsa20Engine;
import org.bouncycastle.crypto.params.KeyParameter;
import org.bouncycastle.crypto.params.ParametersWithIV;

public class PseudoSecureRandom extends SecureRandom {

	private static final Provider PROVIDER = new PseudoSecureRandomProvider();

	public PseudoSecureRandom(byte[] seed) {
		super(new PseudoSecureRandomSpi(seed), PROVIDER);
	}

	private static class PseudoSecureRandomSpi extends SecureRandomSpi {

		private final Salsa20Engine cipher;

		private PseudoSecureRandomSpi(byte[] seed) {
			cipher = new Salsa20Engine();
			initialise(seed);
		}

		private void initialise(byte[] seed) {
			// Hash the seed to produce a 256-bit key
			byte[] key = new byte[32];
			SHA256Digest digest = new SHA256Digest();
			digest.update(seed, 0, seed.length);
			digest.doFinal(key, 0);
			// Initialise the stream cipher with an all-zero nonce
			byte[] nonce = new byte[8];
			cipher.init(true, new ParametersWithIV(new KeyParameter(key), nonce));
		}

		@Override
		protected void engineSetSeed(byte[] seed) {
			initialise(seed);
		}

		@Override
		protected void engineNextBytes(byte[] out) {
			byte[] blank = new byte[out.length];
			cipher.processBytes(blank, 0, out.length, out, 0);
		}

		@Override
		protected byte[] engineGenerateSeed(int length) {
			byte[] seed = new byte[length];
			engineNextBytes(seed);
			return seed;
		}
	}

	private static class PseudoSecureRandomProvider extends Provider {

		private PseudoSecureRandomProvider() {
			super("PseudoSecureRandom", 1.0, "Deterministic PRNG");
		}
	}
}