首页 > > 程序设计 > Java技术 >

java使用RSA与AES加密解密

2019-08-16 09:23:13来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

java使用RSA与AES加密解密

  • 首先了解下，什么是堆成加密，什么是非对称加密？

　　对称加密：加密与解密的密钥是相同的，加解密速度很快，比如AES

　　非对称加密：加密与解密的秘钥是不同的，速度较慢，比如RSA

 

  • 先看代码（先会用在研究） 

　　相关依赖：

   　　<dependency>
          <groupId>org.bouncycastle</groupId>
          <artifactId>bcprov-jdk15on</artifactId>
          <version>1.58</version>
      </dependency>

 

　　

       1，RSA工具类：

package cn.wangtao.utils;

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;

/**
 * @ClassName RSAUtils
 * @Auth 桃子
 * @Date 2019-6-25 15:15
 * @Version 1.0
 * @Description
 **/
public class RSAUtils {

    private static final String RSA = "RSA"; // 加密方式

    private static final Logger logger= LoggerFactory.getLogger(RSAUtils.class);

    //获取密钥
    public static KeyPair getKey() throws Exception {
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA, new BouncyCastleProvider());
            keyPairGenerator.initialize(2048); // 初始化密钥长度
            KeyPair keyPair = keyPairGenerator.generateKeyPair();// 生成密钥对
            return keyPair;
        } catch (Exception e) {
            logger.error("获取RSA秘钥对异常",e);
            throw new Exception("获取RSA秘钥对异常",e);
        }
    }

    //利用公钥进行加密
    public static String encryptStr(RSAPublicKey publicKey, String str) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance(RSA, new BouncyCastleProvider());
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            //加密
            byte[] bytes = getBytes(str.getBytes(), cipher);
            //2进行转换成16进制
            String result = CommonUtils.parseByte2HexStr(bytes);
            return result;
        } catch (Exception e) {
            logger.error("使用RSA公钥进行加密异常",e);
            throw new Exception("使用RSA公钥进行加密异常",e);
        }
    }




    //利用私钥进行解密
    public static String decryptStr(RSAPrivateKey privateKey, String str) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance(RSA, new BouncyCastleProvider());
            cipher.init(Cipher.DECRYPT_MODE, privateKey); // 用密钥初始化此Cipher对象
            //16进制转换成2进制
            byte[] bytes = CommonUtils.parseHexStr2Byte(str);
            //解密
            byte[] bs = getBytes(bytes, cipher);
            String content=new String(bs,"utf-8");
            return content;
        } catch (Exception e) {
            logger.error("使用RSA私钥进行解密异常",e);
            throw new Exception("使用RSA私钥进行解密异常",e);
        }
    }


    //通过cipher获取字节数组
    public static byte[] getBytes(byte[] bytes,Cipher cipher) throws Exception {
        int blockSize = cipher.getBlockSize(); // 返回块的大小
        int j = 0;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        while (bytes.length - j * blockSize > 0) { // 将二进制数据分块写入ByteArrayOutputStream中
            if(bytes.length-j*blockSize>blockSize){
                baos.write(cipher.doFinal(bytes, j * blockSize, blockSize));
            }else{
                baos.write(cipher.doFinal(bytes, j * blockSize,bytes.length-j*blockSize));
            }
            j++;
        }
        baos.close();
        byte[] byteArray = baos.toByteArray();
        return byteArray;
    }

    //保存秘钥对到文件
    public void saveRSAKey(String fileName) throws Exception {
        FileOutputStream fos=null;
        ObjectOutputStream oos=null;
        try {
            KeyPair keyPair = getKey();
            fos=new FileOutputStream(fileName);
            oos=new ObjectOutputStream(fos); //对象序列号
            oos.writeObject(keyPair);
        } catch (Exception e) {
            logger.error("RSA秘钥对保存到文件异常[{}]",fileName,e);
            throw new Exception("RSA秘钥对保存到文件异常",e);
        }finally {
            if(oos!=null){
                try {
                    oos.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }

}

　

/**
 * @ClassName RSAUtils
 * @Version 1.0
 * @Description RSA工具类
 **/
public class RSAUtils {
	
	private static final String RSA = "RSA";
    
    public static final String MD5WITHRSA="MD5withRSA";
    
    public static final String SHA1WITHRSA="SHA1withRSA";
    
    private static Logger logger= LoggerFactory.getLogger(RSAUtils.class);
    
    
    /**
     * @desc 读取秘钥文本内容
     * @createTime 2019年7月2日 下午5:20:38
     * @param keyFile 秘钥文件
     * @return 秘钥文本内容
     * @throws Exception
     */
    private static String initKeyByFile(File keyFile) throws Exception {

    	if(keyFile.exists() && keyFile.isFile()) {
    		BufferedReader bufferedReader = null;
    		try {
                bufferedReader = new BufferedReader(new FileReader(keyFile));
                StringBuilder stringBuilder = new StringBuilder();

                String line = null;
                while ((line = bufferedReader.readLine()) != null) {
                    if (line.length() == 0 || line.charAt(0) == '-') {
                        continue;
                    }
                    stringBuilder.append(line).append(System.getProperty("line.separator"));
                }
                return stringBuilder.toString();
	    	}catch (Exception e) {
	    		logger.error("读取秘钥文本内容异常",e);
	    		throw new Exception("读取秘钥文本内容异常",e);
    		}finally {
	            CommonUtils.closeReaderandWriter(bufferedReader, null);
	         }
    	}
    	return null;
    }
    
    /**
     * @desc 获取公钥
     * @author Liuweian
     * @createTime 2019年7月2日 下午5:19:34
     * @param pubKeyFileName 公钥文件地址
     * @return PublicKey
     * @throws Exception
     */
    public static PublicKey getPublicKeyByFile(File pubKeyFile) throws Exception {
    	String keyContent = initKeyByFile(pubKeyFile);
        byte[] keyByte = Base64.decode(keyContent);
        KeyFactory kf = KeyFactory.getInstance(RSA);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyByte);
        return kf.generatePublic(keySpec);
    }

    /**
     * @desc 获取私钥
     * @createTime 2019年7月2日 下午5:19:16
     * @param priKeyFileName 私钥文件地址
     * @return PrivateKey
     * @throws Exception
     */
    public static PrivateKey getPrivateKeyByFile(File priKeyFile) throws Exception {
    	String keyContent = initKeyByFile(priKeyFile);
        byte[] keyByte = Base64.decode(keyContent);
        KeyFactory kf = KeyFactory.getInstance(RSA);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyByte);
        return kf.generatePrivate(keySpec);
    }

    /**
     * @desc 使用RSA中的私钥对数据签名
     * @createTime 2019年7月2日 下午5:24:30
     * @param privateKey  秘钥对中的私钥
     * @param data 待加签字节数组
     * @param signType 加签类型
     * @return  加签后的签名
     * @throws Exception
     */
    public static String sign(byte[] data, PrivateKey privateKey, String signType) throws Exception {
    		Signature signature = Signature.getInstance(signType);
    		signature.initSign(privateKey);
    		signature.update(data);
    		byte[] signByte = signature.sign();
    		//Base64加密
    		return new String(Base64.encode(signByte));
    }
    
    
    /**
     * @desc 使用RSA中的公钥对签名验签
     * @createTime 2019年7月2日 下午5:24:30
     * @param data 待验签字节数组
     * @param sign 签名
     * @param publicKey  秘钥对中的公钥
     * @param signType 加签类型
     * @return  验签是否成功
     * @throws Exception
     */
    public static boolean verify(byte[] data, byte[] sign, PublicKey publicKey, String signType) {
        try {
            Signature signature = Signature.getInstance(signType);
            signature.initVerify(publicKey);
            signature.update(data);
            //Base64解密
            byte[] keyByte = Base64.decode(sign);
            return signature.verify(keyByte);
        } catch (Exception e) {
            logger.error("验签出现异常", e);
            return false;
        }
    }

    /**
     * @desc 使用RSA中的私钥对数据签名 加签方式 MD5withRSA
     * @createTime 2019年7月2日 下午5:24:30
     * @param privateKey  秘钥对中的私钥
     * @param data 待加签字节数组
     * @return  加签后的签名
     * @throws Exception
     */
    public static String signMD5withRSA(byte[] data, PrivateKey privateKey) throws Exception {
    	return sign(data, privateKey, MD5WITHRSA);
    }
        
    /**
     * @desc 使用RSA中的公钥对签名验签 验签方式 MD5withRSA
     * @createTime 2019年7月2日 下午5:24:30
     * @param sign 签名
     * @param publicKey  秘钥对中的公钥
     * @param signType 加签类型
     * @return  验签是否成功，失败则异常抛出
     * @throws Exception
     */
    public static void verifyMD5withRSA(byte[] data, byte[] sign, PublicKey publicKey) throws Exception {
    	if(!verify(data, sign, publicKey, MD5WITHRSA)) {
    		throw new Exception("验签失败");
    	}
    }
      
    /**
     * @desc 通过cipher获取字节数组  分块
     * @createTime 2019年7月2日 下午5:21:33
     * @param data 待加密的字节数组
     * @param cipher
     * @return
     * @throws Exception
     */
    public static byte[] getBytes(byte[] data, Cipher cipher) throws Exception {
        int blockSize = cipher.getBlockSize(); // 返回块的大小
        int j = 0;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        while (data.length - j * blockSize > 0) { // 将二进制数据分块写入ByteArrayOutputStream中
            if(data.length - j * blockSize > blockSize) {
                baos.write(cipher.doFinal(data, j * blockSize, blockSize));
            }else{
                baos.write(cipher.doFinal(data, j * blockSize, data.length - j * blockSize));
            }
            j++;
        }
        baos.close();
        byte[] byteArray = baos.toByteArray();
        return byteArray;
    }
    
    
    /**
     * @desc 利用公钥进行   加密
     * @createTime 2019年7月2日 下午5:24:30
     * @param key  密钥对的一个
     * @param data 待加密字节数组
     * @return 密文
     * @throws Exception
     */
    public static String encrypt(Key key, byte[] data) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance(RSA, new BouncyCastleProvider());
            cipher.init(Cipher.ENCRYPT_MODE, key);
            //加密
            byte[] bytes = getBytes(data, cipher);
            //2进行转换成16进制
            String result = CommonUtils.parseByte2HexStr(bytes);
            return new String(Base64.encode(result.getBytes(CommonUtils.CODE_TYPE)));
        } catch (Exception e) {
            logger.error("使用RSA公钥进行加密异常",e);
            throw new Exception("使用RSA公钥进行加密异常",e);
        }
    }

    /**
     * @desc 利用私钥进行      解密
     * @createTime 2019年7月2日 下午5:23:10
     * @param key  密钥对的一个
     * @param data 待解密的字节数组
     * @return 明文
     * @throws Exception
     */
    public static String decrypt(Key key, byte[] data) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance(RSA, new BouncyCastleProvider());
            cipher.init(Cipher.DECRYPT_MODE, key); // 用密钥初始化此Cipher对象
            //16进制转换成2进制
            byte[] bytes = CommonUtils.parseHexStr2Byte(Base64.decode(data));
            //解密
            byte[] bs = getBytes(bytes, cipher);
            String content=new String(bs,CommonUtils.CODE_TYPE);
            return content;
        } catch (Exception e) {
            logger.error("使用RSA私钥进行解密异常",e);
            throw new Exception("使用RSA私钥进行解密异常",e);
        }
    }


}

 

　　

 

 

