Java 类javax.crypto.Cipher 实例源码

@Override
public void encryptData(String plaintext) {
   System.out.println("-------Encrypting data using AES algorithm-------");
   try {
       KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
       keyGenerator.init(128);
       SecretKey secretKey = keyGenerator.generateKey();
       byte[] plaintTextByteArray = plaintext.getBytes("UTF8");

       Cipher cipher = Cipher.getInstance("AES");
       cipher.init(Cipher.ENCRYPT_MODE, secretKey);
       byte[] cipherText = cipher.doFinal(plaintTextByteArray);

       System.out.println("Original data: " + plaintext);
       System.out.println("Encrypted data:");
       for (int i = 0; i < cipherText.length; i++) {
           System.out.print(cipherText[i] + " ");

       }
   }
       catch(Exception ex){
           ex.printStackTrace();
       }
   }

protected String decrypt(final String value, final String hashedKey) {
    if (value == null) {
        return null;
    }

    try {
        final Cipher cipher = getCipherObject();
        final byte[] ivCiphertext = decode(value.getBytes());
        final int ivSize = byte2int(Arrays.copyOfRange(ivCiphertext, 0, INTEGER_LEN));
        final byte[] ivValue = Arrays.copyOfRange(ivCiphertext, INTEGER_LEN, (INTEGER_LEN + ivSize));
        final byte[] ciphertext = Arrays.copyOfRange(ivCiphertext, INTEGER_LEN + ivSize, ivCiphertext.length);
        final IvParameterSpec ivSpec = new IvParameterSpec(ivValue);

        cipher.init(Cipher.DECRYPT_MODE, this.key, ivSpec);

        final byte[] plaintext = cipher.doFinal(ciphertext);

        return new String(plaintext);
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }
}

public SafeApacheCamelCipherPair(String transformation)
        throws GeneralSecurityException {
    this.transformation = transformation;

    int d = transformation.indexOf('/');
    String cipherName;
    if (d > 0) {
        cipherName = transformation.substring(0, d);
    } else {
        cipherName = transformation;
    }
    KeyGenerator keygen = KeyGenerator.getInstance(cipherName);
    keygen.init(new SecureRandom());
    Key key = keygen.generateKey();
    this.enccipher = Cipher.getInstance(transformation);
    this.deccipher = Cipher.getInstance(transformation);
    this.enccipher.init(1, key);
    byte[] ivp = this.enccipher.getIV();
    this.deccipher.init(2, key, ivp == null ? null : new IvParameterSpec(ivp));
}

static final Key constructKey(byte[] encoding, String keyAlgorithm,
                              int keyType)
    throws InvalidKeyException, NoSuchAlgorithmException {
    Key result = null;
    switch (keyType) {
    case Cipher.SECRET_KEY:
        result = ConstructKeys.constructSecretKey(encoding,
                                                  keyAlgorithm);
        break;
    case Cipher.PRIVATE_KEY:
        result = ConstructKeys.constructPrivateKey(encoding,
                                                   keyAlgorithm);
        break;
    case Cipher.PUBLIC_KEY:
        result = ConstructKeys.constructPublicKey(encoding,
                                                  keyAlgorithm);
        break;
    }
    return result;
}

public static void encrypt(String message) throws Exception {

        byte[] iv = new byte[16];
        new SecureRandom().nextBytes(iv);

        //IV
        IvParameterSpec ivSpec = new IvParameterSpec(iv);

        //Key
        KeyGenerator generator = KeyGenerator.getInstance("AES");
        generator.init(128);
        SecretKey secretKey = generator.generateKey();

        //Encrypt
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding", "BC");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivSpec);
        cipher.update(message.getBytes());

        byte[] data = cipher.doFinal();
        System.out.println(HexUtil.toString(data));
    }

/**
 * Initialises this cipher with key and a source of randomness
 */
