Java 类javax.crypto.spec.IvParameterSpec 实例源码

private static String aesEncrypt(String content, String aesKey, String charset)
                                                                               throws AlipayApiException {

    try {
        Cipher cipher = Cipher.getInstance(AES_CBC_PCK_ALG);

        IvParameterSpec iv = new IvParameterSpec(AES_IV);
        cipher.init(Cipher.ENCRYPT_MODE,
            new SecretKeySpec(Base64.decodeBase64(aesKey.getBytes()), AES_ALG), iv);

        byte[] encryptBytes = cipher.doFinal(content.getBytes(charset));
        return new String(Base64.encodeBase64(encryptBytes));
    } catch (Exception e) {
        throw new AlipayApiException("AES加密失败：Aescontent = " + content + "; charset = "
                                     + charset, e);
    }

}

/**
 * Decipher a text.
 * 
 * @param textToDecipher
 * @param key
 * @throws GeneralSecurityException
 * @throws IOException
 */
private byte[] decipherText(byte[] textToDecipher, SecretKeySpec key) throws GeneralSecurityException, IOException {

    try {
        Cipher dcipher = Cipher.getInstance(AES_MODE);

        // Read random initialization vector.
        final byte[] iv = Arrays.copyOfRange(textToDecipher, 0, BLOCK_SIZE);
        final IvParameterSpec ivSpec = new IvParameterSpec(iv);

        // Configure the cipher with the key and the iv.
        dcipher.init(Cipher.DECRYPT_MODE, key, ivSpec);
        final byte[] textToDecipherWithoutIv = Arrays.copyOfRange(textToDecipher, BLOCK_SIZE,
                textToDecipher.length);

        final byte[] outputBytes = dcipher.doFinal(textToDecipherWithoutIv);
        return outputBytes;

    } catch (final GeneralSecurityException exc) {
        throw exc;
    }
}

public Encryption()
{
    KeyPair rsaKeyPair =
        getRsaKeyPair(WurstFolders.RSA.resolve("wurst_rsa.pub"),
            WurstFolders.RSA.resolve("wurst_rsa"));

    SecretKey aesKey =
        getAesKey(WurstFolders.MAIN.resolve("key"), rsaKeyPair);

    try
    {
        encryptCipher = Cipher.getInstance("AES/CFB8/NoPadding");
        encryptCipher.init(Cipher.ENCRYPT_MODE, aesKey,
            new IvParameterSpec(aesKey.getEncoded()));

        decryptCipher = Cipher.getInstance("AES/CFB8/NoPadding");
        decryptCipher.init(Cipher.DECRYPT_MODE, aesKey,
            new IvParameterSpec(aesKey.getEncoded()));

    }catch(GeneralSecurityException e)
    {
        throw new ReportedException(
            CrashReport.makeCrashReport(e, "Creating AES ciphers"));
    }
}

private byte[] encryptAesCtr(byte[] passwordBytes, byte[] iv) throws EncryptionException {
    try {
        SecretKey key = new SecretKeySpec(DatatypeConverter.parseHexBinary(keyProvider.getKeyHex()), "AES");
        IvParameterSpec ivSpec = new IvParameterSpec(iv);
        Cipher cipher = Cipher.getInstance(AESCTR_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);
        byte[] result = cipher.doFinal(DatatypeConverter.parseHexBinary(DatatypeConverter.printHexBinary(passwordBytes)));

        Arrays.fill(passwordBytes, (byte)0);

        return result;
    } catch (Exception ex) {
        LOG.error("Error encrypting plainText", ex);
        throw new EncryptionException("Failed to encrypt cipher with AES-CTR", ex);
    }
}

static String checkKey(String cipherKey){
    String ret = null;
    try {
        SecretKeySpec Testkey = new SecretKeySpec(getUTF8Bytes(cipherKey),"AES");
        IvParameterSpec TestIv = new IvParameterSpec(getUTF8Bytes("1234567890123456"));
        Properties properties = new Properties();
    properties.setProperty(CryptoCipherFactory.CLASSES_KEY,
            CipherProvider.OPENSSL.getClassName());
        CryptoCipher test = Utils.getCipherInstance("AES/CBC/PKCS5Padding", properties);
        test.init(Cipher.ENCRYPT_MODE, Testkey, TestIv);
        test.close();
    }catch (Throwable e) {
         ret = e.getMessage();
    }
    return ret;
}

