How to use

getInstance

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

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

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

private byte[] generateKey() throws NoSuchAlgorithmException {
  KeyGenerator keygen = KeyGenerator.getInstance("AES");
  keygen.init(128);
  byte[] key = keygen.generateKey().getEncoded();
  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);
}

/**
 * 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);
}

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

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

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

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

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

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

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

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

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

/**
 * Uses AES/CBC algorithm, no key wrapping.
 */
public void encryptionOnly_CustomerManagedKey() throws NoSuchAlgorithmException {
  SecretKey secretKey = KeyGenerator.getInstance("AES").generateKey();
  AmazonS3Encryption s3Encryption = AmazonS3EncryptionClientBuilder
      .standard()
      .withRegion(Regions.US_WEST_2)
      .withCryptoConfiguration(new CryptoConfiguration(CryptoMode.EncryptionOnly))
      .withEncryptionMaterials(new StaticEncryptionMaterialsProvider(new EncryptionMaterials(secretKey)))
      .build();
  AmazonS3 s3NonEncrypt = AmazonS3ClientBuilder.defaultClient();
  s3Encryption.putObject(BUCKET_NAME, ENCRYPTED_KEY, "some contents");
  s3NonEncrypt.putObject(BUCKET_NAME, NON_ENCRYPTED_KEY, "some other contents");
  System.out.println(s3Encryption.getObjectAsString(BUCKET_NAME, ENCRYPTED_KEY));
  System.out.println(s3Encryption.getObjectAsString(BUCKET_NAME, NON_ENCRYPTED_KEY));
}

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

/**
 * For ranged GET we do not use authenticated encryption since we aren't reading the entire message and can't produce the
 * MAC. Instead we use AES/CTR, an unauthenticated encryption algorithm. If {@link CryptoMode#StrictAuthenticatedEncryption}
 * is enabled, ranged GETs will not be allowed since they do not use authenticated encryption..
 */
public void authenticatedEncryption_RangeGet_CustomerManagedKey() throws NoSuchAlgorithmException {
  SecretKey secretKey = KeyGenerator.getInstance("AES").generateKey();
  AmazonS3Encryption s3Encryption = AmazonS3EncryptionClientBuilder
      .standard()
      .withRegion(Regions.US_WEST_2)
      .withCryptoConfiguration(new CryptoConfiguration(CryptoMode.AuthenticatedEncryption))
      .withEncryptionMaterials(new StaticEncryptionMaterialsProvider(new EncryptionMaterials(secretKey)))
      .build();
  AmazonS3 s3NonEncrypt = AmazonS3ClientBuilder.defaultClient();
  s3Encryption.putObject(BUCKET_NAME, ENCRYPTED_KEY, "some contents");
  s3NonEncrypt.putObject(BUCKET_NAME, NON_ENCRYPTED_KEY, "some other contents");
  System.out.println(s3Encryption.getObjectAsString(BUCKET_NAME, ENCRYPTED_KEY));
  System.out.println(s3Encryption.getObjectAsString(BUCKET_NAME, NON_ENCRYPTED_KEY));
}

/**
 * 生成AES密钥,可选长度为128,192,256位.
 */
public static byte[] generateAesKey(int keysize) {
  try {
    KeyGenerator keyGenerator = KeyGenerator.getInstance(AES_ALG);
    keyGenerator.init(keysize);
    SecretKey secretKey = keyGenerator.generateKey();
    return secretKey.getEncoded();
  } catch (GeneralSecurityException e) {
    throw ExceptionUtil.unchecked(e);
  }
}