java RSA非对称加密

jmp_triumph

于 2020-03-18 18:02:23 发布

阅读量169

点赞数

本文链接：https://blog.csdn.net/qq_29034189/article/details/104949940

版权

#java RSA非对称加密
因为项目需要对数据进行转移，转移出去的数据用公钥进行加密，接受到加密数据用私钥进行解密。
代码如下：

秘钥生成及加解密类

package com.ams.SystemManage.common;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

/**
 * 非对称加密算法RSA算法组件
 * 非对称算法一般是用来传送对称加密算法的密钥来使用的，相对于DH算法，RSA算法只需要一方构造密钥，不需要
 * 大费周章的构造各自本地的密钥对了。DH算法只能算法非对称算法的底层实现。而RSA算法算法实现起来较为简单
 */
public class RSAUtil {
    //非对称密钥算法
    public static final String KEY_ALGORITHM = "RSA";


    /**
     * 密钥长度，DH算法的默认密钥长度是1024
     * 密钥长度必须是64的倍数，在512到65536位之间
     */
    private static final int KEY_SIZE = 2048;
    //公钥
    private static final String PUBLIC_KEY = "RSAPublicKey";

    //私钥
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    /**
     * 初始化密钥对
     *
     * @return Map 甲方密钥的Map
     */
    public static Map<String, Object> initKey() throws Exception {
        //实例化密钥生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //初始化密钥生成器
        keyPairGenerator.initialize(KEY_SIZE);
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //甲方公钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        //甲方私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        //将密钥存储在map中
        Map<String, Object> keyMap = new HashMap<String, Object>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;

    }