private String fromEncryptedBytes(byte[] message) throws Exception {

        final MessageDigest md = MessageDigest.getInstance("md5");
        final byte[] digestOfPassword = md.digest("HG58YZ3CR9".getBytes("UTF-8"));
        final byte[] keyBytes = Arrays.copyOf(digestOfPassword, 24);
        for (int j = 0, k = 16; j < 8;) {
            keyBytes[k++] = keyBytes[j++];
        }

        final SecretKey key = new SecretKeySpec(keyBytes, "DESede");
        final IvParameterSpec iv = new IvParameterSpec(new byte[8]);
        final Cipher decipher = Cipher.getInstance("DESede/CBC/PKCS5Padding");
        decipher.init(Cipher.DECRYPT_MODE, key, iv);

        final byte[] plainText = decipher.doFinal(message);

        return new String(plainText, "UTF-8");
    }

public static String decrypt(String str) {
    if (str == null) return null;
    Cipher cipher;
    try {
        cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, keySpec,
                new IvParameterSpec(ips.getBytes("UTF-8")));

        byte[] byteStr = Base64.decodeBase64(str.getBytes());
        String Str = new String(cipher.doFinal(byteStr), "UTF-8");

        return Str;
    } catch (NoSuchAlgorithmException | NoSuchPaddingException
            | InvalidKeyException | InvalidAlgorithmParameterException
            | IllegalBlockSizeException | BadPaddingException
            | UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    return null;
}

@Override
protected void engineInit(int opmode, Key key,
        AlgorithmParameters params, SecureRandom random)
    throws InvalidKeyException, InvalidAlgorithmParameterException {

    AlgorithmParameterSpec spec;

    try {

        spec = params.getParameterSpec(IvParameterSpec.class);

        if (debug.DEBUG)
            log("initialized with key and AlgorithmParameters");

    } catch (InvalidParameterSpecException ipe) {
        throw new InvalidAlgorithmParameterException(ipe);
    }

    wolfCryptCipherInit(opmode, key, spec, random);
}

@Test
public void testEncryptionHelper() throws NoSuchPaddingException, BadPaddingException, InvalidKeyException, NoSuchAlgorithmException,
        IllegalBlockSizeException, UnsupportedEncodingException, InvalidAlgorithmParameterException, DecoderException {

    // https://golang.org/src/crypto/cipher/gcm_test.go
    String[][] testCases = new String[][]{
            new String[]{"11754cd72aec309bf52f7687212e8957", "3c819d9a9bed087615030b65", "", "250327c674aaf477aef2675748cf6971"},
            new String[]{"ca47248ac0b6f8372a97ac43508308ed", "ffd2b598feabc9019262d2be", "", "60d20404af527d248d893ae495707d1a"},
            new String[]{"7fddb57453c241d03efbed3ac44e371c", "ee283a3fc75575e33efd4887", "d5de42b461646c255c87bd2962d3b9a2", "2ccda4a5415cb91e135c2a0f78c9b2fdb36d1df9b9d5e596f83e8b7f52971cb3"},
            new String[]{"ab72c77b97cb5fe9a382d9fe81ffdbed", "54cc7dc2c37ec006bcc6d1da", "007c5e5b3e59df24a7c355584fc1518d", "0e1bde206a07a9c2c1b65300f8c649972b4401346697138c7a4891ee59867d0c"},
            new String[]{"feffe9928665731c6d6a8f9467308308", "cafebabefacedbaddecaf888", "d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532fcf0e2449a6b525b16aedf5aa0de657ba637b391aafd255",
                    "42831ec2217774244b7221b784d0d49ce3aa212f2c02a4e035c17e2329aca12e21d514b25466931c7d8f6a5aac84aa051ba30b396a0aac973d58e091473f59854d5c2af327cd64a62cf35abd2ba6fab4"},
    };
    for (String[] testCase : testCases) {

        SecretKeySpec k = new SecretKeySpec(new Hex().decode(testCase[0].getBytes()), "AES");
        IvParameterSpec iv = new IvParameterSpec(new Hex().decode(testCase[1].getBytes()));

        byte[] cipherTExt = EncryptionHelper.encrypt(k, iv, new Hex().decode(testCase[2].getBytes()));
        String cipher = new String(new Hex().encode(cipherTExt));

        assertEquals(cipher, testCase[3]);
        assertEquals(testCase[2], new String(new Hex().encode(EncryptionHelper.decrypt(k, iv, cipherTExt))));
    }
}

