How to use

generateKey

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;
}

public static Key generateSingleKey() throws NoSuchAlgorithmException {
 Key key = KeyGenerator.getInstance( SINGLE_KEY_ALGORITHM ).generateKey();
 return key;
}

public CombinedCipherOutputStream(OutputStream out, Cipher asym, String algorithm) throws IOException, GeneralSecurityException {
  super(out);
  // create a new symmetric cipher key used for this stream
  String keyAlgorithm = getKeyAlgorithm(algorithm);
  SecretKey symKey = KeyGenerator.getInstance(keyAlgorithm).generateKey();
  // place the symmetric key by encrypting it with asymmetric cipher
  out.write(asym.doFinal(symKey.getEncoded()));
  // the rest of the data will be encrypted by this symmetric cipher
  Cipher sym = Secret.getCipher(algorithm);
  sym.init(Cipher.ENCRYPT_MODE,symKey, keyAlgorithm.equals(algorithm) ? null : new IvParameterSpec(symKey.getEncoded()));
  super.out = new CipherOutputStream(out,sym);
}

 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);

 import java.nio.file.Files;
import java.nio.file.Paths;

KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128);
SecretKey key = kgen.generateKey();
byte[] encoded = key.getEncoded();
Files.write(Paths.get("target-file"), encoded);

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

  @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();
}

  /**
   * Produce a blowfish key to be used in "Storm jar" command
   */
  public static void main(String[] args) {
    try {
      KeyGenerator kgen = KeyGenerator.getInstance("Blowfish");
      SecretKey skey = kgen.generateKey();
      byte[] raw = skey.getEncoded();
      String keyString = new String(Hex.encodeHex(raw));
      System.out.println("storm -c " + SECRET_KEY + "=" + keyString + " -c " + Config.TOPOLOGY_TUPLE_SERIALIZER + "="
          + BlowfishTupleSerializer.class.getName() + " ...");
    } catch (Exception ex) {
      LOG.error(ex.getMessage());
      ex.printStackTrace();
    }
  }
}

 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);

@Override
public SecretKey generate() {
 try {
  KeyGenerator generator = KeyGenerator.getInstance(ALGORITHM);
  return generator.generateKey();
 } catch (NoSuchAlgorithmException e) {
  monitor.severe(() -> "NoSuchAlgorithmException for: " + ALGORITHM, e);
  throw new RuntimeException("Error creating key generator", e);
 }
}

private static byte[] genKey() {
  if (!isInited) {
    init();
  }
  //首先 生成一个密钥(SecretKey),
  //然后,通过这个秘钥,返回基本编码格式的密钥，如果此密钥不支持编码，则返回 null。
  return keyGen.generateKey().getEncoded();
}

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

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();
}

private SecretKey getKey() {
  if (key==null) {
    synchronized (this) {
      if (key==null) {
        try {
          byte[] encoded = load();
          if (encoded==null) {
            KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM);
            SecretKey key = kg.generateKey();
            store(encoded=key.getEncoded());
          }
          key = new SecretKeySpec(encoded,ALGORITHM);
        } catch (IOException e) {
          throw new Error("Failed to load the key: "+getId(),e);
        } catch (NoSuchAlgorithmException e) {
          throw new Error("Failed to load the key: "+getId(),e);
        }
      }
    }
  }
  return key;
}

 // 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();

  gen = KeyGenerator.getInstance(alg.getJcaName());
} catch (NoSuchAlgorithmException e) {
  throw new IllegalStateException("The " + alg.getJcaName() + " algorithm is not available.  " +
return gen.generateKey();

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