Java安全密码学-（六）非对称加密

简介

① 非对称加密算法又称现代加密算法。

② 非对称加密是计算机通信安全的基石，保证了加密数据不会被破解。

③ 与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥(publickey) 和私有密(privatekey)

④ 公开密钥和私有密钥是一对

⑤ 如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密。

⑥ 如果用私有密钥对数据进行加密，只有用对应的公开密钥才能解密。

⑦ 因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。

 

示例

首先生成密钥对, 公钥为(5,14), 私钥为(11,14)

现在A希望将原文2发送给B

A使用公钥加密数据. 2的5次方mod 14 = 4 , 将密文4发送给B

B使用私钥解密数据. 4的11次方mod14 = 2, 得到原文2

 

特点

加密和解密使用不同的密钥

如果使用私钥加密, 只能使用公钥解密

如果使用公钥加密, 只能使用私钥解密

处理数据的速度较慢, 因为安全级别高

 

常见算法

RSA

ECC

 

私钥加密公钥解密

package com.atguigu.rsa;
import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
/**
 * RSAdemo
 *
 * @Author: 尚硅谷
 * @CreateTime: 2020-04-12
 * @Description:
 */
public class RSAdemo {
    public static void main(String[] args) throws Exception {
        String input = "硅谷";
        // 加密算法
        String algorithm = "RSA";
        //  创建密钥对生成器对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        // 生成公钥
        PublicKey publicKey = keyPair.getPublic();
        // 获取私钥字节数组
        byte[] privateKeyEncoded = privateKey.getEncoded();
        // 获取公钥字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        // 对公私钥进行base64编码
        String privateKeyString = Base64.encode(privateKeyEncoded);
        String publicKeyString = Base64.encode(publicKeyEncoded);


        // 创建加密对象
        // 参数表示加密算法
        Cipher cipher = Cipher.getInstance(algorithm);
        // 初始化加密
        // 第一个参数:加密的模式
        // 第二个参数：使用私钥进行加密
        cipher.init(Cipher.ENCRYPT_MODE,privateKey);
        // 私钥加密
        byte[] bytes = cipher.doFinal(input.getBytes());
        System.out.println(Base64.encode(bytes));
        // 私钥进行解密
        cipher.init(Cipher.DECRYPT_MODE,publicKey);
        // 对密文进行解密，不需要使用base64，因为原文不会乱码
        byte[] bytes1 = cipher.doFinal(bytes);
        System.out.println(new String(bytes1));

    }
}

 

保存公钥和私钥

前面代码每次都会生成 加密和解密 ，咱们需要把加密和解密的方法全部到本地的根目录下面。

import java.io.File;
import java.nio.charset.Charset;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;

import org.apache.commons.io.FileUtils;

import com.sun.org.apache.xml.internal.security.utils.Base64;

public class RSAdemo1 {
	public static void main(String[] args) throws Exception {
		// 加密算法
		String algorithm = "RSA";
		//生成密钥对并保存在本地文件中
		generateKeyToFile(algorithm, "a.pub", "a.pri");
	}

	/**
	 * 生成密钥对并保存在本地文件中
	 *
	 * @param algorithm : 算法
	 * @param pubPath   : 公钥保存路径
	 * @param priPath   : 私钥保存路径
	 * @throws Exception
	 */
	private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
		// 获取密钥对生成器
		KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
		// 获取密钥对
		KeyPair keyPair = keyPairGenerator.generateKeyPair();
		// 获取公钥
		PublicKey publicKey = keyPair.getPublic();
		// 获取私钥
		PrivateKey privateKey = keyPair.getPrivate();
		// 获取byte数组
		byte[] publicKeyEncoded = publicKey.getEncoded();
		byte[] privateKeyEncoded = privateKey.getEncoded();
		// 进行Base64编码
		String publicKeyString = Base64.encode(publicKeyEncoded);
		String privateKeyString = Base64.encode(privateKeyEncoded);
		// 保存文件
		FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
		FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));
	}
}