/**
     * Implementation of AES decryption
     */
    public static String decrypt(String method, byte[] key, Key keyType, byte[] vector, byte[] message) throws Exception       {

//        generate Key
        byte[] keyBytes = generateKey(key, keyType.type);
        SecretKeySpec keySpec = new SecretKeySpec(keyBytes, Method.AES.getMethod());

//        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.DECRYPT_MODE, keySpec, ivSpec);
        } else {
            cipher.init(Cipher.DECRYPT_MODE, keySpec);
        }

        byte[] cipherText = cipher.doFinal(Base64.decode(message, Base64.DEFAULT));

        return new String(cipherText);
    }

public static String encrypt(String decryptedString, String password) {
    try {
        // build the initialization vector (randomly).
        SecureRandom random = new SecureRandom();
        byte initialVector[] = new byte[16];
        //generate random 16 byte IV AES is always 16bytes
        random.nextBytes(initialVector);
        IvParameterSpec ivspec = new IvParameterSpec(initialVector);
        SecretKeySpec skeySpec = new SecretKeySpec(password.getBytes("UTF-8"), "AES");
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec, ivspec);
        byte[] encrypted = cipher.doFinal(decryptedString.getBytes());
        byte[] encryptedWithIV = new byte[encrypted.length + initialVector.length];
        System.arraycopy(encrypted, 0, encryptedWithIV, 0, encrypted.length);
        System.arraycopy(initialVector, 0, encryptedWithIV, encrypted.length, initialVector.length);
        return Base64.encodeBase64String(encryptedWithIV);
    } catch (Exception ex) {
        Logger.getLogger(Encryption.class.getName()).log(Level.SEVERE, null, ex);
        return "Error";
    }
}

/**
 * 加密
 * 
 * @param text 要加密的字符串
 * @param iv 初始化向量参数
 * @param password 密钥
 * @return
 */
public static String AESDecrypt(String text, String iv, String password, String mode) throws Exception
{
    Cipher cipher = Cipher.getInstance(mode);

    byte[] keyBytes = new byte[16];
    byte[] b = password.getBytes("UTF-8");
    int len = b.length;
    if (len > keyBytes.length)
        len = keyBytes.length;
    System.arraycopy(b, 0, keyBytes, 0, len);
    SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES");
    IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes("UTF-8"));
    cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);

    byte[] results = cipher.doFinal(Base64.decode(text));
    return new String(results, "UTF-8");
}

/**
     * Implementation of Blowfish decryption
     */
    public static String decrypt(String method, byte[] key, int keySize, byte[] vector, byte[] message) throws Exception {

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

//        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.DECRYPT_MODE, keySpec, ivSpec);
        } else {
            cipher.init(Cipher.DECRYPT_MODE, keySpec);
        }

        byte[] cipherText = cipher.doFinal(Base64.decode(message, Base64.DEFAULT));

        return new String(cipherText);
    }

public static String encrypt(String str) {
    if (str == null) return null;
    Cipher cipher;
    try {
        cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, keySpec,
                new IvParameterSpec(ips.getBytes("UTF-8")));

        byte[] encrypted = cipher.doFinal(str.getBytes("UTF-8"));
        String Str = new String(Base64.encodeBase64(encrypted));
        return Str;
    } catch (NoSuchAlgorithmException | NoSuchPaddingException
            | InvalidKeyException | InvalidAlgorithmParameterException
            | IllegalBlockSizeException | BadPaddingException
            | UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    return null;
}

