Java 加密算法

一、消息摘要算法

import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.Security;

import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;
import org.apache.commons.codec.digest.DigestUtils;
import org.bouncycastle.crypto.Digest;
import org.bouncycastle.crypto.digests.MD5Digest;
import org.bouncycastle.crypto.digests.SHA1Digest;
import org.bouncycastle.crypto.digests.SHA224Digest;
import org.bouncycastle.crypto.macs.HMac;
import org.bouncycastle.crypto.params.KeyParameter;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

/**
 * 消息摘要算法
 * 
 * @author lenovo-G50-70
 * 
 */
public class MdUtil {

    /**
     * JDK的MD5加密算法
     * 
     * @param content
     */
    public static void jdkMD5(String content) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
                byte[] md5Bytes = md.digest(content.getBytes());
            System.out.println("JDK MD5: " + Hex.encodeHexString(md5Bytes));
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }

    /**
     * JDK的MD2加密算法
     * 
     * @param content
     */
    public static void jdkMD2(String content) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD2");
            byte[] md5Bytes = md.digest(content.getBytes());
            System.out.println("JDK MD2: " + Hex.encodeHexString(md5Bytes));
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }

    /**
     * JDK的HmacMD5加密算法
     * 
     * @param content
     */
    public static void jdkHmacMD5(String content){
        try {
            // 初始化KeyGenerator
            KeyGenerator keyGenerator = KeyGenerator.getInstance("HmacMD5");
            // 产生密钥
            SecretKey secretKey = keyGenerator.generateKey();
            // 获取密钥
            //byte[] key = secretKey.getEncoded();
            byte[] key = Hex.decodeHex(new char[]{'1','2','3','4','5','6','7','8','9','a','b','c','d','e' });
            
            // 还原密钥
            SecretKey restoreSecretKey = new SecretKeySpec(key, "HmacMD5");
            // 实例化MAC
            Mac mac = Mac.getInstance(restoreSecretKey.getAlgorithm());
            // 初始化MAC
            mac.init(restoreSecretKey);
            // 执行摘要
            byte[] hmacMD5Bytes = mac.doFinal(content.getBytes());
            System.out.println("jdk hmacMD5:" + Hex.encodeHexString(hmacMD5Bytes));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 
     * @param content
     */
    public static void jdkSHA1(String content) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA");
            md.update(content.getBytes());
            System.out
                    .println("jdk sha-1: " + Hex.encodeHexString(md.digest()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 
     * @param content
     */
    public static void bcSHA1(String content) {
        Digest digest = new SHA1Digest();
        digest.update(content.getBytes(), 0, content.getBytes().length);
        byte[] sha1Bytes = new byte[digest.getDigestSize()];
        digest.doFinal(sha1Bytes, 0);
        System.out.println("bc sha-1: "
                + org.bouncycastle.util.encoders.Hex.toHexString(sha1Bytes));
    }

    /**
     * BC的HmacMD5加密算法
     * 
     * @param content
     */
    // 用bouncy castle实现:
    public static void bcHmacMD5(String content){
        HMac hmac = new HMac(new MD5Digest());
        // 必须是16进制的字符，长度必须是2的倍数
        hmac.init(new KeyParameter(org.bouncycastle.util.encoders.Hex.decode("123456789abcde")));
        hmac.update(content.getBytes(), 0, content.getBytes().length);
        // 执行摘要
        byte[] hmacMD5Bytes = new byte[hmac.getMacSize()];
        hmac.doFinal(hmacMD5Bytes, 0);
        System.out.println("bc hmacMD5:" + org.bouncycastle.util.encoders.Hex.toHexString(hmacMD5Bytes));
        
    }

    public static void bcMD4(String content) {
        try {
            Security.addProvider(new BouncyCastleProvider());
            MessageDigest md = MessageDigest.getInstance("MD4");
            byte[] md5Bytes = md.digest(content.getBytes());
            System.out.println("BC MD4: " + Hex.encodeHexString(md5Bytes));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void bcMD5(String content) {
        Digest digest = new MD5Digest();
        digest.update(content.getBytes(), 0, content.getBytes().length);
        byte[] md5Bytes = new byte[digest.getDigestSize()];
        digest.doFinal(md5Bytes, 0);
        System.out.println("BC MD5:"
                + org.bouncycastle.util.encoders.Hex.toHexString(md5Bytes));
    }

    public static void bcSHA224(String content) {
        Digest digest = new SHA224Digest();
        digest.update(content.getBytes(), 0, content.getBytes().length);
        byte[] sha224Bytes = new byte[digest.getDigestSize()];
        digest.doFinal(sha224Bytes, 0);
        System.out.println("bc sha-224: "
                + org.bouncycastle.util.encoders.Hex.toHexString(sha224Bytes));
    }

    public static void bcSHA224_2(String content) {
        try {
            Security.addProvider(new BouncyCastleProvider());
            MessageDigest md = MessageDigest.getInstance("SHA224");
            md.update(content.getBytes());
            System.out.println("bc sha-224_2:"
                    + Hex.encodeHexString(md.digest()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * CC的SHA1加密算法
     * 
     * @param content
     */
    public static void ccSHA1(String content) {
        System.out.println("cc sha1-1: "
                + DigestUtils.sha1Hex(content.getBytes()));
        System.out.println("cc sha1-2: " + DigestUtils.sha1Hex(content));
    }

    public static void ccMD5(String content) {
        System.out.println("CC MD5: " + DigestUtils.md5Hex(content.getBytes()));
    }

    public static void ccMD2(String content) {
        System.out.println("CC MD2: " + DigestUtils.md2Hex(content.getBytes()));
    }
}

二、Base64 对称加密算法

import org.apache.commons.codec.binary.Base64;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
import java.io.IOException;

/**
 *  Base64 加密算法
 *  应用场景：e-mail、密钥、证书文件
 */
public class Base64Util {

    /**
     *  JDK自带的Base64 算法
     * @param content
     */
    public static void jdkBase64(String content){
        try {
            //加密
            BASE64Encoder encoder = new BASE64Encoder();
            String encode = encoder.encode(content.getBytes());
            System.out.println(encode);
            //解密
            BASE64Decoder decoder = new BASE64Decoder();
            String decode = new String(decoder.decodeBuffer(encode));
            System.out.println(decode);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * ccBase64 算法
     * @param content
     */
    public static void commonsCodesBase64(String content){
        //加密
        byte[] encodeBytes = Base64.encodeBase64(content.getBytes());
        System.out.println("encode: "+ new String(encodeBytes));
        //解密
        byte[] decodeBytes = Base64.decodeBase64(encodeBytes);
        System.out.println("decode: "+ new String(decodeBytes));
    }

    /**
     * bcBase64 算法
     * @param content
     */
    public static void bouncyCastleBase64(String content){
        //加密
        byte[] encodeBytes = org.bouncycastle.util.encoders.Base64.encode(content.getBytes());
        System.out.println("encode: "+ new String(encodeBytes));
        //解密
        byte[] decodeBytes = org.bouncycastle.util.encoders.Base64.decode(encodeBytes);
        System.out.println("decode: "+ new String(decodeBytes));
    }
}

三、Des 对称加密算法

import org.apache.commons.codec.binary.Hex;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.DESedeKeySpec;
import java.security.Security;

/**
 *  Java对称算法
 *  应用场景：消息传递
 */
public class DesUtil {

    /**
     * JDK的DES加密算法
     * @param content
     */
    public static void jdkDes(String content){
        try {
            //生成key
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
            keyGenerator.init(56); //生成的密钥长度
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] bytesKey = secretKey.getEncoded();

            //Key的转换
            DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
            SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
            SecretKey convertSecretKey=factory.generateSecret(desKeySpec);

            //加密
            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
            byte[] result = cipher.doFinal(content.getBytes());
            System.out.println("jdk des encrypt: "+ Hex.encodeHexString(result));

            //解密
            cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
            result = cipher.doFinal(result);
            System.out.println("jdk des decrypt: "+ new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * BC的DES加密算法
     * @param content
     */
    public static void bcDES(String content){
        try {
            Security.addProvider(new BouncyCastleProvider());
            //生成key
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
            keyGenerator.init(56); //生成的密钥长度
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] bytesKey = secretKey.getEncoded();

            //Key的转换
            DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
            SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
            SecretKey convertSecretKey=factory.generateSecret(desKeySpec);

            //加密
            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
            byte[] result = cipher.doFinal(content.getBytes());
            System.out.println("bc des encrypt: "+ Hex.encodeHexString(result));

            //解密
            cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
            result = cipher.doFinal(result);
            System.out.println("bc des decrypt: "+ new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 常用加密方式
     * @param content
     */
    public static void jdk3Des(String content){
        try {
            //生成key
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
            keyGenerator.init(168); //生成密钥的长度
            //keyGenerator.init(new SecureRandom()); //生成默认长度的key
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] bytesKey = secretKey.getEncoded();

            //Key的转换
            DESedeKeySpec desKeySpec = new DESedeKeySpec(bytesKey);
            SecretKeyFactory factory = SecretKeyFactory.getInstance("DESede");
            SecretKey convertSecretKey=factory.generateSecret(desKeySpec);

            //加密
            Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
            byte[] result = cipher.doFinal(content.getBytes());
            System.out.println("jdk 3des encrypt: "+ Hex.encodeHexString(result));

            //解密
            cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
            result = cipher.doFinal(result);
            System.out.println("jdk 3des decrypt: "+ new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void bc3DES(String content){
          try {
            Security.addProvider(new BouncyCastleProvider());
            // 生成KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DES", "BC");
            keyGenerator.getProvider();
            keyGenerator.init(56);
            // 产生密钥
            SecretKey secretKey = keyGenerator.generateKey();
            // 获取密钥
            byte[] bytesKey = secretKey.getEncoded();
            // KEY转换
            DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
            SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
            Key convertSecretKey = factory.generateSecret(desKeySpec);
            // 加密
            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
            byte[] result = cipher.doFinal(content.getBytes());
            System.out.println("bc des encrypt:" + Hex.encodeHexString(result));
            // 解密
            cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
            result = cipher.doFinal(result);
            System.out.println("bc des decrypt:" + new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

四、Aes 对称加密算法

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;

/**
 * 使用最多的加密算法
 */
public class AesUtil {

    /**
     * JDK的AES加密
     * @param content
     */
    public static void jdkAES(String content){
        try {
            //生成key
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            keyGenerator.init(128);
            SecretKey secretKey =keyGenerator.generateKey();
            byte[] bytesKey = secretKey.getEncoded();
            //key转换
            Key key = new SecretKeySpec(bytesKey,"AES");
            //加密
            Cipher cipher =Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE,key);
            byte[] result = cipher.doFinal(content.getBytes());
            System.out.println("jdk aes encrypt: "+ Base64.encodeBase64String(result));
            //解密
            cipher.init(Cipher.DECRYPT_MODE,key);
            result = cipher.doFinal(result);
            System.out.println("jdk aes decrypt: "+ new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * BC的AES加密
     * @param content
     */
    public static void bcAES(String content){
        try {
            Security.addProvider(new BouncyCastleProvider());
            // 生成KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES", "BC");  
            keyGenerator.getProvider();
            keyGenerator.init(128);
            // 产生密钥
            SecretKey secretKey = keyGenerator.generateKey();
            // 获取密钥
            byte[] keyBytes = secretKey.getEncoded();
            // KEY转换
            Key key = new SecretKeySpec(keyBytes, "AES");
            // 加密
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] result = cipher.doFinal(content.getBytes());
            System.out.println("bc aes encrypt:" + Hex.encodeHexString(result));
            // 解密
            cipher.init(Cipher.DECRYPT_MODE, key);
            result = cipher.doFinal(result);
            System.out.println("bc aes decrypt:" + new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

五、Pbe 对称加密算法

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;
import java.security.Key;
import java.security.SecureRandom;

/**
 * 基于口令的加密算法
 * 综合了Aes、Des的优点
 */
public class PbeUtil {

    public static void jdkPBE(String content){
        try {
            SecureRandom random = new SecureRandom();
            byte[] salt = random.generateSeed(8);
            // 口令和密钥
            String password = "imooc";
            PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray());
            SecretKeyFactory factory = SecretKeyFactory.getInstance("PBEWITHMD5andDES");
            Key key = factory.generateSecret(pbeKeySpec);
            //加密
            PBEParameterSpec pbeParameterSpec = new PBEParameterSpec(salt,100);
            Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
            cipher.init(Cipher.ENCRYPT_MODE,key,pbeParameterSpec);
            byte[] result = cipher.doFinal(content.getBytes());
            System.out.println("jdk pbe encrypt: "+ Base64.encodeBase64String(result));
            //解密
            cipher.init(Cipher.DECRYPT_MODE,key,pbeParameterSpec);
            result = cipher.doFinal(result);
            System.out.println("jdk pbe decrypt: "+new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

六、Dh 非对称加密算法

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.SecretKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;
import java.security.*;
import java.security.spec.X509EncodedKeySpec;
import java.util.Objects;

public class DhUtil {

    public static void jdkDh(String content){
        try{
            //初始化发送方密钥
            KeyPairGenerator senderKeyPairGenerator = KeyPairGenerator.getInstance("DH");
            senderKeyPairGenerator.initialize(512);
            KeyPair senderKeyPair = senderKeyPairGenerator.generateKeyPair();
            byte[] senderPublicKeyEnc = senderKeyPair.getPublic().getEncoded();
            //初始化接收方的密钥
            KeyFactory receiverKeyFactory = KeyFactory.getInstance("DH");
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(senderPublicKeyEnc);
            PublicKey receiverPublicKey = receiverKeyFactory.generatePublic(x509EncodedKeySpec);
            DHParameterSpec dhParameterSpec = ((DHPublicKey) receiverPublicKey).getParams();
            KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");
            receiverKeyPairGenerator.initialize(dhParameterSpec);
            KeyPair receiverKeyPair = receiverKeyPairGenerator.generateKeyPair();
            PrivateKey receiverPrivateKey = receiverKeyPair.getPrivate();
            byte[] receiverPublicKeyEnc = receiverKeyPair.getPublic().getEncoded();
            //构建密钥
            KeyAgreement receiverKeyAgreement = KeyAgreement.getInstance("DH");
            receiverKeyAgreement.init(receiverPrivateKey);
            receiverKeyAgreement.doPhase(receiverPublicKey,true);
            SecretKey receiverDesKey = receiverKeyAgreement.generateSecret("DES");

            KeyFactory senderKeyFactory = KeyFactory.getInstance("DH");
            x509EncodedKeySpec = new X509EncodedKeySpec(receiverPublicKeyEnc);
            PublicKey senderPublicKey =senderKeyFactory.generatePublic(x509EncodedKeySpec);
            KeyAgreement senderKeyAgreement = KeyAgreement.getInstance("DH");
            senderKeyAgreement.init(senderKeyPair.getPrivate());
            senderKeyAgreement.doPhase(senderPublicKey,true);

            SecretKey senderDesKey = senderKeyAgreement.generateSecret("DES");
            if(Objects.equals(receiverDesKey,senderDesKey)){
                System.out.println("双方密钥相同");
            }

            //加密
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(Cipher.ENCRYPT_MODE,senderDesKey);
            byte[] result = cipher.doFinal(content.getBytes());
            System.out.println("jdk dh encrypt: "+Base64.encodeBase64String(result));

            //解密
            cipher.init(Cipher.DECRYPT_MODE,receiverDesKey);
            result = cipher.doFinal(result);
            System.out.println("jdk dh decrypt: "+ new String(result));
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

七、Rsa 非对称加密算法

import org.apache.commons.codec.binary.Base64;
import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

public class RsaUtil {
    public static void jdkRSA(String content){
        try{
            //初始化密钥
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(512);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
            System.out.println("Public Key: "+ Base64.encodeBase64String(rsaPublicKey.getEncoded()));
            System.out.println("Private Key: "+ Base64.encodeBase64String(rsaPrivateKey.getEncoded()));
            //私钥加密
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE,privateKey);
            byte[] result = cipher.doFinal(content.getBytes());
            System.out.println("私钥加密："+ Base64.encodeBase64String(result));
            //公钥解密
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE,publicKey);
            result = cipher.doFinal(result);
            System.out.println("公钥解密："+new String(result));
            //公钥加密
            x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("RSA");
            publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE,publicKey);
            result = cipher.doFinal(content.getBytes());
            System.out.println("公钥加密："+Base64.encodeBase64String(result));
            //私钥解密
            pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            keyFactory = KeyFactory.getInstance("RSA");
            privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE,privateKey);
            result = cipher.doFinal(result);
            System.out.println("私钥解密："+new String(result));
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

八、Idea

import java.security.Key;
import java.security.Security;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

public class IdeaUtil {
    public static void bcIDEA(String content) {
        try {
            Security.addProvider(new BouncyCastleProvider());
            //生成key
            KeyGenerator keyGenerator = KeyGenerator.getInstance("IDEA");
            keyGenerator.init(128);
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] keyBytes = secretKey.getEncoded();
            //转换密钥
            Key key = new SecretKeySpec(keyBytes, "IDEA");
            //加密
            Cipher cipher = Cipher.getInstance("IDEA/ECB/ISO10126Padding");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] result = cipher.doFinal(content.getBytes());
            System.out.println("bc idea encrypt : " + Base64.encodeBase64String(result));
            //解密
            cipher.init(Cipher.DECRYPT_MODE, key);
            result = cipher.doFinal(result);
            System.out.println("bc idea decrypt : " + new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

九、Crc

import java.util.zip.CRC32;

public class CrcUtil {
    public static void crc32(String content){
        CRC32 crc = new CRC32();
        crc.update(content.getBytes());
        String hex = Long.toHexString(crc.getValue());
        System.out.println("jdk crc32 : " + hex);
    }
}

十、Dsa数字签名算法

import org.apache.commons.codec.binary.Hex;

import java.security.*;
import java.security.interfaces.DSAPrivateKey;
import java.security.interfaces.DSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

public class DeaUtil {
    public static void jdkDSA(String content) {
        try {
            //1.初始化密钥
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DSA");
            keyPairGenerator.initialize(512);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            DSAPublicKey dsaPublicKey = (DSAPublicKey) keyPair.getPublic();
            DSAPrivateKey dsaPrivateKey = (DSAPrivateKey)keyPair.getPrivate();

            //2.执行签名
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(dsaPrivateKey.getEncoded());
            KeyFactory keyFactory = KeyFactory.getInstance("DSA");
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            Signature signature = Signature.getInstance("SHA1withDSA");
            signature.initSign(privateKey);
            signature.update(content.getBytes());
            byte[] result = signature.sign();
            System.out.println("jdk dsa sign : " + Hex.encodeHexString(result));

            //3.验证签名
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(dsaPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("DSA");
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            signature = Signature.getInstance("SHA1withDSA");
            signature.initVerify(publicKey);
            signature.update(content.getBytes());
            boolean bool = signature.verify(result);
            System.out.println("jdk dsa verify : " + bool);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

十一、Ecdsa

import org.apache.commons.codec.binary.Hex;
import java.security.*;
import java.security.interfaces.ECPrivateKey;
import java.security.interfaces.ECPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

public class EcdsaUtil {
    public static void jdkECDSA(String content) {
        try {
            //1.初始化密钥
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC");
            keyPairGenerator.initialize(256);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            ECPublicKey ecPublicKey = (ECPublicKey)keyPair.getPublic();
            ECPrivateKey ecPrivateKey = (ECPrivateKey)keyPair.getPrivate();

            //2.执行签名
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(ecPrivateKey.getEncoded());
            KeyFactory keyFactory = KeyFactory.getInstance("EC");
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            Signature signature = Signature.getInstance("SHA1withECDSA");
            signature.initSign(privateKey);
            signature.update(content.getBytes());
            byte[] result = signature.sign();
            System.out.println("jdk ecdsa sign : " + Hex.encodeHexString(result));

            //3.验证签名
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(ecPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("EC");
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            signature = Signature.getInstance("SHA1withECDSA");
            signature.initVerify(publicKey);
            signature.update(content.getBytes());
            boolean bool = signature.verify(result);
            System.out.println("jdk ecdsa verify : " + bool);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

十二、Base64

import org.apache.commons.codec.binary.Base64;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import java.io.IOException;

/**
 *  Base64 加密算法
 *  应用场景：e-mail、密钥、证书文件
 */
public class Base64Util {

    /**
     *  JDK自带的Base64 算法
     * @param content
     */
    public static void jdkBase64(String content){
        try {
            //加密
            BASE64Encoder encoder = new BASE64Encoder();
            String encode = encoder.encode(content.getBytes());
            System.out.println(encode);
            //解密
            BASE64Decoder decoder = new BASE64Decoder();
            String decode = new String(decoder.decodeBuffer(encode));
            System.out.println(decode);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * ccBase64 算法
     * @param content
     */
    public static void commonsCodesBase64(String content){
        //加密
        byte[] encodeBytes = Base64.encodeBase64(content.getBytes());
        System.out.println("encode: "+ new String(encodeBytes));
        //解密
        byte[] decodeBytes = Base64.decodeBase64(encodeBytes);
        System.out.println("decode: "+ new String(decodeBytes));
    }

    /**
     * bcBase64 算法
     * @param content
     */
    public static void bouncyCastleBase64(String content){
        //加密
        byte[] encodeBytes = org.bouncycastle.util.encoders.Base64.encode(content.getBytes());
        System.out.println("encode: "+ new String(encodeBytes));
        //解密
        byte[] decodeBytes = org.bouncycastle.util.encoders.Base64.decode(encodeBytes);
        System.out.println("decode: "+ new String(decodeBytes));
    }
}