protected void engineInit(int mode, Key key, SecureRandom random)
        throws InvalidKeyException {
    if (mode == Cipher.ENCRYPT_MODE)
        if (!(key instanceof PaillierPublicKey))
            throw new InvalidKeyException(
                    "I didn't get a PaillierPublicKey. ");
        else if (mode == Cipher.DECRYPT_MODE)
            if (!(key instanceof PaillierPrivateKey))
                throw new InvalidKeyException(
                        "I didn't get a PaillierPrivateKey. ");
            else
                throw new IllegalArgumentException("Bad mode: " + mode);

    stateMode = mode;
    keyPaillier = key;
    SECURE_RANDOM = random;
    int modulusLength = ((PaillierKey) key).getN().bitLength();
    calculateBlockSizes(modulusLength);
}

/**
 * aes解密-128位
 */
public static String AesDecrypt(String encryptContent, String password) {
    try {
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
        secureRandom.setSeed(password.getBytes());
        keyGen.init(128, secureRandom);
        SecretKey secretKey = keyGen.generateKey();
        byte[] enCodeFormat = secretKey.getEncoded();
        SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, key);
        return new String(cipher.doFinal(hex2Bytes(encryptContent)));
    } catch (Exception e) {
        logger.error("AesDecrypt exception", e);
        return null;
    }
}

/**
 * Returns the algorithm supported for input mechanism.
 * @param mech Mechanism name
 * @param alg Algorithm name
 * @return Algorithm name
 */
private static String getDefaultAlg(String mech, String alg)
        throws NoSuchAlgorithmException {
    if (alg == null) {
        switch (mech) {
            case "Hash_DRBG":
            case "HMAC_DRBG":
                return "SHA-256";
            case "CTR_DRBG":
                return (Cipher.getMaxAllowedKeyLength("AES") < 256)
                        ? "AES-128" : "AES-256";
            default:
                throw new RuntimeException("Mechanism not supported");
        }
    }
    return alg;
}

/**
     * Implementation of DES encryption
     */
    public static String encrypt(String method, byte[] key, byte[] vector, byte[] message) throws Exception {

//        generate Key
        byte[] keyBytes = generateKey(key, KEY_LEGHT);
        SecretKeySpec keySpec = new SecretKeySpec(keyBytes, method);

//        generate Initialization Vector
        byte[] keyBytesIv = generateVector(vector, VECTOR_LEGHT);
        IvParameterSpec ivSpec = new IvParameterSpec(keyBytesIv);

        Cipher cipher = Cipher.getInstance(method);

        if(hasInitVector(method)){
            cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
        } else {
            cipher.init(Cipher.ENCRYPT_MODE, keySpec);
        }

        byte[] cipherText = cipher.doFinal(message);

        return Base64.encodeToString(cipherText, Base64.DEFAULT);
    }

public static void main(String[] args) throws Exception {
    try {
        byte master[] = {
                0, 1, 2, 3, 4
        };
        SecretKey key = new SecretKeySpec(master, "DES");
        Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        throw new RuntimeException("InvalidKeyException not thrown");
    } catch (java.security.InvalidKeyException ike) {
        ike.printStackTrace();
        if (ike.getMessage() != null) {
            out.println("Status -- Passed");
        } else {
            throw new RuntimeException("Error message is not expected when"
                    + " InvalidKeyException is thrown");
        }

    }
}

private static PKCS8EncodedKeySpec readPrivateKey(File keyFile, Optional<String> keyPassword)
        throws IOException, GeneralSecurityException
{
    String content = Files.toString(keyFile, US_ASCII);

    Matcher matcher = KEY_PATTERN.matcher(content);
    if (!matcher.find()) {
        throw new KeyStoreException("found no private key: " + keyFile);
    }
    byte[] encodedKey = base64Decode(matcher.group(1));

    if (!keyPassword.isPresent()) {
        return new PKCS8EncodedKeySpec(encodedKey);
    }

    EncryptedPrivateKeyInfo encryptedPrivateKeyInfo = new EncryptedPrivateKeyInfo(encodedKey);
    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(encryptedPrivateKeyInfo.getAlgName());
    SecretKey secretKey = keyFactory.generateSecret(new PBEKeySpec(keyPassword.get().toCharArray()));

    Cipher cipher = Cipher.getInstance(encryptedPrivateKeyInfo.getAlgName());
    cipher.init(DECRYPT_MODE, secretKey, encryptedPrivateKeyInfo.getAlgParameters());

    return encryptedPrivateKeyInfo.getKeySpec(cipher);
}

