public void initialize() {
e = BigInteger.valueOf(65537);
SecureRandom sr = new SecureRandom();
BigInteger diff = BigInteger.valueOf(2).pow(256);
/*
generate 2 prime numbers greater than 512 bits and that have difference of 2^256
*/
do {
sr.generateSeed(size);
p = new BigInteger(size, 256, sr);
sr.generateSeed(size);
q = new BigInteger(size, 256, sr);
} while (p.bitLength() < size
|| q.bitLength() < size
|| !p.isProbablePrime(256)
|| !q.isProbablePrime(256)
|| p.subtract(q).abs().compareTo(diff) != 1);
n = p.multiply(q);
phi_n = p.subtract(BigInteger.ONE).multiply(q.subtract(BigInteger.ONE));
d = e.modInverse(phi_n);
}
/**
* Changes the internal state to a new, fully-random version that should have no relation to the
* previous state. May be somewhat slow; you shouldn't need to call this often.
*/
public void randomize() {
byte[] bytes = sec.generateSeed(128);
for (int i = sec.nextInt() & 127, c = 0; c < 128; c++, i = i + 1 & 127) {
state[i & 15] |= bytes[c] << ((i >> 4) << 3);
}
choice = sec.nextInt(16);
}
// ---------------------------------------------------------------
private byte[] getSalt(int saltSize) throws NoSuchAlgorithmException, NoSuchProviderException {
// SecureRandom sr = SecureRandom.getInstance( SECURE_RANDOM_ALGORITHM,
// SECURITY_PROVIDER );
SecureRandom sr = new SecureRandom();
sr.setSeed(System.currentTimeMillis());
return sr.generateSeed(saltSize);
}
/*
* Generate random salt
*/
private byte[] getSalt() {
// Generate a random salt.
byte[] salt = new byte[SALT_LEN];
if (random == null) {
random = new SecureRandom();
}
salt = random.generateSeed(SALT_LEN);
return salt;
}
static {
try {
rnd = SecureRandom.getInstance("SHA1PRNG");
} catch (NoSuchAlgorithmException e) {
rnd = new SecureRandom(); // Use default if prefered provider is unavailable
}
byte[] seed = rnd.generateSeed(64);
rnd.setSeed(seed);
}
/** Fall sem framkallar nýtt salt. */
public byte[] getNewSalt() throws Exception {
String TAG = "PasswordHandler getNewSalt";
try {
SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
return random.generateSeed(saltLen);
} catch (Exception e) {
// Villa
throw new Exception("Something went wrong, " + TAG + ": " + e.getMessage());
}
}
public static byte[] randomKey(final int size) {
try {
final KeyGenerator gen = KeyGenerator.getInstance(ALGORITHM);
final SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
sr.generateSeed(128);
gen.init(128, sr);
return gen.generateKey().getEncoded();
} catch (final Exception e) {
throw new RuntimeException(e);
}
}
private SecureRandom createSecureRandom(String algorithm, String provider, int keyLength) {
try {
SecureRandom random = SecureRandom.getInstance(algorithm, provider);
random.setSeed(random.generateSeed(keyLength));
return random;
} catch (NoSuchAlgorithmException e) {
throw new IllegalArgumentException(
"Not a supported SecureRandom key generation algorithm", e);
} catch (NoSuchProviderException e) {
throw new IllegalArgumentException("Not a supported SecureRandom key provider", e);
}
}
public String generateToken(String userName) throws PhrescoException {
String token = "";
try {
SecureRandom random = SecureRandom.getInstance(ALGORITHM_NAME);
byte[] seed = random.generateSeed(132);
random.setSeed(seed);
token = new BigInteger(132, random).toString(32);
tokenCache.put(token, userName);
} catch (NoSuchAlgorithmException e) {
throw new PhrescoException(e);
}
return token;
}
public Client createClient(
PackageInfoOAuth packageInfo,
ClientType clientType,
String[] redirectURIs,
Map<String, Object> properties) {
if (properties == null) {
properties = new HashMap<String, Object>();
}
Object flows = properties.get(Client.PROPERTY_SUPPORTED_FLOWS);
if (flows == null) {
flows = defaultSupportedFlow.get(clientType);
properties.put(Client.PROPERTY_SUPPORTED_FLOWS, flows);
}
/*
* The authorization server MUST require the following clients to
* register their redirection endpoint: o Public clients. o Confidential
* clients utilizing the implicit grant type. (3.1.2.2. Registration
* Requirements)
*/
if (clientType == ClientType.PUBLIC
|| (clientType == ClientType.CONFIDENTIAL
&& Arrays.asList((Object[]) flows).contains(ResponseType.token))) {
if (redirectURIs == null || redirectURIs.length == 0) {
throw new IllegalArgumentException("RedirectionURI(s) required.");
}
}
String clientId = UUID.randomUUID().toString();
char[] clientSecret = null;
if (clientType == ClientType.CONFIDENTIAL
|| (clientType == ClientType.PUBLIC && isIssueClientSecretToPublicClients())) {
// Issue a client secret to the confidential client.
if (count++ > RESEED_CLIENTS) {
count = 0;
random.setSeed(random.generateSeed(20));
}
byte[] secret = new byte[20];
random.nextBytes(secret);
clientSecret = Base64.encode(secret, false).toCharArray();
}
return createClient(packageInfo, clientId, clientSecret, clientType, redirectURIs, properties);
}
public static void generateRandomSeed() {
// create a 160-bit seed
SecureRandom sr0 = new SecureRandom();
byte[] seed = sr0.generateSeed(SEED_BYTES);
// make a string representation
StringBuffer buffer = new StringBuffer(SEED_BYTES * 3);
for (int i = 0; i < seed.length; i++) {
buffer.append(',');
int seedByte = seed[i] & 0xFF;
if (seedByte < 16) {
buffer.append('0');
}
buffer.append(Integer.toHexString(seedByte));
}
// save it in local.properties (Note: remove leading comma)
LocalProperties.setProperty("random_seed", buffer.substring(1));
}
public synchronized byte[] generateSeed(int numBytes) {
checkActive();
return secureRandom.generateSeed(numBytes);
}
private void seedFromExternalStuff(boolean canBlock) {
byte[] buf = new byte[32];
if (File.separatorChar == '/') {
DataInputStream dis = null;
FileInputStream fis = null;
File hwrng = new File("/dev/hwrng");
if (hwrng.exists() && hwrng.canRead())
try {
fis = new FileInputStream(hwrng);
dis = new DataInputStream(fis);
dis.readFully(buf);
consumeBytes(buf);
dis.readFully(buf);
consumeBytes(buf);
dis.close();
} catch (Throwable t) {
Logger.normal(this, "Can't read /dev/hwrng even though exists and is readable: " + t, t);
} finally {
Closer.close(dis);
Closer.close(fis);
}
boolean isSystemEntropyAvailable = true;
// Read some bits from /dev/urandom
try {
fis = new FileInputStream("/dev/urandom");
dis = new DataInputStream(fis);
dis.readFully(buf);
consumeBytes(buf);
dis.readFully(buf);
consumeBytes(buf);
} catch (Throwable t) {
Logger.normal(this, "Can't read /dev/urandom: " + t, t);
// We can't read it; let's skip /dev/random and seed from SecureRandom.generateSeed()
canBlock = true;
isSystemEntropyAvailable = false;
} finally {
Closer.close(dis);
Closer.close(fis);
}
if (canBlock && isSystemEntropyAvailable)
// Read some bits from /dev/random
try {
fis = new FileInputStream("/dev/random");
dis = new DataInputStream(fis);
dis.readFully(buf);
consumeBytes(buf);
dis.readFully(buf);
consumeBytes(buf);
} catch (Throwable t) {
Logger.normal(this, "Can't read /dev/random: " + t, t);
} finally {
Closer.close(dis);
Closer.close(fis);
}
fis = null;
} else
// Force generateSeed(), since we can't read random data from anywhere else.
// Anyway, Windows's CAPI won't block.
canBlock = true;
if (canBlock) {
// SecureRandom hopefully acts as a proxy for CAPI on Windows
buf = sr.generateSeed(32);
consumeBytes(buf);
buf = sr.generateSeed(32);
consumeBytes(buf);
}
// A few more bits
consumeString(Long.toHexString(Runtime.getRuntime().freeMemory()));
consumeString(Long.toHexString(Runtime.getRuntime().totalMemory()));
}
static {
random.setSeed(
OLongSerializer.INSTANCE.deserialize(
secureRandom.generateSeed(OLongSerializer.LONG_SIZE), 0));
}
/**
* 盐初始化 长度8字节
*
* @return
*/
public static byte[] initSalt() {
SecureRandom random = new SecureRandom();
return random.generateSeed(8);
}
public static void main(String... arguments) throws Exception {
byte[] bytes;
SecureRandom prng = SecureRandom.getInstance("SHA1PRNG");
bytes = prng.generateSeed(1);
}
/** Helper to reseed the shared secure random number generator. */
public static void reseedSharedRandom() {
sharedSecureRandom.setSeed(sharedSecureRandom.generateSeed(8));
}