How to use

init

method

in

javax.crypto.KeyGenerator

public static SecretKey generateAESKey() throws NoSuchAlgorithmException {
  KeyGenerator generator = KeyGenerator.getInstance("AES");
  generator.init(128); // The AES key size in number of bits
  return generator.generateKey();
}

private byte[] generateKey() throws NoSuchAlgorithmException {
  KeyGenerator keygen = KeyGenerator.getInstance("AES");
  keygen.init(128);
  byte[] key = keygen.generateKey().getEncoded();
  return key;
}

 KeyGenerator keyGen = KeyGenerator.getInstance("AES");
keyGen.init(256); // for example
SecretKey secretKey = keyGen.generateKey();

 ByteArrayOutputStream baos = new ByteArrayOutputStream();  
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 = 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);

static KeyGenerator keyGeneratorForAlgorithm(String algorithm, int size) {
 try {
  KeyGenerator keyGen = KeyGenerator.getInstance(algorithm);
  keyGen.init(size);
  return keyGen;
 } catch (NoSuchAlgorithmException ex) {
  LOG.error("Key generator init error", ex);
  return null;
 }
}

  @Override
  public byte[] createIV() throws NoSuchAlgorithmException {
    KeyGenerator keygen = KeyGenerator.getInstance("AES");
    keygen.init(128);
    return keygen.generateKey().getEncoded();
  }
}

public static SecretKey createSecretKey(String sym_alg, int key_size) throws NoSuchAlgorithmException {
  // KeyGenerator keyGen=KeyGenerator.getInstance(getAlgorithm(sym_alg));
  KeyGenerator keyGen=KeyGenerator.getInstance(sym_alg);
  keyGen.init(key_size);
  return keyGen.generateKey();
}

 KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128);
SecretKey key = kgen.generateKey();
byte[] encoded = key.getEncoded();
FileOutputStream output = new FileOutputStream(new File("target-file"));
IOUtils.write(encoded, output);

public byte[] keyGen() throws NoSuchAlgorithmException {
 KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
 keyGenerator.init(192);
 return keyGenerator.generateKey().getEncoded();
}

/**
 * Constructor.  This assumes that state can store the tokens securely, and that they should be enabled at all. Please use
 * ClientAuthUtils.areWorkerTokensEnabledServer to validate this first.
 *
 * @param daemonConf the config for nimbus.
 * @param state      the state used to store private keys.
 */
public WorkerTokenManager(Map<String, Object> daemonConf, IStormClusterState state) {
  this.state = state;
  try {
    keyGen = KeyGenerator.getInstance(WorkerTokenSigner.DEFAULT_HMAC_ALGORITHM);
    keyGen.init(KEY_LENGTH);
  } catch (NoSuchAlgorithmException nsa) {
    throw new IllegalArgumentException("Can't find " + WorkerTokenSigner.DEFAULT_HMAC_ALGORITHM + " algorithm.");
  }
  this.tokenLifetimeMillis = TimeUnit.MILLISECONDS.convert(
    ObjectReader.getLong(daemonConf.get(DaemonConfig.STORM_WORKER_TOKEN_LIFE_TIME_HOURS), 24L),
    TimeUnit.HOURS);
}

String generateRandomSecretKey() {
 try {
  KeyGenerator keyGen = KeyGenerator.getInstance(CRYPTO_KEY);
  keyGen.init(KEY_SIZE_IN_BITS, new SecureRandom());
  SecretKey secretKey = keyGen.generateKey();
  return Base64.encodeBase64String(secretKey.getEncoded());
 } catch (Exception e) {
  throw new IllegalStateException("Fail to generate secret key", e);
 }
}

public static SecretKey getSecretKey(byte[] seed) throws Exception {
  SecureRandom secureRandom = new SecureRandom(seed);
  KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_ALGORITHM);
  keyGenerator.init(secureRandom);
  return keyGenerator.generateKey();
}

 // 1. Generate a session key
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
keyGen.init(128)
SecretKey sessionKey = keyGen.generateKey();