public InputDecryptor getValueDecryptor(AlgorithmIdentifier keyEncryptionAlgorithm, final AlgorithmIdentifier contentEncryptionAlgorithm, byte[] encryptedContentEncryptionKey)
    throws CRMFException
{
    Key secretKey = extractSecretKey(keyEncryptionAlgorithm, contentEncryptionAlgorithm, encryptedContentEncryptionKey);

    final Cipher dataCipher = helper.createContentCipher(secretKey, contentEncryptionAlgorithm);

    return new InputDecryptor()
    {
        public AlgorithmIdentifier getAlgorithmIdentifier()
        {
            return contentEncryptionAlgorithm;
        }

        public InputStream getInputStream(InputStream dataIn)
        {
            return new CipherInputStream(dataIn, dataCipher);
        }
    };
}

/**
 * DES算法，加密
 *
 * @param data
 *         待加密字符串
 * @param key
 *            加密私钥，长度不能够小于8位
 * @return 加密后的字节数组，一般结合Base64编码使用

 * @throws Exception
 */
public static String encode(String key, String data) {
    if (data == null)
        return null;
    try {
        DESKeySpec dks = new DESKeySpec(key.getBytes());
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        // key的长度不能够小于8位字节
        Key secretKey = keyFactory.generateSecret(dks);
        Cipher cipher = Cipher.getInstance(ALGORITHM_DES);
        IvParameterSpec iv = new IvParameterSpec("12345678".getBytes());
        AlgorithmParameterSpec paramSpec = iv;
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, paramSpec);
        byte[] bytes = cipher.doFinal(data.getBytes());
        return byte2String(bytes);
    } catch (Exception e) {
        e.printStackTrace();
        return data;
    }
}

/**
 * Creates the Cipher Instance.
 */
private static Cipher createTheCipherInstance(int opMode, String transformation, Key key)
{
    try
    {
        Cipher cipher = Cipher.getInstance(transformation);
        cipher.init(opMode, key);
        return cipher;
    }
    catch (InvalidKeyException invalidkeyexception)
    {
        invalidkeyexception.printStackTrace();
    }
    catch (NoSuchAlgorithmException nosuchalgorithmexception)
    {
        nosuchalgorithmexception.printStackTrace();
    }
    catch (NoSuchPaddingException nosuchpaddingexception)
    {
        nosuchpaddingexception.printStackTrace();
    }

    LOGGER.error("Cipher creation failed!");
    return null;
}

/**
     * Implementation of PBE encryption
     */
    public static String encrypt(Method method, byte[] key, KeySize keySize, byte[] vector, byte[] message) throws Exception{

//        generate Key
        byte[] keyBytes = generateKey(key, keySize.getSize());
        SecretKeySpec keySpec = new SecretKeySpec(keyBytes , method.getMethod());

//        generate Initialization Vector
        byte[] keyBytesIv = generateVector(vector, VECTOR_LEGHT);
        IvParameterSpec ivSpec = new IvParameterSpec(keyBytesIv);

        Cipher cipher = Cipher.getInstance(method.getMethod());

        if(hasInitVector(method.getMethod())){
            cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
        } else {
            cipher.init(Cipher.ENCRYPT_MODE, keySpec);
        }

        byte[] cipherText = cipher.doFinal(message);

        return Base64.encodeToString(cipherText, Base64.DEFAULT);
    }