　2，CommonUtils通用工具类：

package cn.wangtao.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

/**
 * @ClassName CommonUtils
 * @Auth 桃子
 * @Date 2019-6-27 12:51
 * @Version 1.0
 * @Description
 **/
public class CommonUtils {

    private static final Logger logger= LoggerFactory.getLogger(CommonUtils.class);
    //编码方式
    public static final String CODE_TYPE = "UTF-8";

    //字符补全
    private static final String[] consult = new String[]{"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F","G"};

    //关流
    public static void closeReaderandWriter(Reader reader, Writer writer){
        if(writer!=null){
            try {
                writer.close();
            } catch (IOException e) {
                logger.error("关闭输出流失败",e);
            }
        }
        if(reader!=null){
            try {
                reader.close();
            } catch (IOException e) {
                logger.error("关闭输出流失败",e);
            }
        }
    }

    //将16进制转换为二进制
    public static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr.length() < 1)
            return null;
        byte[] result = new byte[hexStr.length()/2];
        for (int i = 0;i< hexStr.length()/2; i++) {
            int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);
            int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }

    //将二进制转换成16进制
    public static String parseByte2HexStr(byte buf[]) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < buf.length; i++) {
            String hex = Integer.toHexString(buf[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

    //补全字符
    public static String completionCodeFor16Bytes(String str) throws Exception {
        try{
            int num = str.getBytes(CODE_TYPE).length;
            int index = num%16;
            //进行加密内容补全操作, 加密内容应该为 16字节的倍数, 当不足16*n字节是进行补全, 差一位时 补全16+1位
            //补全字符 以 $ 开始,$后一位代表$后补全字符位数,之后全部以0进行补全;
            if(index != 0){
                StringBuffer sbBuffer = new StringBuffer(str);
                if(16-index == 1){
                    sbBuffer.append("$" + consult[16-1] + addStr(16-1-1));
                }else{
                    sbBuffer.append("$" + consult[16-index-1] + addStr(16-index-1-1));
                }
                str = sbBuffer.toString();
            }
            return str;
        }catch (Exception e){
            logger.error("使用AES加密前补全字符异常",e);
            throw new Exception("使用AES加密前补全字符异常",e);
        }
    }

    //追加字符
    public static String addStr(int num){
        StringBuffer sbBuffer = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            sbBuffer.append("0");
        }
        return sbBuffer.toString();
    }

    //还原字符(进行字符判断)
    public static String resumeCodeOf16Bytes(String str) throws Exception{
        int indexOf = str.lastIndexOf("$");
        if(indexOf == -1){
            return str;
        }
        String trim = str.substring(indexOf+1,indexOf+2).trim();
        int num = 0;
        for (int i = 0; i < consult.length; i++) {
            if(trim.equals(consult[i])){
                num = i;
            }
        }
        if(num == 0){
            return str;
        }
        return str.substring(0,indexOf).trim();
    }

}

　　

3，AESUtils通用工具类：

package cn.wangtao.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.security.interfaces.RSAPrivateKey;
import java.util.Map;

/**
 * @ClassName AESUtils
 * @Auth 桃子
 * @Date 2019-6-27 12:05
 * @Version 1.0
 * @Description
 **/
public class AESUtils {

    private static final Logger logger= LoggerFactory.getLogger(AESUtils.class);

    //填充类型
    public static final String AES_TYPE = "AES/ECB/PKCS5Padding";

    private static final String AES = "AES"; // 加密方式


    public static final String DES_TYPE = "DES/ECB/PKCS5Padding";

    private static final String DES = "DES"; // 加密方式

    private final  String defaultDesKey="11112222";//8位

    //对字符串加密
    public static String encryptStr(String content,String aesKey) throws Exception {
        try {
            SecretKeySpec key = new SecretKeySpec(aesKey.getBytes(),AES );
            Cipher cipher = Cipher.getInstance(AES_TYPE);
            cipher.init(Cipher.ENCRYPT_MODE, key);
            //字符补全
            String content16Str = CommonUtils.completionCodeFor16Bytes(content);
            byte[] encryptedData = cipher.doFinal(content16Str.getBytes(CommonUtils.CODE_TYPE));
            //2进制转换成16进制
            String hexStr = CommonUtils.parseByte2HexStr(encryptedData);
            return hexStr;
        } catch (Exception e) {
            logger.error("使用AES对字符串加密异常",e);
            throw new Exception("使用AES对字符串加密异常",e);
        }

    }
    //对字符串解密
    public static String  decryptStr(String content,String aesKey) throws Exception {
        try {
            //16进制转换成2进制
            byte[] bytes = CommonUtils.parseHexStr2Byte(content);
            SecretKeySpec key = new SecretKeySpec(
                    aesKey.getBytes(), AES);
            Cipher cipher = Cipher.getInstance(AES_TYPE);
            cipher.init(Cipher.DECRYPT_MODE, key);
            byte[] decryptedData = cipher.doFinal(bytes);
            String result=new String(decryptedData, CommonUtils.CODE_TYPE);
            //还原字符
            String orgResult = CommonUtils.resumeCodeOf16Bytes(result);
            return orgResult;
        } catch (Exception e) {
            logger.error("使用AES对字符串解密异常",e);
            throw new Exception("使用AES对字符串解密异常",e);
        }
    }

    //对文件加密
    public static File encryptFile(File orgFile, File encryptFile, Map<String,Object> context) throws Exception {
        logger.info("使用AES对文件加密开始，源文件地址[{}]加密后文件地址[{}]",orgFile.getPath(),encryptFile.getPath());
        BufferedReader br=null;
        BufferedWriter bw=null;
        try{
            //获取AESKEY ，如果没有为默认
            String aesKey = (String) context.get(Dirt.AES_KEY);
            br=new BufferedReader(new FileReader(orgFile));

            bw=(BufferedWriter)context.get(Dirt.BUFFEREDWRITER);
            if(null==bw){
                bw=new BufferedWriter(new FileWriter(encryptFile));
            }
            String len=null;
            while (null!=(len=br.readLine())){
                String encrypt= encryptStr(len,aesKey);
                bw.write(encrypt);
                bw.newLine();
                bw.flush();
            }
            logger.info("使用AES对文件加密结束，源文件地址[{}]加密后文件地址[{}]",orgFile.getPath(),encryptFile.getPath());
            return encryptFile;
        }catch (Exception e){
            logger.error("使用AES对文件加密异常,源文件地址[{}]加密后文件地址[{}]",orgFile.getPath(),encryptFile.getPath(),e);
            throw new Exception("使用AES对文件加密异常",e);
        }finally {
            CommonUtils.closeReaderandWriter(br,bw);
        }
    }

    //对文本解密，返回解密文件后的文件
    public static File decryptFile(File decryptfile,  File encryptFile,Map<String,Object> context) throws Exception {
        logger.info("使用AES对文件解密开始，源加密文件地址[{}]解密后文件地址[{}]",encryptFile.getPath(),decryptfile.getPath());
        BufferedReader br=null;
        BufferedWriter bw=null;
        try{
            if(decryptfile.exists()){
                decryptfile.delete();
            }
            //边读边加密边写
            br=new BufferedReader(new FileReader(encryptFile));
            bw=new BufferedWriter(new FileWriter(decryptfile));

            String len=null;
            String aesKey=null;
            //判断是否加密
            RSAPrivateKey privateKey= (RSAPrivateKey) context.get(Dirt.RSAPRIVATEKEY);
            if(null!=privateKey){
                StringBuffer sb=new StringBuffer();
                while ((len=br.readLine())!=null){
                    sb.append(len);
                    if(len.equals("\n")||len.equals("")||len.equals("\r\n")||len.equals("\r")){
                        aesKey=RSAUtils.decryptStr(privateKey,sb.toString());
                        break;
                    }
                }
            }
            if(null==aesKey){
                aesKey=(String) context.get(Dirt.AES_KEY);
            }
           logger.info("aesKey[{}]",aesKey);
            if(aesKey!=null){
                while ((len=br.readLine())!=null){
                    String decrypt= decryptStr(len,aesKey);
                    bw.write(decrypt);
                    bw.flush();
                    bw.newLine();
                }
            }
            logger.info("使用AES对文件解密结束，源加密文件地址[{}]解密后文件地址[{}]",encryptFile.getPath(),decryptfile.getPath());
            return decryptfile;
        }catch (Exception e){
            logger.error("使用AES对文件解密异常,源加密文件地址[{}]解密后文件地址[{}]",encryptFile.getPath(),decryptfile.getPath(),e);
            throw new Exception("使用AES对文件解密异常",e);
        }finally {
            CommonUtils.closeReaderandWriter(br,bw);
        }
    }
}

　　

/**
 * @ClassName AESUtils
 * @Version 1.0
 * @Description AES工具类
 **/
public class AESUtils {
	
	private static final Logger logger = LoggerFactory.getLogger(AESUtils.class);
    
    /** 加密方式 */
    public static final String AES = "AES";
    
    public static final String AES_Type = "AES/ECB/PKCS5Padding";
   
    /**
     * @desc 随机生成AES加密秘钥
     * @createTime 2019年7月2日 下午5:36:00
     * @return 随机的AES的秘钥串 16位
     * @throws Exception
     */
  	public static String getAesKey() {
  	    Random random = new Random();
  	    String result = "";
  	    for(int i = 0; i< 16; i++){
  	        String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";
  	        // 输出字母还是数字
  	        if( "char".equalsIgnoreCase(charOrNum) ) {
  	            // 输出是大写字母还是小写字母
  	        	// int temp = random.nextInt(2) % 2 == 0 ? 65 : 97;
  	            result += (char)(random.nextInt(26) + 65);
  	        } else {
  	            result += String.valueOf(random.nextInt(10));
  	        }
  	    }
  	    return result;
  	}
    
    /**
     * @desc AES加密操作
     * @createTime 2019年7月2日 下午5:30:33
     * @param data 待加密字节数组
     * @param aesKey 秘钥串
     * @return 密文
     * @throws Exception
     */
    public static String encrypt(byte[] data, String aesKey) throws Exception {
        try {
            SecretKeySpec key = new SecretKeySpec(aesKey.getBytes(CommonUtils.CODE_TYPE), AES);
            Cipher cipher = Cipher.getInstance(AES);	
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] encryptedData = cipher.doFinal(data);
            //2进制转换成16进制并返回密文
            String result = CommonUtils.parseByte2HexStr(encryptedData);
            return new String(Base64.encode(result.getBytes(CommonUtils.CODE_TYPE)));
        } catch (Exception e) {
            logger.error("使用AES对字符串加密异常", e);
            throw new Exception("使用AES对字符串加密异常", e);
        }
    }

    /**
     * @desc AES解密操作
     * @createTime 2019年7月2日 下午5:31:37
     * @param data 待解密字节数组
     * @param aesKey 秘钥串
     * @return 明文
     * @throws Exception
     */
    public static String decrypt(byte[] data, String aesKey) throws Exception {
        try {
            // 16进制转换成2进制
            byte[] bytes = CommonUtils.parseHexStr2Byte(Base64.decode(data));
            
            SecretKeySpec key = new SecretKeySpec(aesKey.getBytes(CommonUtils.CODE_TYPE), AES);
            Cipher cipher = Cipher.getInstance(AES);
            cipher.init(Cipher.DECRYPT_MODE, key);
            //执行解密
            byte[] decryptedData = cipher.doFinal(bytes);
            //还原字符并返回
            return new String(decryptedData, CommonUtils.CODE_TYPE);
        } catch (Exception e) {
            logger.error("使用AES对字符串解密异常", e);
            throw new Exception("使用AES对字符串解密异常", e);
        }
    }


}

　　

