Java--非对称加密算法

最新推荐文章于 2021-08-25 20:45:47 发布
最新推荐文章于 2021-08-25 20:45:47 发布
阅读量272 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BtWangZhi/article/details/79037545
版权

DH（密钥加密算法）
在这里插入图片描述

public static void jdkDH(){
        try {
            //初始化发送方密钥---发送方的密钥对构建
            KeyPairGenerator senderKeyPairGenerator=KeyPairGenerator.getInstance("DH");
            senderKeyPairGenerator.initialize(512);
            KeyPair senderKeyPair=senderKeyPairGenerator.generateKeyPair();

            //2 初始化接收方密钥对--使用发送方的公钥构建接收方的密钥对
            KeyFactory receiveKeyFactory=KeyFactory.getInstance("DH");
            X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(senderKeyPair.getPublic().getEncoded());
            PublicKey receivePublicKey = receiveKeyFactory.generatePublic(x509EncodedKeySpec);
            DHParameterSpec dhParameterSpec=((DHPublicKey)receivePublicKey).getParams();
            KeyPairGenerator receiverKeyPairGenerator=KeyPairGenerator.getInstance("DH");
            receiverKeyPairGenerator.initialize(dhParameterSpec);
            KeyPair receiverKeyPair=receiverKeyPairGenerator.generateKeyPair();

            //3 接收方创建本地密钥--用自己的私钥+发送方的公钥
            KeyAgreement receiverKeyAgreement=KeyAgreement.getInstance("DH");
            receiverKeyAgreement.init(receiverKeyPair.getPrivate());
            PublicKey aPublic = senderKeyPair.getPublic();
            receiverKeyAgreement.doPhase(senderKeyPair.getPublic(),true);
            SecretKey receiverDesKey=receiverKeyAgreement.generateSecret("DES");

            //4 发送方创建本地密钥--用自己的私钥+接收方的公钥
            KeyAgreement senderKeyAgreement=KeyAgreement.getInstance("DH");
            senderKeyAgreement.init(senderKeyPair.getPrivate());
            senderKeyAgreement.doPhase(receiverKeyPair.getPublic(),true);
            SecretKey senderDesKey=senderKeyAgreement.generateSecret("DES");

            if(Objects.equals(receiverDesKey,senderDesKey)){
                System.out.println("双方密钥相同");
            }

            //=====================测试============================
            //4 加密
            Cipher cipher= Cipher.getInstance("DES");
            cipher.init(Cipher.ENCRYPT_MODE,senderDesKey);
            byte[] result = cipher.doFinal("hello world".getBytes());
            System.out.println("jdk dh encrypt:"+ Base64.encodeBase64String(result));

            //解密
            cipher.init(Cipher.DECRYPT_MODE,senderDesKey);
            result = cipher.doFinal(result);
            System.out.println("jdk dh decrypt:"+ new String(result));
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
    }

RSA非对称加密算法
这里写图片描述

	/**
	 * 加密算法RSA
	 */
	public static final String KEY_ALGORITHM = "RSA";

	/**
	 * 获取公钥的key
	 */
	public static final String PUBLIC_KEY = "RSAPublicKey";

	/**
	 * 获取私钥的key
	 */
	public static final String PRIVATE_KEY = "RSAPrivateKey";

	/**
	 * RSA最大加密明文大小
	 */
	private static final int MAX_ENCRYPT_BLOCK = 117;

	/**
	 * RSA最大解密密文大小
	 */
	private static final int MAX_DECRYPT_BLOCK = 128;

2.1 加密算法RSA

	/**
	 * 生成密钥对(公钥和私钥)
	 * 
	 * @return
	 * @throws Exception
	 */
	public static Map<String, Object> generateKeyPair() throws Exception {
		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
		keyPairGen.initialize(1024);
		KeyPair keyPair = keyPairGen.generateKeyPair();
		RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
		RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
		Map<String, Object> keyMap = new HashMap<String, Object>(2);
		keyMap.put(PUBLIC_KEY, Base64Utils.encode(publicKey.getEncoded()));
		keyMap.put(PRIVATE_KEY, Base64Utils.encode(privateKey.getEncoded()));
		return keyMap;
	}

公钥加密

	/**
	 * 
	 * 公钥加密
	 * @param data
	 *            源数据
	 * @param publicKey
	 *            公钥(BASE64编码)
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
		byte[] keyBytes = Base64Utils.decode(publicKey);
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key publicK = keyFactory.generatePublic(x509KeySpec);

		// 对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, publicK);
		int inputLen = data.length;
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		int offSet = 0;
		byte[] cache;
		int i = 0;

		// 对数据分段加密
		while (inputLen - offSet > 0) {
			if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
				cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
			} else {
				cache = cipher.doFinal(data, offSet, inputLen - offSet);
			}
			out.write(cache, 0, cache.length);
			i++;
			offSet = i * MAX_ENCRYPT_BLOCK;
		}
		byte[] encryptedData = out.toByteArray();
		out.close();
		return encryptedData;
	}

私钥加密

	/**
	 *
	 *  私钥加密
	 * @param data
	 *            源数据
	 * @param privateKey
	 *            私钥(BASE64编码)
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
		byte[] keyBytes = Base64Utils.decode(privateKey);
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, privateK);
		int inputLen = data.length;
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		int offSet = 0;
		byte[] cache;
		int i = 0;
		// 对数据分段加密
		while (inputLen - offSet > 0) {
			if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
				cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
			} else {
				cache = cipher.doFinal(data, offSet, inputLen - offSet);
			}
			out.write(cache, 0, cache.length);
			i++;
			offSet = i * MAX_ENCRYPT_BLOCK;
		}
		byte[] encryptedData = out.toByteArray();
		out.close();
		return encryptedData;
	}

公钥解密

	/**
	 * 公钥解密
	 * 
	 * @param encryptedData
	 *            已加密数据
	 * @param publicKey
	 *            公钥(BASE64编码)
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
		byte[] keyBytes = Base64Utils.decode(publicKey);
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key publicK = keyFactory.generatePublic(x509KeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, publicK);
		int inputLen = encryptedData.length;
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		int offSet = 0;
		byte[] cache;
		int i = 0;
		// 对数据分段解密
		while (inputLen - offSet > 0) {
			if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
				cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
			} else {
				cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
			}
			out.write(cache, 0, cache.length);
			i++;
			offSet = i * MAX_DECRYPT_BLOCK;
		}
		byte[] decryptedData = out.toByteArray();
		out.close();
		return decryptedData;
	}

私钥解密

	/**
	 * 私钥解密
	 * 
	 * @param encryptedData
	 *            已加密数据
	 * @param privateKey
	 *            私钥(BASE64编码)
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
		byte[] keyBytes = Base64Utils.decode(privateKey);
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, privateK);
		int inputLen = encryptedData.length;
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		int offSet = 0;
		byte[] cache;
		int i = 0;
		// 对数据分段解密
		while (inputLen - offSet > 0) {
			if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
				cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
			} else {
				cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
			}
			out.write(cache, 0, cache.length);
			i++;
			offSet = i * MAX_DECRYPT_BLOCK;
		}
		byte[] decryptedData = out.toByteArray();
		out.close();
		return decryptedData;
	}

涉及到编码和解码：

/** *//**
     * <p>
     * BASE64字符串解码为二进制数据
     * </p>
     * 
     * @param base64
     * @return
     * @throws Exception
     */
    public static byte[] decode(String base64) throws Exception {
        return Base64.decode(base64.getBytes());
    }
    
    /** *//**
     * <p>
     * 二进制数据编码为BASE64字符串
     * </p>
     * 
     * @param bytes
     * @return
     * @throws Exception
     */
    public static String encode(byte[] bytes) throws Exception {
        return new String(Base64.encode(bytes));
    }

测试：

/**
	 * 测试私钥加密，公钥解密
	 */
	public static void testEncryptAndDecrypt() {
		try {
			Map<String, Object> keyPair = generateKeyPair();
			// 私钥加密
			byte[] encryptData = encryptByPrivateKey("德玛".getBytes(), keyPair.get(PRIVATE_KEY).toString());
			System.out.println(encryptData);
			// 公钥解密
			byte[] decryData = decryptByPublicKey(encryptData, keyPair.get(PUBLIC_KEY).toString());
			System.out.println(new String(decryData));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 测试公钥加密，私钥解密
	 */
	public static void testDecryptAndEncrypt() {
		try {
			Map<String, Object> keyPair = generateKeyPair();
			// 公钥加密
			byte[] encryptData = encryptByPublicKey("西亚".getBytes(), keyPair.get(PUBLIC_KEY).toString());
			System.out.println(encryptData);

			// 私钥解密
			byte[] decryptData = decryptByPrivateKey(encryptData, keyPair.get(PRIVATE_KEY).toString());
			System.out.println(new String(decryptData));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
BtWangZhi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RSA加解密-java
qq526424978的博客
03-27 394
注意点: 1.RSA加密明文最大长度117字节，解密要求密文最大长度为128字节，所以在加密和解密的过程中需要分块进行 2.openssl加解密有固定的头和尾需要特殊处理 RSAUtil.java package com.centerm.ivycloud.vportal.userportalservice.util; import java.io.ByteArrayOutputStrea
Java中的对称加密算法
hi_0123的专栏
09-14 7531
在Java中，对于加密密钥和解密密钥相同的加密我们称之为非对称加密，其中主要有DES，3DES和AES加密。 DES加密 package com.example.asiatravel.learndes.util; import android.util.Log; import javax.crypto.Cipher; import javax.crypto.KeyGenerator; im
RSAUtil
由零开始。
08-03 2793
RSA
RSA加密解密，String转PublicKey、PrivateKey；附Base64.JAR
weixin_30908707的博客
06-06 3658
网络请求的数据需要加密，服务器给的他们那一套在Android一直报错，自己写了一个；package com.cc.common.util; import javax.crypto.Cipher; import java.security.*; import java.security.spec.PKCS8EncodedKeySpec; import java....
RSA使用X509EncodedKeySpec、PKCS8EncodedKeySpec生成公钥和私钥
iteye_14264的博客
11-02 5329
[code="java"] private static final String KEY_ALGORITHM = "RSA"; private static final String PUBLIC_KEY ="publicKey"; private static final String PRIVATE_KEY ="privateKey"; public st...
Java 中的加密算法
荒的博客
08-25 394
加密算法 加密算法通常分为对称加密算法和非对称加密算法： 对称加密算法（symmetric-key cryptography）：加密和解密时使用相同的密钥。常用的对称加密算法有 DES、AES。 非对称加密算法（asymmetric-key cryptography）：加密和解密使用不同的密钥，例如公钥加密的内容只能用私钥解密，所以又称为公钥加密算法（public-key cryptography）。使用最广泛的非对称加密算法是 RSA 算法。 两者有不同的使用场景，而且经常会一起搭配起来使用，例如 SSL
java 非对称加密算法RSA实现详解
08-25
Java 非对称加密算法RSA实现详解 Java 非对称加密算法RSA实现详解是 Java 语言中的一种常用加密算法，主要用于保护数据的安全性。 RSA 算法是一种基于大数分解的加密算法，它的安全性取决于大数分解的难度。在 Java...
JAVA加密算法- 非对称加密算法（DH，RSA）的详细介绍
09-01
非对称加密算法是加密技术中的重要组成部分，它在Java中被广泛应用于安全通信和数据保护。非对称加密算法的核心特点是使用一对密钥，即公钥和私钥，其中公钥可以公开，而私钥必须保密。这种机制解决了对称加密算法中...
java 非对称加密算法DH实现详解
08-25
Java 非对称加密算法 DH 实现详解 Java 非对称加密算法 DH 实现详解是一种基于 Diffie-Hellman 密钥交换算法的非对称加密算法实现。该算法实现了密钥交换、加密和解密的过程，主要用于保证数据的安全传输。 Diffie...
Java-Js双向Des对称加密Demo
12-06
本示例"Java-Js双向Des对称加密Demo"提供了在Java和JavaScript两个平台间实现DES加密解密的互操作性。下面将详细阐述DES加密解密的核心原理、Java和JavaScript的实现细节以及如何在两者之间进行兼容。 DES是一种块...
Java对称加密算法DES实例详解
08-25
Java对称加密算法DES实例详解 Java对称加密算法是使用对称密钥进行加密和解密的加密算法，其加密和解密使用相同的密钥。Java中对称加密算法有多种，而DES（Data Encryption Standard）是其中一种古老的对称加密...
java--Excel读取及转XML
BtWangZhi的博客
08-02 3840
1 单纯的将excel转xml 下载jdom-2.0.6.jar和操作excel的jxl-2.6.jar架包/** * 将execl转成xml * * @param excelPath * 被转换的excel文件路径 * @param xmlPath * 转换成xml的路径 */
java--16--系统函数
BtWangZhi的博客
04-23 1300
1 System类 1.1 currentTimeMillis：返回当前时间，精确到毫秒。取决于当前操作系统，可能会比当前操作系统的时间大。 1.2 arraycopy：将src数组中的数据从srcPos开始复制到dest数组中从destPos开始。长度为length。 /** * 测试System中的arrayCopy数组 */ public static v
Java--SMTP协议与发送邮件
BtWangZhi的博客
06-27 1229
本人用的是QQ的，需要在开启POP3/SMTP服务。 设置-》账号-》POP3/SMTP服务 开启，即可得到一个授权码，代码中需要的。具体参考： https://blog.csdn.net/chwshuang/article/details/54344317 添加maven依赖包： &amp;lt;!-- 邮件 --&amp;gt; &amp;lt;dependency&amp;gt; ...
Java--Jdk1.8Lambda
BtWangZhi的博客
08-02 1073
public class LambdaTest { public static void main(String[] args){ int[] intArr=new int[]{1,2,3}; //java8之前的写法 Arrays.parallelSetAll(intArr, new IntUnaryOperator() { ...
java--17--Map及其实现类与子接口
BtWangZhi的博客
04-23 713
1 Map概述 Map代表具有映射关系的集合， 该接口中的方法如下： 需要强调的是： size():Map集合中的映射条数如果大于Integer.MAX_VALUE，将返回Integer.MAX_VALUE，而不是实际的条数。 put():将映射插入到集合中，如果出现key已存在的情况，将会覆盖。 entrySet()：返回Map集合中包含映射的Set集合。 equals(Obje
java--泛型
BtWangZhi的博客
05-14 674
1 泛型的用处 定义一个集合，没有定义添加的元素类型，在添加元素是，不会检查每个添加的元素的类型。List lst_01=new ArrayList(); lst_01.add("111"); lst_01.add(5); System.out.println(((String)lst_01.get(2)).length());执行代码时将会出现java.lang.ClassCastExcepti
java--20--Set及其实现类与子接口
BtWangZhi的博客
05-13 667
1 Set 1.1 代码简要说明： A collection that contains no duplicate elements. More formally, sets contain no pair of elements e1 and e2 such that e1.equals(e2), and at most one null element. As implied by it
java 非对称加密算法验签
最新发布
06-18
在Java中，非对称加密算法主要用于安全通信中的密钥交换和数据签名。非对称加密是指使用一对密钥，一个是公开的公钥，另一个是私有的私钥，它们互为互补，不能由一个单独地解密另一个生成的信息。 1. **公钥加密**...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值