/**
 * Decrypts a message with a private key
 * @param chiffrat byte Array encrypted text to decrypt
 * @param pk PrivateKey Key for the decryption
 * @return String Decrypted message
 */
public String decrypt(byte[] chiffrat, PrivateKey pk) {
    if(!isMessageLengthValid(chiffrat)) {
        StaticStandard.logErr("Chiffrat must not be longer than " + maximum_message_length + " bytes");
        return null;
    }
    try {
        final Cipher cipher = Cipher.getInstance(RSA);
        cipher.init(Cipher.DECRYPT_MODE, pk);
        String message = new String(cipher.doFinal(chiffrat));
        return message;
    } catch (Exception ex) {
        StaticStandard.logErr("Error while decrypting message: " + ex);
        return null;
    }
}

private static SignatureSpi newInstance(Service s)
        throws NoSuchAlgorithmException {
    if (s.getType().equals("Cipher")) {
        // must be NONEwithRSA
        try {
            Cipher c = Cipher.getInstance(RSA_CIPHER, s.getProvider());
            return new CipherAdapter(c);
        } catch (NoSuchPaddingException e) {
            throw new NoSuchAlgorithmException(e);
        }
    } else {
        Object o = s.newInstance(null);
        if (o instanceof SignatureSpi == false) {
            throw new NoSuchAlgorithmException
                ("Not a SignatureSpi: " + o.getClass().getName());
        }
        return (SignatureSpi)o;
    }
}

/**
 * DES
 * @param src
 * @param password
 * @return
 */
public static byte[] decrypt(byte []src, String password) {
    try {
        // DES算法要求有一个可信任的随机数源
        SecureRandom random = new SecureRandom();
        // 创建一个DESKeySpec对象
        DESKeySpec desKey = new DESKeySpec(password.getBytes());
        // 创建一个密匙工厂
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        // 将DESKeySpec对象转换成SecretKey对象
        SecretKey securekey = keyFactory.generateSecret(desKey);
        // Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance("DES");
        // 用密匙初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, securekey, random);
        // 真正开始解密操作
        return cipher.doFinal(src);
    } catch (Throwable e) {
        e.printStackTrace();
    }

    return null;
}

@Override
public Serializable sealObject(String keyAlias, AlgorithmParameters params, Serializable input)
{
    if (input == null)
    {
        return null;
    }
    Cipher cipher = getCipher(keyAlias, params, Cipher.ENCRYPT_MODE);
    if (cipher == null)
    {
        return input;
    }
    try
    {
        return new SealedObject(input, cipher);
    }
    catch (Exception e)
    {
        throw new AlfrescoRuntimeException("Failed to seal object", e);
    }
}

public static void main(String[] args) throws Exception {
    Locale reservedLocale = Locale.getDefault();
    try {
        Locale.setDefault(new Locale("tr", "TR"));

        System.out.println(Cipher.getInstance("RSA/ECB/PKCS1Padding"));
        System.out.println(Cipher.getInstance("RSA/ECB/PKCS1PADDING"));
        System.out.println(Cipher.getInstance("rsa/ecb/pkcs1padding"));
        System.out.println(Cipher.getInstance("Blowfish"));
        System.out.println(Cipher.getInstance("blowfish"));
        System.out.println(Cipher.getInstance("BLOWFISH"));

        System.out.println("OK");
    } finally {
        // restore the default locale
        Locale.setDefault(reservedLocale);
    }
}

/**
 * Seals the given cleartext key, using the password provided at
 * construction time
 */