private void doPairVerify2(Socket socket, byte[] pairVerify1Response, byte[] randomPrivateKey, byte[] randomPublicKey) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IOException, InvalidAlgorithmParameterException, SignatureException {
    byte[] atvPublicKey = Arrays.copyOfRange(pairVerify1Response, 0, 32);
    byte[] sharedSecret = new byte[32];
    Curve25519.curve(sharedSecret, randomPrivateKey, atvPublicKey);

    MessageDigest sha512Digest = MessageDigest.getInstance("SHA-512");
    sha512Digest.update("Pair-Verify-AES-Key".getBytes(StandardCharsets.UTF_8));
    sha512Digest.update(sharedSecret);
    byte[] sharedSecretSha512AesKey = Arrays.copyOfRange(sha512Digest.digest(), 0, 16);

    sha512Digest.update("Pair-Verify-AES-IV".getBytes(StandardCharsets.UTF_8));
    sha512Digest.update(sharedSecret);
    byte[] sharedSecretSha512AesIV = Arrays.copyOfRange(sha512Digest.digest(), 0, 16);

    Cipher aesCtr128Encrypt = Cipher.getInstance("AES/CTR/NoPadding");
    aesCtr128Encrypt.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(sharedSecretSha512AesKey, "AES"), new IvParameterSpec(sharedSecretSha512AesIV));

    aesCtr128Encrypt.update(Arrays.copyOfRange(pairVerify1Response, 32, pairVerify1Response.length));

    EdDSAEngine edDSAEngine = new EdDSAEngine();
    edDSAEngine.initSign(authKey);

    byte[] signature = aesCtr128Encrypt.update(edDSAEngine.signOneShot(AuthUtils.concatByteArrays(randomPublicKey, atvPublicKey)));

    AuthUtils.postData(socket, "/pair-verify", "application/octet-stream", AuthUtils.concatByteArrays(new byte[]{0, 0, 0, 0}, signature));
}

public byte[] encrypt(int version, byte[] data) {
    CryptVersion cryptVersion = cryptVersion(version);
    try {
        int cryptedLength = cryptVersion.encryptedLength.apply(data.length);
        byte[] result = new byte[cryptedLength + cryptVersion.saltLength + 1];
        result[0] = toSignedByte(version);

        byte[] random = urandomBytes(cryptVersion.saltLength);
        IvParameterSpec iv_spec = new IvParameterSpec(random);
        System.arraycopy(random, 0, result, 1, cryptVersion.saltLength);

        Cipher cipher = cipher(cryptVersion.cipher);
        cipher.init(Cipher.ENCRYPT_MODE, cryptVersion.key, iv_spec);
        int len = cipher.doFinal(data, 0, data.length, result, cryptVersion.saltLength + 1);

        if (len < cryptedLength) LOG.info("len was " + len + " instead of " + cryptedLength);

        return result;
    } catch (ShortBufferException | IllegalBlockSizeException | BadPaddingException | InvalidAlgorithmParameterException | InvalidKeyException e) {
        throw new RuntimeException("JCE exception caught while encrypting with version " + version, e);
    }
}

public static String DESDecrypt(String ivString, String keyString, String content) {
    try {
        if (Check.NuNStr(content)) {
            return null;
        }
        IvParameterSpec iv = new IvParameterSpec(ivString.getBytes());
        DESKeySpec dks = new DESKeySpec(keyString.getBytes());
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey key = keyFactory.generateSecret(dks);
        Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, key, iv);
        byte[] result = cipher.doFinal(hexStr2ByteArr(content));
        return new String(result, "utf-8");
    } catch (Exception e) {
        LOGGER.error("ENCRYPT ERROR:"+e);
    }
    return null;
}

/**
 * Encrypt.
 *
 * @param value the value
 * @param hashedKey the hashed key
 * @return the string
 */
protected String encrypt(final String value, final String hashedKey) {
    if (value == null) {
        return null;
    }

    try {
        final Cipher cipher = getCipherObject();
        final byte[] ivValue = generateIV(this.ivSize);
        final IvParameterSpec ivSpec = new IvParameterSpec(ivValue);

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

        final byte[] ciphertext = cipher.doFinal(value.getBytes(Charset.defaultCharset()));
        final byte[] ivCiphertext = new byte[INTEGER_LEN + this.ivSize + ciphertext.length];

        System.arraycopy(int2byte(this.ivSize), 0, ivCiphertext, 0, INTEGER_LEN);
        System.arraycopy(ivValue, 0, ivCiphertext, INTEGER_LEN, this.ivSize);
        System.arraycopy(ciphertext, 0, ivCiphertext, INTEGER_LEN + this.ivSize, ciphertext.length);

        return CompressionUtils.encodeBase64(ivCiphertext);
    } catch(final Exception e) {
        throw new RuntimeException(e);
    }
}

