java使用RSA与AES加密解密

其他 2019-06-28 11:18:17 阅读次数: 0

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

　　对称加密：加密与解密的密钥是相同的，加解密速度很快，比如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();
                }
            }
        }
    }

}

　　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.utilsimport 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")){ //AES密文以空行结束，RSA使用Base64加密写入时，会换行
                        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);
        }
    }
}

　　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

猜你喜欢

转载自www.cnblogs.com/gdhzdbh/p/11101540.html
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022