SealedObject seal(Key key)
    throws Exception
{
    // create a random salt (8 bytes)
    byte[] salt = new byte[8];
    SunJCE.getRandom().nextBytes(salt);

    // create PBE parameters from salt and iteration count
    PBEParameterSpec pbeSpec = new PBEParameterSpec(salt, 20);

    // create PBE key from password
    PBEKeySpec pbeKeySpec = new PBEKeySpec(this.password);
    SecretKey sKey = new PBEKey(pbeKeySpec, "PBEWithMD5AndTripleDES");
    pbeKeySpec.clearPassword();

    // seal key
    Cipher cipher;

    PBEWithMD5AndTripleDESCipher cipherSpi;
    cipherSpi = new PBEWithMD5AndTripleDESCipher();
    cipher = new CipherForKeyProtector(cipherSpi, SunJCE.getInstance(),
                                       "PBEWithMD5AndTripleDES");
    cipher.init(Cipher.ENCRYPT_MODE, sKey, pbeSpec);
    return new SealedObjectForKeyProtector(key, cipher);
}

private String decryptCredential(final String cred) {
    try {
        final PrivateKeyFactoryBean factory = new PrivateKeyFactoryBean();
        factory.setAlgorithm("RSA");
        factory.setLocation(new ClassPathResource("RSA1024Private.p8"));
        factory.setSingleton(false);
        final PrivateKey privateKey = factory.getObject();

        logger.debug("Initializing cipher based on [{}]", privateKey.getAlgorithm());
        final Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());

        logger.debug("Decoding value [{}]", cred);
        final byte[] cred64 = CompressionUtils.decodeBase64ToByteArray(cred);

        logger.debug("Initializing decrypt-mode via private key [{}]", privateKey.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);

        final byte[] cipherData = cipher.doFinal(cred64);
        return new String(cipherData);
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }
}

/**
 * Decrypt DATA
 * @param encryptedBase64
 * @return
 */
public static String decryptAES_ECB_PKCS5Padding(String encryptedBase64) {
    try {
        byte[] IV = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
        IvParameterSpec iv = new IvParameterSpec(IV);

        byte[] key = {
                1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1
        };
        SecretKeySpec skeySpec = new SecretKeySpec(key, "AES");

        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, skeySpec);

        Base64 b64 = new Base64();
        byte[] encryptedBase64Bytes = encryptedBase64.getBytes();
        byte[] original = cipher.doFinal(b64.decodeBase64(encryptedBase64Bytes));

        return new String(original);
    } catch (Exception ex) {
        ex.printStackTrace();
    }

    return null;
}

public PBKDF2(String algo, String passwd)
        throws InvalidKeySpecException, NoSuchAlgorithmException,
        NoSuchPaddingException {
    super(algo, PBKDF2_SALT_SIZE);

    ci = Cipher.getInstance(CIPHER_TRANSFORMATION);

    PBEKeySpec pbeKeySpec = new PBEKeySpec(passwd.toCharArray(), getSalt(),
            ITERATION_COUNT, CIPHER_KEY_SIZE);
    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(algo);
    key = keyFactory.generateSecret(pbeKeySpec);
}

private static String getDefaultProviderKey() {
    try {
        return "aes/gcm/" + (Cipher.getMaxAllowedKeyLength("AES") > 128 ? "256" : "128");
    } catch (NoSuchAlgorithmException e) {
        return "aes/gcm/128";
    }
}

/**
 * The private key corresponding to the contract certificate is to be decrypted by 
 * the receiver (EVCC) using the session key derived in the ECDH protocol.
 * Applies the algorithm AES-CBC-128 according to NIST Special Publication 800-38A.
 * The initialization vector IV shall be read from the 16 most significant bytes of the 
 * ContractSignatureEncryptedPrivateKey field.
 * 
 * @param sessionKey The symmetric session key with which the encrypted private key is to be decrypted
 * @param encryptedKeyWithIV The encrypted private key of the contract certificate given as a byte array
 *                           whose first 16 byte hold the initialization vector
 * @return The decrypted private key of the contract certificate
 */