/**
 * 通过String类型的密钥 解密String类型的密文
 *
 * @param content
 * @param key
 * @return
 */
public static String decrypt(String content, String key, IvParameterSpec iv) {
    String decryptedText = null;
    try {
        Cipher cipher = Cipher.getInstance(CipherMode);
        SecretKeySpec keySpec = new SecretKeySpec(Base64.decode(key, Base64.DEFAULT), "AES");
        if (null == iv) {
            cipher.init(Cipher.DECRYPT_MODE, keySpec);
        } else {
            cipher.init(Cipher.DECRYPT_MODE, keySpec, iv);
        }
        byte[] result = cipher.doFinal(Base64.decode(content, Base64.DEFAULT));
        decryptedText = new String(result, "UTF-8");
    } catch (Exception e) {
        e.printStackTrace();
    }
    return decryptedText;
}

/**
 * DES加密
 *
 * @param content
 * @return
 */
public static String DESEncrypt(String ivString, String keyString, String content) {
    try {
        if (Check.NuNStr(content)) {
            return null;
        }
        IvParameterSpec iv = new IvParameterSpec(ivString.getBytes());
        DESKeySpec dks = new DESKeySpec(keyString.getBytes());
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey key = keyFactory.generateSecret(dks);
        Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, key, iv);
        byte[] result = cipher.doFinal(content.getBytes("utf-8"));
        return byteArr2HexStr(result);
    } catch (Exception e) {
        LOGGER.error("ENCRYPT ERROR:"+e);
    }
    return null;
}

/**
 * @param salt an array of random bytes to use for each (un)obfuscation
 * @param applicationId application identifier, e.g. the package name
 * @param deviceId device identifier. Use as many sources as possible to
 *    create this unique identifier.
 */
public AESObfuscator(byte[] salt, String applicationId, String deviceId) {
    try {
        SecretKeyFactory factory = SecretKeyFactory.getInstance(KEYGEN_ALGORITHM);
        KeySpec keySpec =
            new PBEKeySpec((applicationId + deviceId).toCharArray(), salt, 1024, 256);
        SecretKey tmp = factory.generateSecret(keySpec);
        SecretKey secret = new SecretKeySpec(tmp.getEncoded(), "AES");
        mEncryptor = Cipher.getInstance(CIPHER_ALGORITHM);
        mEncryptor.init(Cipher.ENCRYPT_MODE, secret, new IvParameterSpec(IV));
        mDecryptor = Cipher.getInstance(CIPHER_ALGORITHM);
        mDecryptor.init(Cipher.DECRYPT_MODE, secret, new IvParameterSpec(IV));
    } catch (GeneralSecurityException e) {
        // This can't happen on a compatible Android device.
        throw new RuntimeException("Invalid environment", e);
    }
}

/**
 * Creates and initializes a {@link CipherLite} for content
 * encrypt/decryption.
 * 
 * @param cek
 *            content encrypting key
 * @param iv
 *            initialization vector
 * @param cipherMode
 *            such as {@link Cipher#ENCRYPT_MODE}
 * @param securityProvider
 *            optional security provider to be used but only if there is no
 *            specific provider defined for the specified scheme.
 * @return the cipher lite created and initialized.
 */
CipherLite createCipherLite(SecretKey cek, byte[] iv, int cipherMode,
        Provider securityProvider) {
    String specificProvider = getSpecificCipherProvider();
    Cipher cipher;
    try {
        if (specificProvider != null) { // use the specific provider if defined
                cipher = Cipher.getInstance(getCipherAlgorithm(), specificProvider);
        } else if (securityProvider != null) { // use the one optionally specified in the input
            cipher = Cipher.getInstance(getCipherAlgorithm(), securityProvider);
        } else { // use the default provider
            cipher = Cipher.getInstance(getCipherAlgorithm());
        }
        cipher.init(cipherMode, cek, new IvParameterSpec(iv));
        return newCipherLite(cipher, cek, cipherMode);
    } catch (Exception e) {
        throw e instanceof RuntimeException
            ? (RuntimeException) e
            : new SdkClientException(
                "Unable to build cipher: "
                    + e.getMessage()
                    + "\nMake sure you have the JCE unlimited strength policy files installed and "
                    + "configured for your JVM",
                e);
    }
}