读取秘钥加密解密

import java.io.File;
import java.nio.charset.Charset;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

import org.apache.commons.io.FileUtils;

import com.sun.org.apache.xml.internal.security.utils.Base64;

public class RSAdemo {
	public static void main(String[] args) throws Exception {
		String input = "硅谷";
		// 加密算法
		String algorithm = "RSA";
		PrivateKey privateKey = getPrivateKey("a.pri", algorithm);
		PublicKey publicKey = getPublicKey("a.pub", algorithm);
		String s = encryptRSA(algorithm, privateKey, input);
		String s1 = decryptRSA(algorithm, publicKey, s);
		System.out.println(s1);
	}

	public static PublicKey getPublicKey(String pulickPath, String algorithm) throws Exception {
		// 将文件内容转为字符串
		String publicKeyString = FileUtils.readFileToString(new File(pulickPath), Charset.defaultCharset());
		// 获取密钥工厂
		KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
		// 构建密钥规范 进行Base64解码
		X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
		// 生成公钥
		return keyFactory.generatePublic(spec);
	}

	public static PrivateKey getPrivateKey(String priPath, String algorithm) throws Exception {
		// 将文件内容转为字符串
		String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
		// 获取密钥工厂
		KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
		// 构建密钥规范 进行Base64解码
		PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
		// 生成私钥
		return keyFactory.generatePrivate(spec);
	}

	/**
	 * 生成密钥对并保存在本地文件中
	 *
	 * @param algorithm : 算法
	 * @param pubPath   : 公钥保存路径
	 * @param priPath   : 私钥保存路径
	 * @throws Exception
	 */
	public static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
		// 获取密钥对生成器
		KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
		// 获取密钥对
		KeyPair keyPair = keyPairGenerator.generateKeyPair();
		// 获取公钥
		PublicKey publicKey = keyPair.getPublic();
		// 获取私钥
		PrivateKey privateKey = keyPair.getPrivate();
		// 获取byte数组
		byte[] publicKeyEncoded = publicKey.getEncoded();
		byte[] privateKeyEncoded = privateKey.getEncoded();
		// 进行Base64编码
		String publicKeyString = Base64.encode(publicKeyEncoded);
		String privateKeyString = Base64.encode(privateKeyEncoded);
		// 保存文件
		FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
		FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));

	}

	/**
	 * 解密数据
	 *
	 * @param algorithm      : 算法
	 * @param encrypted      : 密文
	 * @param key            : 密钥
	 * @return : 原文
	 * @throws Exception
	 */
	public static String decryptRSA(String algorithm, Key key, String encrypted) throws Exception {
		// 创建加密对象
		// 参数表示加密算法
		Cipher cipher = Cipher.getInstance(algorithm);
		// 私钥进行解密
		cipher.init(Cipher.DECRYPT_MODE, key);
		// 由于密文进行了Base64编码, 在这里需要进行解码
		byte[] decode = Base64.decode(encrypted);
		// 对密文进行解密，不需要使用base64，因为原文不会乱码
		byte[] bytes1 = cipher.doFinal(decode);
		return new String(bytes1);

	}

	/**
	 * 使用密钥加密数据
	 *
	 * @param algorithm      : 算法
	 * @param input          : 原文
	 * @param key            : 密钥
	 * @return : 密文
	 * @throws Exception
	 */
	public static String encryptRSA(String algorithm, Key key, String input) throws Exception {
		// 创建加密对象
		// 参数表示加密算法
		Cipher cipher = Cipher.getInstance(algorithm);
		// 初始化加密
		// 第一个参数:加密的模式
		// 第二个参数：使用私钥进行加密
		cipher.init(Cipher.ENCRYPT_MODE, key);
		// 私钥加密
		byte[] bytes = cipher.doFinal(input.getBytes());
		// 对密文进行Base64编码
		return Base64.encode(bytes);
	}
}