private static ECPrivateKey decryptPrivateKey(SecretKey sessionKey, byte[] encryptedKeyWithIV) {
    byte[] initVector = new byte[16];
    byte[] encryptedKey = null;

    try {
        // Get the first 16 bytes of the encrypted private key which hold the IV

        encryptedKey = new byte[encryptedKeyWithIV.length - 16];
        System.arraycopy(encryptedKeyWithIV, 0, initVector, 0, 16);
        System.arraycopy(encryptedKeyWithIV, 16, encryptedKey, 0, encryptedKeyWithIV.length - 16);

        IvParameterSpec ivParamSpec = new IvParameterSpec(initVector);
        Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");

        /*
         * You must have the Java Cryptography Extension (JCE) Unlimited Strength 
         * Jurisdiction Policy Files 8 installed, otherwise this cipher.init call will yield a
         * "java.security.InvalidKeyException: Illegal key size"
         */
        cipher.init(Cipher.DECRYPT_MODE, sessionKey, ivParamSpec);
        byte[] decrypted = cipher.doFinal(encryptedKey);

        return getPrivateKey(decrypted);
    } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException |
            InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException |
            NegativeArraySizeException e) {
        getLogger().error(e.getClass().getSimpleName() + " occurred while trying to decrypt private key" +
                  "\nSession key (" + (sessionKey != null ? sessionKey.getEncoded().length : 0) + " bytes): " +
                  ByteUtils.toHexString(sessionKey.getEncoded()) +
                  "\nEncrypted key (" + (encryptedKey != null ? encryptedKey.length : 0) + " bytes): " +
                  ByteUtils.toHexString(encryptedKey) +
                  "\nEncrypted key with IV (" + (encryptedKeyWithIV != null ? encryptedKeyWithIV.length : 0) + " bytes): " +
                  ByteUtils.toHexString(encryptedKey), e);
    } 

    return null;
}

/**
* decripta il messaggio
* 
* @param message messaggio per la decritptazione
* @return stringa decriptata
* @throws Exception 
*/
 private String decrypt(String message) throws Exception {
   byte[] bytesrc = convertHexString(message);
   Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
   DESKeySpec desKeySpec = new DESKeySpec(key.getBytes("UTF-8"));
   SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
   SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
   IvParameterSpec iv = new IvParameterSpec(key.getBytes("UTF-8"));

   cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
   byte[] retByte = cipher.doFinal(bytesrc);
   return new String(retByte);
 }

/**
 * 公钥加密
 * 
 * @param data 待加密数据
 * @param key 公钥
 * @return byte[] 加密数据
 * @throws Exception
 */
public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception {
    // 取得公钥
    X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
    // 对数据加密
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, publicKey);
    return cipher.doFinal(data);
}

public static byte[] a(String str, byte[] bArr) {
    byte[] bArr2 = null;
    try {
        Key secretKeySpec = new SecretKeySpec(str.getBytes(), "DESede");
        AlgorithmParameterSpec ivParameterSpec = new IvParameterSpec(new byte[8]);
        Cipher instance = Cipher.getInstance(a);
        instance.init(1, secretKeySpec, ivParameterSpec);
        bArr2 = instance.doFinal(bArr);
    } catch (Exception e) {
    }
    return bArr2;
}

private byte[] encrypt(byte[] plainText, byte[] key, byte[] initialVector)
        throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
        InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
    Cipher cipher = Cipher.getInstance(cipherTransformation);
    SecretKeySpec secretKeySpec = new SecretKeySpec(key, aesEncryptionAlgorithm);
    IvParameterSpec ivParameterSpec = new IvParameterSpec(initialVector);
    cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);
    plainText = cipher.doFinal(plainText);
    return plainText;
}

/**
 * DES加密模板
 *
 * @param data           数据
 * @param key            秘钥
 * @param algorithm      加密算法
 * @param transformation 转变
 * @param isEncrypt      {@code true}: 加密 {@code false}: 解密
 * @return 密文或者明文，适用于DES，3DES，AES
 */
