AES,RSA加密工具

import org.apache.commons.codec.binary.Base64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import sun.misc.BASE64Decoder;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.SecretKeySpec;

public class AESUtil {

    //实例化日志对象，引用jar包org.slf4j.Logger
    private static final Logger logger = LoggerFactory.getLogger(AESUtil.class);
    //算法
    private static final String ALGORITHMSTRs = "AES/ECB/PKCS5Padding";
    private static final String ALGORITHMSTR = "AES/ECB/NoPadding";
    /*
     *AES解密
     * data 待解密数据
     * key 解密秘钥
     * return 解密后的string
     */
    public static String desEncryt(String data,String key) throws Exception{
        try{

            byte[] encrypted=new BASE64Decoder().decodeBuffer(data);
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            kgen.init(128);

            Cipher cipher = Cipher.getInstance(ALGORITHMSTR);

            cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key.getBytes(), "AES"));

            return new String(cipher.doFinal(encrypted),"UTF-8");
        }catch (Exception ex){

            logger.error(ex.getMessage());

            return null;
        }
    }

    /**
     * AES加密
     * @param  content 待加密的内容
     * @param  encryptKey 加密密钥
     * @return 加密后的byte[]
     * @throws Exception
     */
    public static String aesEncryptToBytes(String content, String encryptKey) throws Exception {
        byte[] raw = encryptKey.getBytes();  //获得密码的字节数组
        SecretKeySpec skey = new SecretKeySpec(raw, "AES"); //根据密码生成AES密钥
        Cipher cipher = Cipher.getInstance(ALGORITHMSTRs);  //根据指定算法ALGORITHM自成密码器
        cipher.init(Cipher.ENCRYPT_MODE, skey); //初始化密码器，第一个参数为加密(ENCRYPT_MODE)或者解密(DECRYPT_MODE)操作，第二个参数为生成的AES密钥
        byte [] byte_content = content.getBytes("utf-8"); //获取加密内容的字节数组(设置为utf-8)不然内容中如果有中文和英文混合中文就会解密为乱码
        byte [] encode_content = cipher.doFinal(byte_content); //密码器加密数据
        return Base64.encodeBase64String(encode_content); //将加密后的数据转换为字符串返回

    }


}


//另一种加解密算法 RSA
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.NullArgumentException;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

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;
import java.util.HashMap;
import java.util.Map;

public  class RSAUtil {


   public static Map<Integer,String> genKeyPair() throws NullArgumentException{

       Map<Integer,String> keyMap=new HashMap<>();
       try{
           //初始化秘钥生成器生成秘钥
           KeyPairGenerator KeyPairGen=KeyPairGenerator.getInstance("RSA");
           KeyPairGen.initialize(1024,new SecureRandom());
           KeyPair keyPair=KeyPairGen.generateKeyPair();
           //生成公私钥
           RSAPublicKey publicKey=(RSAPublicKey)keyPair.getPublic();
           RSAPrivateKey privateKey=(RSAPrivateKey)keyPair.getPrivate();


           String publicKeyString=encryptBASE64(publicKey.getEncoded());
           String privateKeyString=encryptBASE64(privateKey.getEncoded());
           keyMap.put(0,privateKeyString);
           keyMap.put(1,publicKeyString);

           return keyMap;

       }catch (Exception ex){
           return null;
       }

   }


    //解码返回byte
    public static byte[] decryptBASE64(String key) throws Exception {
        return (new BASE64Decoder()).decodeBuffer(key);
    }

    //编码返回字符串
    public static String encryptBASE64(byte[] key) throws Exception {
        return (new BASE64Encoder()).encodeBuffer(key);
    }
   /*
   * 私钥加密
   * data 待加密串
   * key 私钥
   * return 返回加密好的字符串
   * */
   public static String encryptByPrivate(String data,String key) throws Exception{

     //  byte[] encrypted=new BASE64Decoder().decodeBuffer(data);

       if(data==null)
           return null;

       //取得私钥
       byte[] encrypted = new BASE64Decoder().decodeBuffer(key);


       PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(encrypted);
       KeyFactory keyFactory = KeyFactory.getInstance("RSA");
       //生成私钥
       PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
       //数据加密



       Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

       cipher.init(Cipher.ENCRYPT_MODE, privateKey);
       //对数据进行分段
       byte []  dataReturn=null;
       for (int i = 0; i < data.getBytes("utf-8").length; i += 64) {
           byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data.getBytes("utf-8"), i,
                   i + 64));
           dataReturn = ArrayUtils.addAll(dataReturn, doFinal);
       }


       return encryptBASE64(dataReturn);
   }


    /*
     * 公钥加密
     * data 待加密串
     * key 公钥
     * return 返回加密好的字符串
     * */
    public static String encryptByPublic(String data,String key) throws Exception{

       // byte[] encrypted=new BASE64Decoder().decodeBuffer(data.getBytes();
        //取得公钥
        byte[] encrypted = new BASE64Decoder().decodeBuffer(key);
        X509EncodedKeySpec X509KeySpec = new X509EncodedKeySpec(encrypted);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        //生成私钥
        PublicKey publicKey = keyFactory.generatePublic(X509KeySpec);
        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        //对数据进行分段
        byte []  dataReturn=null;
        for (int i = 0; i < data.getBytes("utf-8").length; i += 64) {
            byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data.getBytes("utf-8"), i,
                    i + 64));
            dataReturn = ArrayUtils.addAll(dataReturn, doFinal);
        }


        return encryptBASE64(dataReturn);
    }


    /*
     * 私钥解密
     * data 待解密串
     * key 私钥
     * return 返回解密好的字符串
     * */
    public static String decryptByPrivate(String data,String key) throws Exception{

      //  byte[] encrypted=new BASE64Decoder().decodeBuffer(data);
        //取得私钥
        byte[] encrypted = decryptBASE64(key);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(encrypted);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        //生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        //对数据进行分段
        String dataReturn=null;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < decryptBASE64(data).length; i += 128) {

            byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(decryptBASE64(data), i, i + 128));
            sb.append(new String(doFinal));
        }
        dataReturn = sb.toString();
        return dataReturn;
    }


    /*
     * 公钥加密
     * data 待加密串
     * key 公钥
     * return 返回加密好的字符串
     * */
    public static String decryptByPublic(String data,String key) throws Exception{

        byte[] encrypted=decryptBASE64(key);
        //取得公钥
        X509EncodedKeySpec X509KeySpec = new X509EncodedKeySpec(encrypted);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        //生成私钥
        PublicKey publicKey = keyFactory.generatePublic(X509KeySpec);
        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        //对数据进行分段
        String dataReturn=null;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < decryptBASE64(data).length; i += 128) {

            byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(decryptBASE64(data), i, i + 128));
            sb.append(new String(doFinal));
        }
        dataReturn = sb.toString();
        return dataReturn;
    }

}