// 2. Encrypt the session key with the RSA public key
Cipher rsaCipher = Cipher.getInstance("RSA");
rsaCipher.init(Cipher.ENCRYPT_MODE, rsaPublicKey)
byte[] encryptedSessionKey = rsaCipher.doFinal(sessionKey.getEncoded());

// 3. Encrypt the data using the session key (unencrypted)
Cipher aesCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
aesCipher.init(Cipher.ENCRYPT_MODE, sessionKey); <-- sessionKey is the unencrypted
//                                                   session key.
// ... use aesCipher to encrypt your data

// 4. Save the encrypted data along with the encrypted 
// session key (encryptedSessionKey).
// PLEASE NOTE THAT BECAUSE OF THE ENCRYPTION MODE (CBC),
// YOU ALSO NEED TO ALSO SAVE THE IV (INITIALIZATION VECTOR).
// aesCipher.aesCipher.getParameters().
//     getParametersSpec(IvParameters.class).getIV();

 KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
keyGenerator.init(128);
SecretKey key = keyGenerator.generateKey();

  keyGen = KeyGenerator.getInstance("AES");
} catch (NoSuchAlgorithmException e) {
  e.printStackTrace();
keyGen.init(128); //128位的AES加密
try {

String generateRandomSecretKey() {
 try {
  KeyGenerator keyGen = KeyGenerator.getInstance(CRYPTO_KEY);
  keyGen.init(KEY_SIZE_IN_BITS, new SecureRandom());
  SecretKey secretKey = keyGen.generateKey();
  return Base64.encodeBase64String(secretKey.getEncoded());
 } catch (Exception e) {
  throw new IllegalStateException("Fail to generate secret key", e);
 }
}

  public static void main(String[] args) {
    Key key;
    SecureRandom rand = new SecureRandom();
    KeyGenerator generator = null;
    try {
      generator = KeyGenerator.getInstance("AES");
    } catch (NoSuchAlgorithmException e) {
      e.printStackTrace();
    }
    generator.init(256, rand);
    key = generator.generateKey();


  }
}

SecureRandom sr = SecureRandom.getInstance("SHA1PRNG", "Crypto");
sr.setSeed(keyStart);
kgen.init(128, sr);
SecretKey skey = kgen.generateKey();
return skey.getEncoded();

 public static void main(String... args) throws Exception {
  byte[] data = "hello".getBytes();

  KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
  keyGenerator.init(128); // 192 and 256 bits may not be available

  SecretKey secretKey = keyGenerator.generateKey();

  Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");

  // By initializing the cipher in CBC mode, an "initialization vector" has been randomly
  // generated. This initialization vector will be necessary to decrypt the encrypted data.
  // It is safe to store the initialization vector in plain text for later use. You can obtain
  // it's bytes by calling iv.getIV().
  cipher.init(Cipher.ENCRYPT_MODE, secretKey);
  IvParameterSpec iv = cipher.getParameters().getParameterSpec(IvParameterSpec.class);
  byte[] encryptedData = cipher.doFinal(data);

  // When decrypting the encrypted data, you must provide the initialization vector used
  // during the encryption phase.
  cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
  byte[] decryptedData = cipher.doFinal(encryptedData);

  if (!Arrays.equals(data, decryptedData)) {
    throw new Exception("Data was not decrypted successfully");
  }
}

/**
 * Generate a new AES key used to encrypt the message.
 *
 * @param keyType Key Type
 * @param keyLength Key Length in bit
 * @return new AES key
 * @throws NoSuchAlgorithmException
 */
public static byte[] generateKey(String keyType, int keyLength) throws NoSuchAlgorithmException {
  KeyGenerator generator = KeyGenerator.getInstance(keyType);
  generator.init(keyLength);
  return generator.generateKey().getEncoded();
}