public static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt) {
    if (data == null || data.length == 0 || key == null || key.length == 0) return null;
    try {
        SecretKeySpec keySpec = new SecretKeySpec(key, algorithm);
        Cipher cipher = Cipher.getInstance(transformation);
        SecureRandom random = new SecureRandom();
        cipher.init(isEncrypt ? Cipher.ENCRYPT_MODE : Cipher.DECRYPT_MODE, keySpec, random);
        return cipher.doFinal(data);
    } catch (Throwable e) {
        e.printStackTrace();
        return null;
    }
}

private void combination_16(List<byte[]> results, int mode, byte[] AAD,
        byte[] plainText, AlgorithmParameters params) throws Exception {
    Cipher c = createCipher(mode, params);

    // prepare ByteBuffer to test
    ByteBuffer buf = ByteBuffer.allocateDirect(AAD.length);
    buf.put(AAD);
    buf.position(0);
    buf.limit(AAD.length);
    c.updateAAD(buf);

    // prepare empty ByteBuffer
    ByteBuffer emptyBuf = ByteBuffer.allocateDirect(0);
    emptyBuf.put(new byte[0]);
    c.updateAAD(emptyBuf);

    // prepare buffers to encrypt/decrypt
    ByteBuffer in = ByteBuffer.allocateDirect(plainText.length);
    in.put(plainText);
    in.position(0);
    in.limit(plainText.length);
    ByteBuffer output = ByteBuffer.allocateDirect(
            c.getOutputSize(in.limit()));
    output.position(0);
    output.limit(c.getOutputSize(in.limit()));

    // process input text with an empty buffer
    c.update(in, output);
    ByteBuffer emptyBuf2 = ByteBuffer.allocate(0);
    emptyBuf2.put(new byte[0]);
    c.doFinal(emptyBuf2, output);
    int resultSize = output.position();
    byte[] result16 = new byte[resultSize];
    output.position(0);
    output.limit(resultSize);
    output.get(result16, 0, resultSize);
    results.add(result16);
}

private void initCiphers(String algo, SecretKey key,
        AlgorithmParameterSpec aps) throws NoSuchAlgorithmException,
        NoSuchPaddingException, InvalidKeyException,
        InvalidAlgorithmParameterException {
    Provider provider = Security.getProvider("SunJCE");
    if (provider == null) {
        throw new RuntimeException("SunJCE provider does not exist.");
    }
    Cipher ci1 = Cipher.getInstance(algo, provider);
    ci1.init(Cipher.ENCRYPT_MODE, key, aps);
    pair[0] = ci1;
    Cipher ci2 = Cipher.getInstance(algo, provider);
    ci2.init(Cipher.DECRYPT_MODE, key, aps);
    pair[1] = ci2;
}

private static void testEncryptDecrypt(OAEPParameterSpec spec,
        int dataLength) throws Exception {

    System.out.print("Testing OAEP with hash ");
    if (spec != null) {
        System.out.print(spec.getDigestAlgorithm() + " and MGF " +
            ((MGF1ParameterSpec)spec.getMGFParameters()).
                getDigestAlgorithm());
    } else {
        System.out.print("Default");
    }
    System.out.println(", " + dataLength + " bytes");

    Cipher c = Cipher.getInstance("RSA/ECB/OAEPPadding", cp);
    if (spec != null) {
        c.init(Cipher.ENCRYPT_MODE, publicKey, spec);
    } else {
        c.init(Cipher.ENCRYPT_MODE, publicKey);
    }

    byte[] data = new byte[dataLength];
    byte[] enc = c.doFinal(data);
    if (spec != null) {
        c.init(Cipher.DECRYPT_MODE, privateKey, spec);
    } else {
        c.init(Cipher.DECRYPT_MODE, privateKey);
    }
    byte[] dec = c.doFinal(enc);
    if (Arrays.equals(data, dec) == false) {
        throw new Exception("Data does not match");
    }
}

static String encrypt(String data) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
    Key key = generateKey();
    Cipher cipher = Cipher.getInstance(algorithm);
    cipher.init(Cipher.ENCRYPT_MODE, key);
    byte[] encryptedData = cipher.doFinal(data.getBytes());
    return (encodeToString(encryptedData, 16));
}