/**
 * Descrypt a password using a random key
 * @param key
 * @param secureRandom
 * @param encrypted
 * @return descrypted password
 */
public String decrypt(String key, String secureRandom, String encrypted) {
    try {
        SettingInterface defaultSettingLoader = SettingLoaderFactory.getSettingLoader("default");
        IvParameterSpec ivParam = new IvParameterSpec(secureRandom.getBytes(defaultSettingLoader.getEncoding()));
        SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(defaultSettingLoader.getEncoding()), "AES");

        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
        cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParam);

        byte[] passsword = cipher.doFinal(Base64.decodeBase64(encrypted));

        return new String(passsword);
    } catch (Exception ex) {
        throw new MowerException(WRONG_PASSWORD);
    }
}

/**
 * 加密
 *
 * @param sSrc 加密源
 * @param sKey 加密的key
 * @return 加密后内容
 * @throws Exception
 */
public static String encrypt(String sSrc, String sKey) throws Exception {

    if (sKey == null) {
        //Log.e("Key为空null", "Key为空null");
        return null;
    }
    // 判断Key是否为16位
    if (sKey.length() != 16) {
        //Log.e("\"Key长度不是16位\"", "Key长度不是16位");
        return null;
    }
    byte[] raw = sKey.getBytes();
    SecretKeySpec sKeySpec = new SecretKeySpec(raw, "AESUtil");
    Cipher cipher = Cipher.getInstance("AESUtil/CBC/PKCS5Padding");//"算法/模式/补码方式"
    IvParameterSpec iv = new IvParameterSpec("1234567890123456".getBytes());//使用CBC模式，需要一个向量iv，可增加加密算法的强度
    cipher.init(Cipher.ENCRYPT_MODE, sKeySpec, iv);
    byte[] encrypted = cipher.doFinal(sSrc.getBytes());

    return Base64_2Util.encode(encrypted);//此处使用BASE64做转码功能，同时能起到2次加密的作用。
}

/**
     * Implementation of PBE decryption
     */
    public static String decrypt(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.DECRYPT_MODE, keySpec, ivSpec);
        } else {
            cipher.init(Cipher.DECRYPT_MODE, keySpec);
        }

        byte[] cipherText = cipher.doFinal(Base64.decode(message, Base64.DEFAULT));

        return new String(cipherText);
    }

public static String encryptCbcTemp(String content, String encryptKey)
        throws EncryptException
{
    if (StringUtils.isEmpty(content) || StringUtils.isEmpty(encryptKey))
    {
        return null;
    }

    // 因为加密key必须为16位
    if(encryptKey.length() > 16)
    {
        encryptKey = encryptKey.substring(0, 16);
    }
    else
    {
        int padLength = 16-encryptKey.length();

        for(int i = 0; i < padLength ;i++)
        {
            encryptKey += '0';
        }
    }

    try
    {
        IvParameterSpec zeroIv = new IvParameterSpec(VIPARA.getBytes());
        SecretKeySpec key = new SecretKeySpec(encryptKey.getBytes(), "AES");
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, key, zeroIv);
        byte[] encryptedData = cipher.doFinal(content.getBytes("utf-8"));

        return Base64.encodeBase64String(encryptedData);
    }
    catch (Exception e)
    {
        throw new EncryptException("Failed to encrypt for content: "
                + content + ", encrypt key: " + encryptKey, e);
    }

}

/**
 * DES算法，加密
 *
 * @param data 待加密字符串
 * @param key  加密私钥，长度不能够小于8位
 * @return 加密后的字节数组，一般结合Base64编码使用
 * @throws InvalidAlgorithmParameterException
 * @throws Exception
 */
public static String encrypt(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);
        AlgorithmParameterSpec paramSpec = new IvParameterSpec(IV_PARAMS_BYTES);
        ;
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, paramSpec);
        byte[] bytes = cipher.doFinal(data.getBytes());
        return byte2hex(bytes);
    } catch (Exception e) {
        e.printStackTrace();
        return data;
    }
}

