private static byte[] key(final byte[] key) throws Exception { final KeyGenerator gen = KeyGenerator.getInstance(ALGORITHM); final SecureRandom sr = SecureRandom.getInstance("SHA1PRNG"); sr.setSeed(key); gen.init(128, sr); return gen.generateKey().getEncoded(); }
/** * Returns the SecureRandom used to generate secure random data. * * <p>Creates and initializes if null. * * @return the SecureRandom used to generate secure random data */ private SecureRandom getSecRan() { if (secRand == null) { secRand = new SecureRandom(); secRand.setSeed(System.currentTimeMillis()); } return secRand; }
// --------------------------------------------------------------- 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); }
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); ByteArrayOutputStream baos = new ByteArrayOutputStream(); Bitmap bm = null; bm.compress(Bitmap.CompressFormat.PNG, 100, baos); // bm is the bitmap object byte[] b = baos.toByteArray(); byte[] keyStart = "this is a key".getBytes(); KeyGenerator kgen; try { kgen = KeyGenerator.getInstance("AES"); SecureRandom sr = SecureRandom.getInstance("SHA1PRNG"); sr.setSeed(keyStart); kgen.init(128, sr); // 192 and 256 bits may not be available SecretKey skey = kgen.generateKey(); byte[] key = skey.getEncoded(); // encrypt byte[] encryptedData = encrypt(key, b); // decrypt byte[] decryptedData = decrypt(key, encryptedData); } catch (NoSuchAlgorithmException e) { // TODO 自動產生的 catch 區塊 e.printStackTrace(); } catch (Exception e) { // TODO 自動產生的 catch 區塊 e.printStackTrace(); } }
public boolean generateKeys() { PublicKey keyPub; PrivateKey keyPri; SecureRandom rand; Security.addProvider(new ABAProvider()); rand = new SecureRandom(); rand.setSeed(System.currentTimeMillis()); try { KeyPairGenerator fact; KeyPair keyPair; fact = KeyPairGenerator.getInstance("RSA", "ABA"); fact.initialize(1024, rand); keyPair = fact.generateKeyPair(); keyPub = keyPair.getPublic(); keyPri = keyPair.getPrivate(); pubKey = bytesToHexStr(keyPub.getEncoded()); priKey = bytesToHexStr(keyPri.getEncoded()); } catch (Exception e) { return false; } return true; }
public PBEKeySpec getPassword(IPreferencesContainer container, int passwordType) { byte[] encryptedPassword; if ((passwordType & CREATE_NEW_PASSWORD) == 0) encryptedPassword = getEncryptedPassword(container); else encryptedPassword = null; if (encryptedPassword != null) { byte[] decryptedPassword = windecrypt(encryptedPassword); if (decryptedPassword != null) { String password = new String(decryptedPassword); return new PBEKeySpec(password.toCharArray()); } else { StorageException e = new StorageException( StorageException.ENCRYPTION_ERROR, WinCryptoMessages.decryptPasswordFailed); AuthPlugin.getDefault().logError(WinCryptoMessages.decryptPasswordFailed, e); return null; } } // add info message in the log AuthPlugin.getDefault().logMessage(WinCryptoMessages.newPasswordGenerated); byte[] rawPassword = new byte[PASSWORD_LENGTH]; SecureRandom random = new SecureRandom(); random.setSeed(System.currentTimeMillis()); random.nextBytes(rawPassword); String password = Base64.encode(rawPassword); if (savePassword(password, container)) return new PBEKeySpec(password.toCharArray()); else return null; }
private static byte[] getRawKey(byte[] seed) throws Exception { KeyGenerator kgen = KeyGenerator.getInstance("AES"); SecureRandom sr = SecureRandom.getInstance("SHA1PRNG"); sr.setSeed(seed); kgen.init(128, sr); // 192 and 256 bits may not be available return kgen.generateKey().getEncoded(); }
/** * 产生任意给定长度的随纯机数字字符串。 * * @param iLength 产生随机数的位数 * @return 给定位数的随机数 */ public static String getRandomIntNum(int iLength) { sr.setSeed(System.currentTimeMillis()); StringBuffer sb = new StringBuffer(); for (int i = 0; i < iLength; i++) { sb.append(Math.abs(sr.nextInt(10))); } return sb.toString(); }
/** * 获取RSA公私钥 * * @param seedBytes * @return * @throws NoSuchAlgorithmException */ public KeyPair generateRSAKeyPair(byte[] seedBytes) throws NoSuchAlgorithmException { KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA"); int keySize = 1024; // 约定RSA加密采用1024位 // linux下需强制设置RNG算法 SecureRandom random = SecureRandom.getInstance("SHA1PRNG"); random.setSeed(seedBytes); keyGen.initialize(keySize, random); return keyGen.generateKeyPair(); }
private byte[] getRawKey(byte[] seed) throws Exception { KeyGenerator kgen = KeyGenerator.getInstance("AES"); SecureRandom sr = SecureRandom.getInstance("SHA1PRNG", "Crypto"); sr.setSeed(seed); kgen.init(128, sr); SecretKey skey = kgen.generateKey(); byte[] raw = skey.getEncoded(); return raw; }
private byte[] getRawKey(byte[] seed) throws NoSuchAlgorithmException { KeyGenerator kgen = KeyGenerator.getInstance(PASS_ALGO); SecureRandom sr = SecureRandom.getInstance("SHA1PRNG"); sr.setSeed(seed); kgen.init(128, sr); SecretKey skey = kgen.generateKey(); byte[] raw = skey.getEncoded(); return raw; }
static void init(int numTerms) { SecureRandom random = new SecureRandom(); random.setSeed(1); termsList.clear(); for (int i = 0; i < numTerms; i++) { String term = new BigInteger(512, random).toString(32); termsList.add(term); } }
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); }
// ZAP: added new ServerSocketFaktory with support of dynamic SSL certificates public SSLSocketFactory getTunnelSSLSocketFactory(String hostname) { // SSLServerSocketFactory ssf = null; // set up key manager to do server authentication // KeyStore ks; try { SSLContext ctx = SSLContext.getInstance("SSL"); KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509"); SslCertificateService scs = CachedSslCertifificateServiceImpl.getService(); KeyStore ks = scs.createCertForHost(hostname); kmf.init(ks, SslCertificateService.PASSPHRASE); java.security.SecureRandom x = new java.security.SecureRandom(); x.setSeed(System.currentTimeMillis()); ctx.init(kmf.getKeyManagers(), null, x); SSLSocketFactory tunnelSSLFactory = ctx.getSocketFactory(); return tunnelSSLFactory; } catch (NoSuchAlgorithmException e) { // Turn into RuntimeException. How to handle this error in a user friendly way? throw new RuntimeException(e); } catch (KeyStoreException e) { // Turn into RuntimeException. How to handle this error in a user friendly way? throw new RuntimeException(e); } catch (CertificateException e) { // Turn into RuntimeException. How to handle this error in a user friendly way? throw new RuntimeException(e); // } catch (IOException e) { // // Turn into RuntimeException. How to handle this error in a user friendly way? // throw new RuntimeException(e); } catch (UnrecoverableKeyException e) { // Turn into RuntimeException. How to handle this error in a user friendly way? throw new RuntimeException(e); } catch (KeyManagementException e) { // Turn into RuntimeException. How to handle this error in a user friendly way? throw new RuntimeException(e); } catch (InvalidKeyException e) { // Turn into RuntimeException. How to handle this error in a user friendly way? throw new RuntimeException(e); } catch (NoSuchProviderException e) { // Turn into RuntimeException. How to handle this error in a user friendly way? throw new RuntimeException(e); } catch (SignatureException e) { // Turn into RuntimeException. How to handle this error in a user friendly way? throw new RuntimeException(e); } catch (IOException e) { // Turn into RuntimeException. How to handle this error in a user friendly way? throw new RuntimeException(e); } }
public static void setKey(String key) { try { KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM_AES); SecureRandom secureRandom = SecureRandom.getInstance(ALGORITHM_SHA1_PRNG); secureRandom.setSeed(key.getBytes()); keyGenerator.init(secureRandom); setAesKey(keyGenerator.generateKey()); keyGenerator = null; } catch (Exception e) { e.printStackTrace(); } }
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 void testLIFO() { SecureRandom sr = new SecureRandom(); sr.setSeed(System.currentTimeMillis()); int ntries = 1; for (int i = 0; i < ntries; i++) { int n = 1000; float[] x = createRandomNumbers(sr, n); float[] y = createRandomNumbers(sr, n); XYStack stack = new XYStack(); for (int j = 0; j < n; j++) { stack.push(x[j], y[j]); } float xCheck0 = x[n - 1]; float yCheck0 = y[n - 1]; float xCheck1 = x[n - 2]; float yCheck1 = y[n - 2]; float xCheck2 = x[n - 3]; float yCheck2 = y[n - 3]; float xCheck3 = x[n - 4]; float yCheck3 = y[n - 4]; float[] result0 = stack.pop(); float[] result1 = stack.pop(); float[] result2 = stack.pop(); float[] result3 = stack.pop(); assertTrue(Math.abs(xCheck0 - result0[0]) < 0.01); assertTrue(Math.abs(yCheck0 - result0[1]) < 0.01); assertTrue(Math.abs(xCheck1 - result1[0]) < 0.01); assertTrue(Math.abs(yCheck1 - result1[1]) < 0.01); assertTrue(Math.abs(xCheck2 - result2[0]) < 0.01); assertTrue(Math.abs(yCheck2 - result2[1]) < 0.01); assertTrue(Math.abs(xCheck3 - result3[0]) < 0.01); assertTrue(Math.abs(yCheck3 - result3[1]) < 0.01); } }
public static String buildNonce(Date date) { String nonce = ""; try { SecureRandom random = java.security.SecureRandom.getInstance("SHA1PRNG"); random.setSeed(date.getTime()); byte[] nonceBytes = new byte[16]; random.nextBytes(nonceBytes); nonce = new String(Base64.encodeBase64(nonceBytes), "UTF-8"); } catch (Exception e) { e.printStackTrace(); } return nonce; }
private static SecureRandom createSecureRandom() { /* * We use our threaded seed generator to generate a good random seed. If the user * has a better random seed, he should use the constructor with a SecureRandom. */ ThreadedSeedGenerator tsg = new ThreadedSeedGenerator(); SecureRandom random = new SecureRandom(); /* * Hopefully, 20 bytes in fast mode are good enough. */ random.setSeed(tsg.generateSeed(20, true)); return random; }
private static byte[] getRawKey(byte[] seed) throws Exception { KeyGenerator kgen = KeyGenerator.getInstance(KEY_ALGORITHM); // SHA1PRNG 强随机种子算法, 要区别4.2以上版本的调用方法 SecureRandom sr = null; if (android.os.Build.VERSION.SDK_INT >= 17) { sr = SecureRandom.getInstance("SHA1PRNG", PROVIDER); } else { sr = SecureRandom.getInstance("SHA1PRNG"); } sr.setSeed(seed); kgen.init(KEY_SIZE, sr); // 256 bits or 128 bits,192bits SecretKey skey = kgen.generateKey(); byte[] raw = skey.getEncoded(); return raw; }
public Long getChallenge() { if (challenge == null) { SecureRandom random; try { random = SecureRandom.getInstance("SHA1PRNG", "SUN"); } catch (NoSuchAlgorithmException ex) { random = new SecureRandom(); LOGGER.error(ex.getMessage(), ex); } catch (NoSuchProviderException ex) { random = new SecureRandom(); LOGGER.error(ex.getMessage(), ex); } random.setSeed((new Date()).getTime()); challenge = random.nextLong() % (10 ^ 6); } return challenge; }
public static String decrypt(byte[] content, String keyWord) throws OfficeException { try { KeyGenerator kgen = KeyGenerator.getInstance("AES"); SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG"); secureRandom.setSeed(keyWord.getBytes()); kgen.init(128, secureRandom); SecretKey secretKey = kgen.generateKey(); byte[] enCodeFormat = secretKey.getEncoded(); SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES"); Cipher cipher = Cipher.getInstance("AES"); cipher.init(Cipher.DECRYPT_MODE, key); byte[] result = cipher.doFinal(content); return new String(result); } catch (Exception e) { throw new OfficeException("encrypt failed:", e); } }
/* * 获得AES密钥 */ byte[] generateAesByte(byte[] seedBytes) { // AIX小型机下SecureRandom算法不一致 KeyGenerator keyGen = null; int keySize = 128; // 约定AES加密采用 128 位 // linux下需强制设置RNG算法 SecureRandom random = null; try { keyGen = KeyGenerator.getInstance("AES"); random = SecureRandom.getInstance("SHA1PRNG"); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } random.setSeed(seedBytes); keyGen.init(keySize, random); SecretKey secretKey = keyGen.generateKey(); return secretKey.getEncoded(); }
private Tetromino createRandomTetromino() { Tetromino result = null; SecureRandom random = new SecureRandom(); random.setSeed(UUID.randomUUID().hashCode()); int type = random.nextInt(NUMBER_OF_TETROMINO_TYPE); switch (type) { case TETROMINO_L: result = new LTetromino(); break; case TETROMINO_J: result = new JTetromino(); break; case TETROMINO_S: result = new STetromino(); break; case TETROMINO_Z: result = new ZTetromino(); break; case TETROMINO_T: result = new TTetromino(); break; case TETROMINO_O: result = new OTetromino(); break; case TETROMINO_I: result = new ITetromino(); break; } int color = random.nextInt(Tetromino.NUMBER_OF_COLOR) + 1; result.setColor(color); result.setX(0); result.setY(0); int col = result.getFirstBlockColIndex(); int row = result.getFirstBlockRowIndex(); result.setX(4 - col); result.setY(0 - row); return result; }
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 SSLSocketFactory getClientSocketFactory(String type) { // Trust all invalid server certificate TrustManager[] trustMgr = new TrustManager[] {new RelaxedX509TrustManager()}; try { SSLContext sslContext = SSLContext.getInstance(type); java.security.SecureRandom x = new java.security.SecureRandom(); x.setSeed(System.currentTimeMillis()); sslContext.init(null, trustMgr, x); clientSSLSockFactory = sslContext.getSocketFactory(); HttpsURLConnection.setDefaultSSLSocketFactory(clientSSLSockFactory); } catch (Exception e) { e.printStackTrace(); } return clientSSLSockFactory; }
/** Safely initializes the random number generator, by seeding it with data from /dev/urandom. */ public static void initialize(SecureRandom generator) throws IOException { FileInputStream fis = null; try { fis = new FileInputStream("/dev/urandom"); if (fis.read(sSeedBytes) != sSeedBytes.length) { throw new IOException("Failed to get enough random data."); } generator.setSeed(sSeedBytes); } finally { try { if (fis != null) { fis.close(); } } catch (IOException e) { // Ignore exception closing the device. } } }
public AESEncryptor(String key) { KeyGenerator generator = null; try { generator = KeyGenerator.getInstance("AES"); SecureRandom secureRandom; if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) { secureRandom = SecureRandom.getInstance("SHA1PRNG", "Crypto"); } else { secureRandom = SecureRandom.getInstance("SHA1PRNG"); } secureRandom.setSeed(key.getBytes()); generator.init(128, secureRandom); } catch (Exception e) { Log.e(TAG, e.getMessage()); } if (generator != null) { mKeyBytes = generator.generateKey().getEncoded(); } }
/** Creates a new instance of Encrypter */ public AltEncrypter(String passPhrase) { try { SecureRandom sr = SecureRandom.getInstance("SHA1PRNG"); sr.setSeed(passPhrase.getBytes("UTF8")); KeyGenerator kGen = KeyGenerator.getInstance("DESEDE"); kGen.init(168, sr); Key key = kGen.generateKey(); cipherEncrypt = Cipher.getInstance("DESEDE/ECB/PKCS5Padding"); cipherEncrypt.init(Cipher.ENCRYPT_MODE, key); cipherDecrypt = Cipher.getInstance("DESEDE/ECB/PKCS5Padding"); cipherDecrypt.init(Cipher.DECRYPT_MODE, key); } catch (UnsupportedEncodingException e) { } catch (NoSuchPaddingException e) { } catch (NoSuchAlgorithmException e) { } catch (InvalidKeyException e) { } }