    /**
     * 私钥加密
     *
     * @param data 待加密数据
     * @param key  密钥
     * @return byte[] 加密数据
     */
    public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception {

        //取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 公钥加密
     *
     * @param data 待加密数据
     * @param key  密钥
     * @return byte[] 加密数据
     */
    public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception {

        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //密钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }

    /**
     * 私钥解密
     *
     * @param data 待解密数据
     * @param key  密钥
     * @return byte[] 解密数据
     */
    public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception {
        //取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 公钥解密
     *
     * @param data 待解密数据
     * @param key  密钥
     * @return byte[] 解密数据
     */
    public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception {

        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //密钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
        //数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }

    /**
     * 取得私钥
     *
     * @param keyMap 密钥map
     * @return byte[] 私钥
     */
    public static byte[] getPrivateKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }

    /**
     * 取得公钥
     *
     * @param keyMap 密钥map
     * @return byte[] 公钥
     */
    public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }

    /**
     * <p>
     * BASE64字符串解码为二进制数据
     * </p>
     */
    public static byte[] decode(String base64) {
        return Base64.getDecoder().decode(base64);
    }

    /**
     * <p>
     * 二进制数据编码为BASE64字符串
     * </p>
     */
    public static String encode(byte[] bytes) {
        return  Base64.getEncoder().encodeToString(bytes);
    }

    /**
     *
     */
    public static void test() {
        try {
            //初始化密钥
            //生成密钥对
            Map<String, Object> keyMap = RSAUtil.initKey();
            //公钥
            byte[] publicKey = RSAUtil.getPublicKey(keyMap);

            //私钥
            byte[] privateKey = RSAUtil.getPrivateKey(keyMap);
            System.out.println("公钥：/n" + RSAUtil.encode(publicKey));
            System.out.println("私钥：/n" + RSAUtil.encode(privateKey));

            System.out.println("================密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输=============");
            String str = "RSA密码交换算法";
            System.out.println("/n===========甲方向乙方发送加密数据==============");
            System.out.println("原文:" + str);
            //甲方进行数据的加密
            byte[] code1 = RSAUtil.encryptByPrivateKey(str.getBytes(), privateKey);
            System.out.println("加密后的数据：" + RSAUtil.encode(code1));
            System.out.println("===========乙方使用甲方提供的公钥对数据进行解密==============");
            //乙方进行数据的解密
            byte[] decode1 = RSAUtil.decryptByPublicKey(code1, publicKey);
            System.out.println("乙方解密后的数据：" + new String(decode1) + "/n/n");

            System.out.println("===========反向进行操作，乙方向甲方发送数据==============/n/n");

            str = "乙方向甲方发送数据RSA算法";

            System.out.println("原文:" + str);

            //乙方使用公钥对数据进行加密
            byte[] code2 = RSAUtil.encryptByPublicKey(str.getBytes(), publicKey);
            System.out.println("===========乙方使用公钥对数据进行加密==============");
            System.out.println("加密后的数据：" + RSAUtil.encode(code2));

            System.out.println("=============乙方将数据传送给甲方======================");
            System.out.println("===========甲方使用私钥对数据进行解密==============");

            //甲方使用私钥对数据进行解密
            byte[] decode2 = RSAUtil.decryptByPrivateKey(code2, privateKey);

            System.out.println("甲方解密后的数据：" + new String(decode2));
        } catch (Exception e) {
            System.out.println(e);
        }

    }
}

调用代码：

package com.ams.SystemManage.common;

public class KeyPrivateUtil {

    //私钥
    private static final String PRIVATE_KEY = "MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDWmLYkwDuFts1p45BwrQtmzmgvso57sTEjUR/BnayjuSVCxHJ0NDzNiL1Ze1Ouu0UeFVeumkygD8UAJ6snaE+pegW3qrHORKwxcZFfiQym6QF8FhA8arZR1YOhd3JZjPFWTzmEOWSEwp1ZhbSS4lnNCOx1sV45Hu2iqW5l+ImuBdFUFX4COSRZfIEU2Yi1cSNc1eELGYClF1+PDa0qEDKc/XvRWP+HlUE4NhjnHlVroVx8hAYlfBBovUaNtDwnuYExtfr6++oeFLC9b9Nr/tW9ypi5IFeQFtj/Qc+2eQQF+6Zr2P/aXPwclEh/qlDoqA4mPeo5eT7lprWOFmdnAYHLAgMBAAECggEAB33JmgCAnhsyvOK9/O5QNWoONrVihkyPZ763akBmsZ551QSw7tU7VtIns13RSYptusOe+HrteDGkvGvQwe2Wc6xNUnXp2BwLRidDSRT/3+ccGf4BL21q6PIYXW94ip9sy15fpnnZxE1bmy+bjVHL4GhSgjdLZUNq+KCL4zu+aViSkXYG13SyGxaxFfHr+FnrYGb+oWkNFInTKlM9cZhCo0I/DOkgP7NJx4fZkQ1YsWaZrNbRfqNobUYc7p8QijKAruNwKOtN7RH4MFJh+Uaaz3QAYjme+Gj4T/Ykuk8BpJ5dNmnucB29k//yC6c0mrajUJEcpQ/tlS/zp/YJviRWqQKBgQD8szLWFOh/O0upicrd5vcm20ttwuXTfhWWo0378JVCyrpR1DozjfQ5MpQW0Koy1mVpYZNMJhBqvz4IgO8nhgtGRIVUZhUZhSFXyQvUOZT1/vdbqfyKM+LTTZr+DUkTClIbgplCk/0t6fLclv8cep38TGT//z3GwlBQccu8EJWGcwKBgQDZZiEUMEffdWr9Z59lWCiX9/EEqiDJHc4HV5vWNMH7ysc92fcTDHX0GyiNcmLbY6ZkS4qVd+zOL30EyemFp5/+1O6p75QyXxylQQNN156fmo30p9JgM69Omh7+ODhupbAWu1FvgG2tcPRByZutqOz0dI1Xt5XT9GSkV3aMD6NpSQKBgBHu+b2dsD5PS/hVMhN7b7DPQVQhz8OpoAiXwFIP6dfaoUxrXlIIUfu5Li9MUbfX5UyMQzLVRLb+qX1bAR3x8lzjQf8SW477FrmvJ+rAx2SJ2q4jqyt3sTJDwKsk8DmsstUG+K9z5zTZ9IVZJfO0c//SwBw21gCEC8UZvlazapknAoGAPsf9mYTv3JpeEVwRbgTthCV4Fu7ClRHkY75rJIsL0hkXPMdrULbygVIufdqgrdazQJeIJ+4AFvMj2XQt2gk0bTU0zyJ+26UX8qk5uQshpdnOUO7+FAYZBEwB00yND3cNySLDO74M7l+GSlFcgeQcuePGxaQgwpr7TXJsq7oAaPECgYBbRjQkfFTgrQGMobFEo4XKlosDL4F9crx8NvlhXB64rNUo/lpF9UaF8IiGsc34bgjL64hfVKJq1+h9AWHOk1DFq4x/kbScgwPgf4cTC2LEgMt8I5zopFsUM666lwY6sZ1nW8K9QuLdnF0i9h0V9+qbOblYKhgiP+OJBQhubjbE9w==";
    /**
     * 加密
     */
    public static String encryptPrivateKey(String data) throws Exception {
        return RSAUtil.encode(RSAUtil.encryptByPrivateKey(
                data.getBytes(),
                RSAUtil.decode(KeyPrivateUtil.PRIVATE_KEY)));
    }

    /**
     * 解密
     */
    public static String decryptByPrivateKey(String data) throws Exception {
        return new String(RSAUtil.decryptByPrivateKey(
                RSAUtil.decode(data),
                RSAUtil.decode(KeyPrivateUtil.PRIVATE_KEY)));
    }

}

MD5工具类

package com.ams.SystemManage.common;


import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.math.BigInteger;
import java.security.MessageDigest;

public class MD5 {

//    public static void main(String[] args) {
//        try {
//            //此处我测试的是我本机jdk源码文件的MD5值
//            String filePath = "C:\\Program Files\\Java\\jdk1.7.0_45\\src.zip";
//
//            String md5Hashcode = md5HashCode(filePath);
//            String md5Hashcode32 = md5HashCode32(filePath);
//
//            System.out.println(md5Hashcode + "：文件的md5值");
//            System.out.println(md5Hashcode32 + "：文件32位的md5值");
//
//            //System.out.println(-100 & 0xff);
//        } catch (FileNotFoundException e) {
//            e.printStackTrace();
//        }
//    }

    /**
     * 获取文件的md5值 ，有可能不是32位
     *
     * @param filePath 文件路径
     * @return
     * @throws FileNotFoundException
     */
    public static String md5HashCode(String filePath) throws FileNotFoundException {
        FileInputStream fis = new FileInputStream(filePath);
        return md5HashCode(fis);
    }

    /**
     * 保证文件的MD5值为32位
     *
     * @param filePath 文件路径
     * @return
     * @throws FileNotFoundException
     */
    public static String md5HashCode32(String filePath) throws FileNotFoundException {
        FileInputStream fis = new FileInputStream(filePath);
        return md5HashCode32(fis);
    }

    /**
     * java获取文件的md5值
     *
     * @param fis 输入流
     * @return
     */
    public static String md5HashCode(InputStream fis) {
        try {
            //拿到一个MD5转换器,如果想使用SHA-1或SHA-256，则传入SHA-1,SHA-256
            MessageDigest md = MessageDigest.getInstance("MD5");

            //分多次将一个文件读入，对于大型文件而言，比较推荐这种方式，占用内存比较少。
            byte[] buffer = new byte[1024];
            int length = -1;
            while ((length = fis.read(buffer, 0, 1024)) != -1) {
                md.update(buffer, 0, length);
            }
            fis.close();
            //转换并返回包含16个元素字节数组,返回数值范围为-128到127
            byte[] md5Bytes = md.digest();
            BigInteger bigInt = new BigInteger(1, md5Bytes);//1代表绝对值
            return bigInt.toString(16);//转换为16进制
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

    /**
     * java计算文件32位md5值
     *
     * @param fis 输入流
     * @return
     */
    public static String md5HashCode32(InputStream fis) {
        try {
            //拿到一个MD5转换器,如果想使用SHA-1或SHA-256，则传入SHA-1,SHA-256
            MessageDigest md = MessageDigest.getInstance("MD5");

            //分多次将一个文件读入，对于大型文件而言，比较推荐这种方式，占用内存比较少。
            byte[] buffer = new byte[1024];
            int length = -1;
            while ((length = fis.read(buffer, 0, 1024)) != -1) {
                md.update(buffer, 0, length);
            }
            fis.close();

            //转换并返回包含16个元素字节数组,返回数值范围为-128到127
            byte[] md5Bytes = md.digest();
            StringBuffer hexValue = new StringBuffer();
            for (int i = 0; i < md5Bytes.length; i++) {
                int val = ((int) md5Bytes[i]) & 0xff;//解释参见最下方
                if (val < 16) {
                    /**
                     * 如果小于16，那么val值的16进制形式必然为一位，
                     * 因为十进制0,1...9,10,11,12,13,14,15 对应的 16进制为 0,1...9,a,b,c,d,e,f;
                     * 此处高位补0。
                     */
                    hexValue.append("0");
                }
                //这里借助了Integer类的方法实现16进制的转换
                hexValue.append(Integer.toHexString(val));
            }
            return hexValue.toString();
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }
}

/**
 * 方法md5HashCode32 中     ((int) md5Bytes[i]) & 0xff   操作的解释：
 * 在Java语言中涉及到字节byte数组数据的一些操作时，经常看到 byte[i] & 0xff这样的操作，这里就记录总结一下这里包含的意义：
 * 1、0xff是16进制（十进制是255），它默认为整形，二进制位为32位，最低八位是“1111 1111”，其余24位都是0。
 * 2、&运算: 如果2个bit都是1，则得1，否则得0；
 * 3、byte[i] & 0xff：首先，这个操作一般都是在将byte数据转成int或者其他整形数据的过程中；使用了这个操作，最终的整形数据只有低8位有数据，其他位数都为0。
 * 4、这个操作得出的整形数据都是大于等于0并且小于等于255的
 **/

jmp_triumph

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java RSA非对称加密

#java RSA非对称加密因为项目需要对数据进行转移，转移出去的数据用公钥进行加密，接受到加密数据用私钥进行解密。代码如下：秘钥生成及加解密类package com.ams.SystemManage.common;import java.security.Key;import java.security.KeyFactory;import java.security.KeyPair...
复制链接

扫一扫