文档章节

RSA-加密解密-工具类

nickles
 nickles
发布于 2017/05/14 13:14
字数 1044
阅读 209
收藏 0

需求:对支付相关的账号和密码进行加密【RSA非对称加密】处理,需要使用时,公钥解密出来放到内存中使用。服务器不再存放明文账号和密码。

从网上找了些RSA加密解密算法工具类,发现仅能本地加密解密,如果把加密结果【秘钥 公-私】作为字符串直接作为静态变量使用,则无法完成解密,具体原因还未知,爆了大量错误。于是对加密算法工具类进行了一下改造,将公钥存储到项目resource目录下,加密key放到代码中,实现“用时解密” --- 如果有改进意见,请回复评论

 

package 【xxxxx不暴露包名】;

/**
 * Created by percy on 2017/5/11.
 * RSA-工具类
 */
import com.xxxx.util.Base64;

import java.io.*;
import java.math.BigInteger;
import java.security.*;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import javax.crypto.Cipher;

public class RSAFromFile {

    /**
     * 根据传入的账号 和 密码 进行解密
     * @param mch_id 账户
     * @param key key
     * @return
     * @throws Exception
     */
    public static String getMchKey (String mch_id,String key) throws Exception {

        //用于获取resource目录下存储的私钥目录
        String Public_Key_File = Thread.currentThread()
                                       .getContextClassLoader()
                                       .getResource("key/" +mch_id+"_public.pem").getPath();

        RSAFromFile rsaObj = new RSAFromFile();
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(2048);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        PublicKey  publicKey =  rsaObj.readPublicKeyFromFile(Public_Key_File);
        byte[] encryptedData = Base64.decode(key);
        String resultByPublicKey = rsaObj.decryptDataByPublicKey(encryptedData,Public_Key_File);
        return resultByPublicKey;
    }