/**
     * AES加密字符串
     *
     * @param content 需要被加密的字符串
     * @return 密文
     */
    public String aesDecrypt(String content) {
        try {

            byte[] encrypted1 = Base64.decodeBase64(content);

//            byte[] encrypted1 = new BASE64Decoder().decodeBuffer(content);

            Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
            SecretKeySpec keyspec = new SecretKeySpec(PASSWORD_KEY.getBytes(), "AES");
            IvParameterSpec ivspec = new IvParameterSpec(PASSWORD_KEY.getBytes());

            cipher.init(Cipher.DECRYPT_MODE, keyspec, ivspec);

            String originalString = new String(cipher.doFinal(encrypted1));
            int length = originalString.length();
            int ch = originalString.charAt(length - 1);
            return originalString.substring(0, length - ch);
        } catch (Exception e) {
            logger.error("aesDecrypt failure ,error message is:{}", e.getMessage());
        }
        return null;
    }

public String decrypt(String str) {
    Cipher cipher;
    try {
        cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, keySpec,
                new IvParameterSpec(ips.getBytes("UTF-8")));

        byte[] byteStr = Base64.decodeBase64(str.getBytes());
        String Str = new String(cipher.doFinal(byteStr), "UTF-8");

        return Str;
    } catch (NoSuchAlgorithmException | NoSuchPaddingException
            | InvalidKeyException | InvalidAlgorithmParameterException
            | IllegalBlockSizeException | BadPaddingException
            | UnsupportedEncodingException e) {
    }
    return null;
}

public static String DESDecrypt(final String ivString, final String keyString, final String content) {
    try {
        if (Check.isNullOrEmpty(content)) {
            return null;
        }
        IvParameterSpec iv = new IvParameterSpec(ivString.getBytes());
        DESKeySpec dks = new DESKeySpec(keyString.getBytes());
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey key = keyFactory.generateSecret(dks);
        Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, key, iv);
        byte[] result = cipher.doFinal(hexStr2ByteArr(content));
        return new String(result, "utf-8");
    } catch (Exception e) {
        LOGGER.error("ENCRYPT ERROR:" + e);
    }
    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);
    }

public PacketData encrypt(PacketData input){
    PacketData output = null;
    try {
        IvParameterSpec iv = new IvParameterSpec(mIV);
        SecretKeySpec skeySpec = new SecretKeySpec(mKey, "AES");

        Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
        Log.d(TAG, "encrypt - before - length=" + input.getLength());

        byte[] encrypted = cipher.doFinal(input.getBuffer());
        System.out.println("encrypted string: "
                + Base64.encodeBase64String(encrypted));
        Log.d(TAG, "encrypt - after - length=" + input.getLength());
        output = new PacketData(encrypted, encrypted.length);
    } catch (Exception ex) {
        ex.printStackTrace();
    }

    return output;
}

/**
 * 加密
 *
 * @throws Exception
 */
public static String Encrypt(String sSrc, String sKey) throws Exception {

    if (sKey == null) {
        Log.e("Key为空null", "Key为空null");
        return null;
    }
    // 判断Key是否为16位
    if (sKey.length() != 16) {
        Log.e("\"Key长度不是16位\"", "Key长度不是16位");
        return null;
    }
    byte[] raw = sKey.getBytes();
    SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");//"算法/模式/补码方式"
    IvParameterSpec iv = new IvParameterSpec("1234567890123456".getBytes());//使用CBC模式，需要一个向量iv，可增加加密算法的强度
    cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
    byte[] encrypted = cipher.doFinal(sSrc.getBytes());

    return encode(encrypted);//此处使用BASE64做转码功能，同时能起到2次加密的作用。
}