　　4，Dirt常量

package cn.wangtao.utils;

import java.security.interfaces.RSAPublicKey;

/**
 * @ClassName Dirt
 * @Auth 桃子
 * @Date 2019-6-27 14:20
 * @Version 1.0
 * @Description
 **/
public class Dirt {
    public  static  final String UPLOADFILEURL="uploadFileUrl";
    public static final String AES_KEY="aesKey";
    public static final String RSAPUBLICKEY="rsaPublicKey";
    public static final String RSAPRIVATEKEY="rsaPrivateKey";


    public final static String RETURNCODE="returnCode";
    public final static String RETURNMSG="returnMsg";
    public final static String FILENAME="fileName";
    public final static String ORGFILENAME="orgFileName";
    public final static String ENCRYPTFILE="encryptFile";


    public static final String BUFFEREDWRITER="bufferedWriter"; //是为了在原始文件中进行补充加密

    //返回码
    public final static String SUCCESSCODE="000000";
    public final static String FAILEDCODE="999999";

    //加密文件所放的目录
    public final static String BASELOCALDIR="XXX"; //基本目录路径
    public final static String ENCRYPTLOCALDIR="encrypt"; //加密文件目录


}

 

 

  • AES的介绍

　　　详情请参考：https://blog.csdn.net/qq_28205153/article/details/55798628

  • RSA的介绍

 　　     详情请参考：https://www.cnblogs.com/jiftle/p/7903762.html


原文链接:https://www.cnblogs.com/gdhzdbh/p/11101540.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：mybatis分页插件PageHelper使用

下一篇：使用fastjson读取超巨json文件引起的GC问题

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签