    /**
     * 存储文件
     * @param fileName
     * @param mod
     * @param exp
     * @throws IOException
     */
    private void saveKeys(String fileName,BigInteger mod,BigInteger exp) throws IOException{
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;

        try {
            System.out.println("初始化"+fileName + "...");
            fos = new FileOutputStream(fileName);
            oos = new ObjectOutputStream(new BufferedOutputStream(fos));

            oos.writeObject(mod);
            oos.writeObject(exp);

            System.out.println(fileName + " 初始化成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
        finally{
            if(oos != null){
                oos.close();

                if(fos != null){
                    fos.close();
                }
            }
        }
    }


    /**
     * 私钥加密
     * @param data
     * @throws IOException
     */
    private byte[] encryptDataByPrivateKey(String data,String PRIVATE_KEY_FILE) throws IOException {
        System.out.println("\n----------------加密开始------------");

        System.out.println("Data Before Encryption :" + data);
        byte[] dataToEncrypt = data.getBytes();
        byte[] encryptedData = null;
        try {
            PrivateKey privateKey = readPrivateKeyFromFile(PRIVATE_KEY_FILE);
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            encryptedData = cipher.doFinal(dataToEncrypt);
            System.out.println("Encryted Data: " + encryptedData);

        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("----------------加密结束------------");
        return encryptedData;
    }


    /**
     * 公钥加密
     * @param data
     * @throws IOException
     */
    private byte[] encryptDataByPublicKey(String data,String PUBLIC_KEY_FILE) throws IOException {
        System.out.println("\n----------------加密开始------------");

        System.out.println("Data Before Encryption :" + data);
        byte[] dataToEncrypt = data.getBytes();
        byte[] encryptedData = null;
        try {
            PublicKey pubKey = readPublicKeyFromFile(PUBLIC_KEY_FILE);
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, pubKey);
            encryptedData = cipher.doFinal(dataToEncrypt);
            System.out.println("Encryted Data: " + encryptedData);

        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("----------------加密结束------------");
        return encryptedData;
    }

    /**
     * 私钥解密
     * @param data
     * @throws IOException
     */
    private String decryptDataByPrivateKey(byte[] data,String PRIVATE_KEY_FILE) throws IOException {
        System.out.println("\n----------------私钥解密开始------------");
        byte[] descryptedData = null;

        try {
            PrivateKey privateKey = readPrivateKeyFromFile(PRIVATE_KEY_FILE);
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            descryptedData = cipher.doFinal(data);

        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("----------------私钥解密结束------------");
        return new String(descryptedData);
    }

    /**
     * 公钥解密
     * @param data
     * @throws IOException
     */
    private String decryptDataByPublicKey(byte[] data,String PUBLIC_KEY_FILE) throws IOException {
        System.out.println("\n----------------公钥解密开始------------");
        byte[] descryptedData = null;

        try {
            PublicKey publicKey = readPublicKeyFromFile(PUBLIC_KEY_FILE);
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            descryptedData = cipher.doFinal(data);

        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("----------------公钥解密结束------------");
        return new String(descryptedData);
    }

    /**
     * 从文件中读取公钥
     * @param fileName
     * @return PublicKey
     * @throws IOException
     */
    public PublicKey readPublicKeyFromFile(String fileName) throws IOException{

        FileInputStream fis = null;
        ObjectInputStream ois = null;
        PublicKey publicKey ;
        try {
            System.out.println("file Path:" + fileName);
            fis = new FileInputStream(new File(fileName));
            ois = new ObjectInputStream(fis);

            BigInteger modulus = (BigInteger) ois.readObject();
            BigInteger exponent = (BigInteger) ois.readObject();

            //Get Public Key
            RSAPublicKeySpec rsaPublicKeySpec = new RSAPublicKeySpec(modulus, exponent);
            KeyFactory fact = KeyFactory.getInstance("RSA");
             publicKey = fact.generatePublic(rsaPublicKeySpec);

            return publicKey;

        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            if(ois != null){
                ois.close();
                if(fis != null){
                    fis.close();
                }
            }
        }
        return null;
    }

    /**
     * 从文件中读取公钥
     * @param fileName
     * @return
     * @throws IOException
     */
    public PrivateKey readPrivateKeyFromFile(String fileName) throws IOException{
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            fis = new FileInputStream(new File(fileName));
            ois = new ObjectInputStream(fis);

            BigInteger modulus = (BigInteger) ois.readObject();
            BigInteger exponent = (BigInteger) ois.readObject();

            //Get Private Key
            RSAPrivateKeySpec rsaPrivateKeySpec = new RSAPrivateKeySpec(modulus, exponent);
            KeyFactory fact = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = fact.generatePrivate(rsaPrivateKeySpec);

            return privateKey;

        } catch (Exception e) {
            e.printStackTrace();
        }
        finally{
            if(ois != null){
                ois.close();
                if(fis != null){
                    fis.close();
                }
            }
        }
        return null;
    }


//    public static void main(String[] args) throws Exception {
//
//        File file = new File (Thread.currentThread().getContextClassLoader()
//                .getResource("jubaoyun/jubaopay.ini").toString());


        //--------------------------------------验证开始--------------------------------------
//        RSAFromFile rsaObj = new RSAFromFile();
//
//        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
//        keyPairGenerator.initialize(2048);
//        KeyPair keyPair = keyPairGenerator.generateKeyPair();
////        PrivateKey privateKey = rsaObj.readPrivateKeyFromFile(PRIVATE_KEY_FILE);
//        PublicKey  publicKey =  rsaObj.readPublicKeyFromFile(PUBLIC_KEY_FILE);
//
//        byte[] encryptedData = Base64.decode("keykeykeykey...");   <---  加密后的key
//
////        String resultByPrivateKey= rsaObj.decryptDataByPrivateKey(encryptedData);
////        System.out.println("私钥解密结果:"+resultByPrivateKey);
//
//        String resultByPublicKey = rsaObj.decryptDataByPublicKey(encryptedData);
//        System.out.println("公钥解密结果:"+resultByPublicKey);
        //--------------------------------------验证结束--------------------------------------



//        System.out.println("-------初始化 公钥 和 私钥 -------------");
//        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
//        keyPairGenerator.initialize(2048);
//        KeyPair keyPair = keyPairGenerator.generateKeyPair();
//        PublicKey publicKey = keyPair.getPublic();
//        PrivateKey privateKey = keyPair.getPrivate();
//        System.out.println("公钥 - " + publicKey);
//        System.out.println("私钥 - " + privateKey);
//
//
//        System.out.println("\n------- PULLING OUT PARAMETERS WHICH MAKES KEYPAIR----------\n");
//        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
//        RSAPublicKeySpec rsaPubKeySpec = keyFactory.getKeySpec(publicKey, RSAPublicKeySpec.class);
//        RSAPrivateKeySpec rsaPrivKeySpec = keyFactory.getKeySpec(privateKey, RSAPrivateKeySpec.class);
//
////        System.out.println("\n--------保存公钥和私钥到文件-------\n");
//        RSAFromFile rsaObj = new RSAFromFile();
//        rsaObj.saveKeys(PUBLIC_KEY_FILE, rsaPubKeySpec.getModulus(), rsaPubKeySpec.getPublicExponent());
//        rsaObj.saveKeys(PRIVATE_KEY_FILE, rsaPrivKeySpec.getModulus(), rsaPrivKeySpec.getPrivateExponent());



        //-------------------------------公钥加密====私钥解密--------------------------------------
//        //使用公钥加密
//        byte[] encryptedDataByPublicKey = rsaObj.encryptDataByPublicKey(" hello world hello world ");
//
//        System.out.println("公钥加密结果:"+Base64.encode(encryptedDataByPublicKey));
//
//        //使用私钥解密
//        rsaObj.decryptDataByPrivateKey(encryptedDataByPublicKey);

//        //--------------------------------私钥加密====公钥解密--------------------------------------
//        //使用私钥加密
//        byte[] encryptedDataByPrivateKey = rsaObj.encryptDataByPrivateKey("hello world");
//        System.out.println("私钥加密结果:"+Base64.encode(encryptedDataByPrivateKey));
//        //使用公钥解密
//        System.out.println(rsaObj.decryptDataByPublicKey(encryptedDataByPrivateKey));
//    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

© 著作权归作者所有

nickles
粉丝 5
博文 39
码字总数 32378
作品 0
深圳
程序员
私信 提问
浅析RSA公钥密码以及使用Java自带API实现RSA的密钥生成和加解密

RSA是目前最流行的非对称密码,目前广泛应用在数字签名,数字证书上。 那么什么是非对称密码呢?就是给明文加密的密钥和给密文解密的密钥是不一样的。其中,对外暴露的是公钥,自己保留的是私...

Lunqi
2015/07/15
0
1
Java非对称加密RSA工具类v1.1

依旧是练习的产物,java的加密算法有很多,可惜用起来很痛苦(个人感受),有时间的话打算做个简化过程的所有加密算法工具类,之前已经写过一个包含MD5、SHA1、DES、AES、异或的简单工具类 ...

linin630
2016/09/13
95
0
C# 中使用 RSA加解密算法

一、什么是RSA   RSA公开密钥密码体制。所谓的公开密钥密码体制就是使用不同的加密密钥与解密密钥,是一种“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。      在公开...

唐僧他大叔
2017/04/12
0
0
Android外部文件加解密及应用实践

有这样的应用场景,当我们把一些重要文件放到asset文件夹中时,把.apk解压是可以直接拿到这个文件的,一些涉及到重要信息的文件我们并不想被反编译拿去,这个时候需要先对文件进行加密,然后...

C6C
2018/05/08
0
0
RSA加密解密及数字签名Java实现

RSA公钥加密算法是1977年由罗纳德·李维斯特(Ron Rivest)、阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三...

Jialy
2013/10/25
0
5

没有更多内容

加载失败,请刷新页面

加载更多

Jenkins系列_插件安装及报错处理

进入Jenkins之后我们可以进行插件的安装,插件管理位于以下模块: 发现上面报了一堆错误,是因为插件的依赖没有安装好,那么这一节,就先把这些错误解决掉吧。解决完成后,也就基本会使用插件...

shzwork
今天
2
0
mysql mysql的所有查询语句和聚合函数(整理一下,忘记了可以随时看看)

查询所有字段 select * from 表名; 查询自定字段 select 字段名 from 表名; 查询指定数据 select * from 表名 where 条件; 带关键字IN的查询 select * from 表名 where 条件 [not] in(元素...

edison_kwok
昨天
8
0
多线程同时加载缓存实现

import com.google.common.cache.Cache;import com.google.common.cache.CacheBuilder;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorServi......

暗中观察
昨天
3
0
利用VisualVM 内存查看

准备工作,建几个测试类。等下就是要查看这几个类里面的属性 package visualvm;public class MultiObject { private String str; private int i; MultiObject(String str...

冷基
昨天
2
0
组装一台工作游戏两用机

一、配置清单如下: 分类 项目 价格(元) 主板 华硕(ASUS)TUF Z370-PLUS GAMING II 电竞特工 Z370二代 支持9代CPU 1049 CPU 英特尔(Intel) i7 8700K 酷睿六核 盒装CPU处理器 2640 风扇 九...

mbzhong
昨天
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部