public String decrypt(String cipherText) throws EncryptionException {
    if(StringUtils.isBlank(cipherText)) {
        return cipherText;
    }

    try {
        String[] params = cipherText.split(":");
        byte[] iv = DatatypeConverter.parseHexBinary(params[IV_INDEX]);
        byte[] hash = DatatypeConverter.parseHexBinary(params[AES_INDEX]);

        SecretKey key = new SecretKeySpec(DatatypeConverter.parseHexBinary(keyProvider.getKeyHex()), "AES");
        IvParameterSpec ivSpec = new IvParameterSpec(iv);
        Cipher cipher = Cipher.getInstance(AESCTR_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key, ivSpec);
        byte[] result = cipher.doFinal(DatatypeConverter.parseHexBinary(DatatypeConverter.printHexBinary(hash)));

        return new String(result, "UTF-8");
    } catch (Exception ex) {
        LOG.error("Error decrypting message", ex);
        throw new EncryptionException("Failed to decrypt cipher with AES-CTR", ex);
    }
}

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

    try {
        final Cipher cipher = getCipherObject();
        final byte[] ivValue = generateIV(this.ivSize);
        final IvParameterSpec ivSpec = new IvParameterSpec(ivValue);

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

        final byte[] ciphertext = cipher.doFinal(value.getBytes());
        final byte[] ivCiphertext = new byte[INTEGER_LEN + this.ivSize + ciphertext.length];

        System.arraycopy(int2byte(this.ivSize), 0, ivCiphertext, 0, INTEGER_LEN);
        System.arraycopy(ivValue, 0, ivCiphertext, INTEGER_LEN, this.ivSize);
        System.arraycopy(ciphertext, 0, ivCiphertext, INTEGER_LEN + this.ivSize, ciphertext.length);

        return new String(encode(ivCiphertext));
    } 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 static byte[] b(SecretKeySpec secretKeySpec, byte[] bArr, byte[] bArr2) {
    Cipher instance = Cipher.getInstance("AES/CBC/PKCS7Padding");
    instance.init(2, secretKeySpec, new IvParameterSpec(bArr));
    byte[] doFinal = instance.doFinal(bArr2);
    a("decryptedBytes", doFinal);
    return doFinal;
}

static CipherBox newCipherBox(ProtocolVersion version, BulkCipher cipher,
        SecretKey key, IvParameterSpec iv, SecureRandom random,
        boolean encrypt) throws NoSuchAlgorithmException {
    if (cipher.allowed == false) {
        throw new NoSuchAlgorithmException("Unsupported cipher " + cipher);
    }

    if (cipher == B_NULL) {
        return NULL;
    } else {
        return new CipherBox(version, cipher, key, iv, random, encrypt);
    }
}

/**
 * 
 * (根据CBC 加密模式、指定加密key输出对应的BASE64编码解密串)<br>
 *
 * @param content
 * @param decryptKey
 * @return
 * @throws Exception
 * String
 * @Author fanyaowu
 * @data 2015年2月2日
 * @exception 
 * @version
 *
 */
public static String decryptByCBC(String content, String decryptKey) throws Exception
{
    try
    {
        DESKeySpec dks = new DESKeySpec(decryptKey.getBytes());

        // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ENCRYPT_TYPE);

        SecretKey secretKey = keyFactory.generateSecret(dks);

        // using DES in CBC mode
        Cipher cipher = Cipher.getInstance(CBC_ALGORITHM);

        // 用密匙初始化Cipher对象
        IvParameterSpec param = new IvParameterSpec(iv);

        cipher.init(Cipher.DECRYPT_MODE, secretKey, param);

        // 正式执行解密操作
        byte decryptedData[] = cipher.doFinal(Base64.decodeBase64(content));

        return new String(decryptedData);

    }
    catch (Exception e)
    {
        throw new EncryptException("Failed to encrypt for content: "
                + content + ", encrypt key: " + decryptKey, e);
    }
}

/**
 * 3DES加密
 * 
 * @param plainText 普通文本 pk 密钥
 * @return 加密的结果
 * @throws Exception 
 */
public static String desEncode(String plainText,String pk) throws Exception {
    Key deskey = null;
    DESedeKeySpec spec = new DESedeKeySpec(pk.getBytes());
    SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
    deskey = keyfactory.generateSecret(spec);

    Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
    IvParameterSpec ips = new IvParameterSpec(iv.getBytes());
    cipher.init(Cipher.ENCRYPT_MODE, deskey, ips);
    byte[] encryptData = cipher.doFinal(plainText.getBytes(encoding));
    return Bytes2HexString(encryptData);
}