protected String encrypt(String value ) {

        try {
            final byte[] bytes = value!=null ? value.getBytes(UTF8) : new byte[0];
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
            SecretKey key = keyFactory.generateSecret(new PBEKeySpec(SEKRIT));
            Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
            pbeCipher.init(Cipher.ENCRYPT_MODE, key, new PBEParameterSpec(Secure.getString(context.getContentResolver(), Secure.ANDROID_ID).getBytes(UTF8), 20));
            return new String(Base64.encode(pbeCipher.doFinal(bytes), Base64.NO_WRAP),UTF8);
        } catch( Exception e ) {
            throw new RuntimeException(e);
        }

    }

private void combination_16(List<byte[]> results, int mode, byte[] AAD,
        byte[] plainText, AlgorithmParameters params) throws Exception {
    Cipher c = createCipher(mode, params);

    // prepare ByteBuffer to test
    ByteBuffer buf = ByteBuffer.allocateDirect(AAD.length);
    buf.put(AAD);
    buf.position(0);
    buf.limit(AAD.length);
    c.updateAAD(buf);

    // prepare empty ByteBuffer
    ByteBuffer emptyBuf = ByteBuffer.allocateDirect(0);
    emptyBuf.put(new byte[0]);
    c.updateAAD(emptyBuf);

    // prepare buffers to encrypt/decrypt
    ByteBuffer in = ByteBuffer.allocateDirect(plainText.length);
    in.put(plainText);
    in.position(0);
    in.limit(plainText.length);
    ByteBuffer output = ByteBuffer.allocateDirect(
            c.getOutputSize(in.limit()));
    output.position(0);
    output.limit(c.getOutputSize(in.limit()));

    // process input text with an empty buffer
    c.update(in, output);
    ByteBuffer emptyBuf2 = ByteBuffer.allocate(0);
    emptyBuf2.put(new byte[0]);
    c.doFinal(emptyBuf2, output);
    int resultSize = output.position();
    byte[] result16 = new byte[resultSize];
    output.position(0);
    output.limit(resultSize);
    output.get(result16, 0, resultSize);
    results.add(result16);
}

/**
 * Decrypts the cryptoKey of the user with the given derived key
 *
 * @param derivedKey derived key of the user
 * @param user       the user for which the cryptoKey should be decrypted
 * @return the decrypted cryptoKey
 * @throws GeneralSecurityException in case of an error
 */
private static SecretKey decryptCryptoKey(byte[] derivedKey, User user) throws GeneralSecurityException {

    Cipher cipher = Cipher.getInstance(AES_CTR_NO_PADDING, BOUNCY_CASTLE);
    SecretKey derivedKeySecretKey = new SecretKeySpec(derivedKey, 0, derivedKey.length, AES);
    cipher.init(Cipher.DECRYPT_MODE, derivedKeySecretKey, new IvParameterSpec(user.getCryptoKeyIV()));
    byte[] encryptionKeyDecrypted = cipher.doFinal(user.getCryptoKey());

    return new SecretKeySpec(encryptionKeyDecrypted, 0, encryptionKeyDecrypted.length, AES);
}

/**
 * Encrypts the plaintext using password. In case of exception, returns null.
 */
// VisibleForTesting
public static String encryptInternal(String password, String plaintext) {
  try {
    return Arrays.toString(performCryptOperation(Cipher.ENCRYPT_MODE, password,
        plaintext.getBytes("UTF-8")));
  } catch (UnsupportedEncodingException e) {
    Log.w("Unable to encrypt " + plaintext, e);
    return null;
  }
}

private static boolean check() {
    try {
        Cipher.getInstance(
                ContentCryptoScheme.AES_GCM.getCipherAlgorithm(),
                BOUNCY_CASTLE_PROVIDER);
        return true;
    } catch (Exception e) {
        return false;
    }
}