用Java实现RSA加密算法

使用Java实现安全性加密与解密在当今信息时代，数据的安全性越来越受到重视。

无论是个人的隐私信息还是企业的商业机密，都需要得到有效的保护。

而加密与解密技术就是一种常用的保护数据安全的手段。

本文将介绍如何使用Java语言实现安全性加密与解密。

1. 加密与解密的基本概念加密是将明文转换为密文的过程，而解密则是将密文转换回明文的过程。

加密算法通常使用一个密钥，密钥用于控制加密过程的转换规则，只有拥有正确的密钥才能进行解密。

常见的加密算法有对称加密算法和非对称加密算法。

对称加密算法使用相同的密钥进行加密和解密，速度较快，但密钥的传输和管理相对困难。

非对称加密算法使用一对密钥，公钥用于加密，私钥用于解密，安全性较高，但速度较慢。

2. 使用Java实现对称加密Java提供了多种对称加密算法的实现，如DES、AES等。

下面以AES算法为例，介绍如何使用Java实现对称加密。

首先，需要导入Java加密扩展（JCE）的包。

在Java 8及以上版本中，JCE已经被默认包含在JDK中，无需额外导入。

接下来，可以使用以下代码进行AES加密：```javaimport javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;public class AESUtil {private static final String ALGORITHM = "AES";public static String encrypt(String plainText, String key) throws Exception {KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);keyGenerator.init(128);SecretKey secretKey = keyGenerator.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec secretKeySpec = new SecretKeySpec(enCodeFormat, ALGORITHM);Cipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);byte[] encryptedBytes = cipher.doFinal(plainText.getBytes());return Base64.getEncoder().encodeToString(encryptedBytes);}public static String decrypt(String encryptedText, String key) throws Exception {KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);keyGenerator.init(128);SecretKey secretKey = keyGenerator.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec secretKeySpec = new SecretKeySpec(enCodeFormat, ALGORITHM);Cipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);byte[] encryptedBytes = Base64.getDecoder().decode(encryptedText);byte[] decryptedBytes = cipher.doFinal(encryptedBytes);return new String(decryptedBytes);}}```以上代码中，`encrypt`方法用于对明文进行加密，`decrypt`方法用于对密文进行解密。

Java使⽤Cipher类实现加密，包括DES，DES3，AES和RSA加密⼀、先看⼀个简单加密，解密实现1.1 加密/*** content: 加密内容* slatKey: 加密的盐，16位字符串* vectorKey: 加密的向量，16位字符串*/public String encrypt(String content, String slatKey, String vectorKey) throws Exception {Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");IvParameterSpec iv = new IvParameterSpec(vectorKey.getBytes());cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);byte[] encrypted = cipher.doFinal(content.getBytes());return Base64.encodeBase64String(encrypted);}1.2 解密/*** content: 解密内容(base64编码格式)* slatKey: 加密时使⽤的盐，16位字符串* vectorKey: 加密时使⽤的向量，16位字符串*/public String decrypt(String base64Content, String slatKey, String vectorKey) throws Exception {Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");IvParameterSpec iv = new IvParameterSpec(vectorKey.getBytes());cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);byte[] content = Base64.decodeBase64(base64Content);byte[] encrypted = cipher.doFinal(content);return new String(encrypted);}1.3 代码解释上⾯简单实现了AES("AES/CBC/PKCS5Padding")的加密和解密。

javaRSAUtils加密⼯具类操作1.RSA加密算法是⼀种⾮对称加密算法。

在公开密钥加密和电⼦商业中RSA被⼴泛使⽤。

RSA公开密钥密码体制。

所谓的公开密钥密码体制就是使⽤不同的加密密钥与解密密钥，是⼀种“由已知加密密钥推导出解密密钥在计算上是不可⾏的”密码体制。

在公开密钥密码体制中，加密密钥（即公开密钥）PK是公开信息，⽽解密密钥（即秘密密钥）SK是需要保密的。

加密算法E和解密算法D也都是公开的。

虽然解密密钥SK是由公开密钥PK决定的，但却不能根据PK计算出SK。

2.本⼯具类涉及到BASE64编码，所以先展⽰出BASE64Utils：package mon.util;import sun.misc.BASE64Decoder;import sun.misc.BASE64Encoder;import java.security.MessageDigest;/*** BASE64的加解密* @author Neo* @date 2018-4-15 22:21:51**/@SuppressWarnings("restriction")public class Base64Utils {public static final String KEY_SHA = "SHA";public static final String KEY_MD5 = "MD5";/*** BASE64解密** @param key* @return* @throws Exception*/public static byte[] decryptBASE64(String key) throws Exception {return (new BASE64Decoder()).decodeBuffer(key);}/*** BASE64加密** @param key* @return* @throws Exception*/public static String encryptBASE64(byte[] key) throws Exception {return (new BASE64Encoder()).encodeBuffer(key);}/*** MD5加密** @param data* @return* @throws Exception*/public static byte[] encryptMD5(byte[] data) throws Exception {MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);md5.update(data);return md5.digest();}/*** SHA加密** @param data* @return* @throws Exception*/public static byte[] encryptSHA(byte[] data) throws Exception {MessageDigest sha = MessageDigest.getInstance(KEY_SHA);sha.update(data);return sha.digest();}}3.然后我们展⽰RSAUtils：package mon.util;import javax.crypto.Cipher;import java.security.*;import java.security.interfaces.RSAPrivateKey;import java.security.interfaces.RSAPublicKey;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.HashMap;import java.util.Map;/*** RSA安全编码组件** @version 1.0* @desc 公钥和私钥存放在properties⽂件的时候每⾏的末尾加上“\r\n\” <br/>* “\r\n” 起到换⾏的作⽤,最后的“\”在properties在⾥表⽰连接** @author Neo* @date 2018-4-15 22:23:19* @since 1.0*/public class RSAUtils extends Base64Utils {public static final String KEY_ALGORITHM = "RSA";public static final String SIGNATURE_ALGORITHM = "MD5withRSA";private static final String PUBLIC_KEY = "RSAPublicKey";private static final String PRIVATE_KEY = "RSAPrivateKey";/*** ⽤私钥对信息⽣成数字签名** @param data 加密数据* @param privateKey 私钥* @return* @throws Exception*/public static String sign(String data, String privateKey) throws Exception {return sign(data.getBytes(), privateKey);}/*** ⽤私钥对信息⽣成数字签名** @param data 加密数据* @param privateKey 私钥* @return* @throws Exception*/public static String sign(byte[] data, String privateKey) throws Exception {// 解密由base64编码的私钥byte[] keyBytes = decryptBASE64(privateKey);// 构造PKCS8EncodedKeySpec对象PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); // KEY_ALGORITHM 指定的加密算法KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);// 取私钥匙对象PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);// ⽤私钥对信息⽣成数字签名Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);signature.initSign(priKey);signature.update(data);return encryptBASE64(signature.sign());/*** 校验数字签名** @param data 加密数据* @param publicKey 公钥* @param sign 数字签名* @return 校验成功返回true 失败返回false* @throws Exception*/public static boolean verify(String data, String publicKey, String sign) throws Exception { return verify(data.getBytes(), publicKey, sign);}/*** 校验数字签名** @param data 加密数据* @param publicKey 公钥* @param sign 数字签名* @return 校验成功返回true 失败返回false* @throws Exception*/public static boolean verify(byte[] data, String publicKey, String sign) throws Exception { // 解密由base64编码的公钥byte[] keyBytes = decryptBASE64(publicKey);// 构造X509EncodedKeySpec对象X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);// KEY_ALGORITHM 指定的加密算法KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);// 取公钥匙对象PublicKey pubKey = keyFactory.generatePublic(keySpec);Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);signature.initVerify(pubKey);signature.update(data);// 验证签名是否正常return signature.verify(decryptBASE64(sign));}/*** 解密<br>* ⽤私钥解密** @param data* @param key* @return* @throws Exception*/public static String decryptByPrivateKey(String data, String key) throws Exception {return new String(decryptByPrivateKey(Base64Utils.decryptBASE64(data), key));}/*** 解密<br>* ⽤私钥解密** @param data* @param key* @return* @throws Exception*/public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception {// 对密钥解密byte[] keyBytes = decryptBASE64(key);// 取得私钥PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);// 对数据解密Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.DECRYPT_MODE, privateKey);return cipher.doFinal(data);}/*** 解密<br>* ⽤私钥解密** @param data* @param key* @return* @throws Exception*/public static String decryptByPublicKey(String data, String key) throws Exception { return new String(decryptByPublicKey(Base64Utils.decryptBASE64(data), key)); }/*** 解密<br>* ⽤私钥解密** @param data* @param key* @return* @throws Exception*/public static byte[] decryptByPublicKey(byte[] data, String key) throws Exception { // 对密钥解密byte[] keyBytes = decryptBASE64(key);// 取得公钥X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key publicKey = keyFactory.generatePublic(x509KeySpec);// 对数据解密Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.DECRYPT_MODE, publicKey);return cipher.doFinal(data);}/*** 加密<br>* ⽤公钥加密** @param data* @param key* @return* @throws Exception*/public static String encryptByPublicKey(String data, String key) throws Exception { return Base64Utils.encryptBASE64(encryptByPublicKey(data.getBytes(), key)); }/*** 加密<br>* ⽤公钥加密** @param data* @param key* @return* @throws Exception*/public static byte[] encryptByPublicKey(byte[] data, String key) throws Exception { // 对公钥解密byte[] keyBytes = decryptBASE64(key);// 取得公钥X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key publicKey = keyFactory.generatePublic(x509KeySpec);// 对数据加密Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.ENCRYPT_MODE, publicKey);return cipher.doFinal(data);}/*** 加密<br>* ⽤私钥加密** @param data* @param key* @return* @throws Exception*/public static String encryptByPrivateKey(String data, String key) throws Exception { return Base64Utils.encryptBASE64(encryptByPrivateKey(data.getBytes(), key)); }/*** 加密<br>* ⽤私钥加密** @param data* @param key* @return* @throws Exception*/public static byte[] encryptByPrivateKey(byte[] data, String key) throws Exception { // 对密钥解密byte[] keyBytes = decryptBASE64(key);// 取得私钥PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);// 对数据加密Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.ENCRYPT_MODE, privateKey);return cipher.doFinal(data);}/*** 取得私钥** @param keyMap* @return* @throws Exception*/public static String getPrivateKey(Map<String, Object> keyMap) throws Exception { Key key = (Key) keyMap.get(PRIVATE_KEY);return encryptBASE64(key.getEncoded());}/*** 取得公钥** @param keyMap* @return* @throws Exception*/public static String getPublicKey(Map<String, Object> keyMap) throws Exception {Key key = (Key) keyMap.get(PUBLIC_KEY);return encryptBASE64(key.getEncoded());}/*** 初始化密钥** @return* @throws Exception*/public static Map<String, Object> initKey() 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, publicKey);keyMap.put(PRIVATE_KEY, privateKey);return keyMap;}public static void main(String[] args) {try {Map<String, Object> map = RSAUtils.initKey();String publicKey = RSAUtils.getPublicKey(map);String privateKey = RSAUtils.getPrivateKey(map);System.out.println("公钥：" + publicKey);System.out.println("私钥：" + privateKey);String data = "Java是世界上最好的编程语⾔";String encryptData = RSAUtils.encryptByPublicKey(data, publicKey);System.out.println("加密后：" + encryptData);String decryptData = RSAUtils.decryptByPrivateKey(encryptData, privateKey);System.out.println("解密后：" + decryptData);} catch (Exception e) {e.printStackTrace();}}}4.最后展⽰测试结果：补充知识：java使⽤RSA⽣成公钥和私钥，并进⾏加解密废话不多说，上代码：import javax.crypto.Cipher;import sun.misc.BASE64Decoder;import sun.misc.BASE64Encoder;import java.security.KeyFactory;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.SecureRandom;import java.security.interfaces.RSAPrivateKey;import java.security.interfaces.RSAPublicKey;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.HashMap;import java.util.Map;/*** Java RSA 加密⼯具类*/public class RSAUtils {/*** 密钥长度于原⽂长度对应以及越长速度越慢*/private final static int KEY_SIZE = 1024;/*** ⽤于封装随机产⽣的公钥与私钥*/private static Map<Integer, String> keyMap = new HashMap<Integer, String>();/*** 随机⽣成密钥对* @throws Exception*/public static void genKeyPair() throws Exception {// KeyPairGenerator类⽤于⽣成公钥和私钥对，基于RSA算法⽣成对象KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");// 初始化密钥对⽣成器keyPairGen.initialize(KEY_SIZE, new SecureRandom());// ⽣成⼀个密钥对，保存在keyPair中KeyPair keyPair = keyPairGen.generateKeyPair();// 得到私钥RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();// 得到公钥RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();String publicKeyString = encryptBASE64(publicKey.getEncoded());// 得到私钥字符串String privateKeyString = encryptBASE64(privateKey.getEncoded());// 将公钥和私钥保存到Map//0表⽰公钥keyMap.put(0, publicKeyString);//1表⽰私钥keyMap.put(1, privateKeyString);}//编码返回字符串public static String encryptBASE64(byte[] key) throws Exception {return (new BASE64Encoder()).encodeBuffer(key);}//解码返回bytepublic static byte[] decryptBASE64(String key) throws Exception {return (new BASE64Decoder()).decodeBuffer(key);}/*** RSA公钥加密** @param str 加密字符串* @param publicKey 公钥* @return 密⽂* @throws Exception 加密过程中的异常信息*/public static String encrypt(String str, String publicKey) throws Exception {//base64编码的公钥byte[] decoded = decryptBASE64(publicKey);RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded)); //RSA加密Cipher cipher = Cipher.getInstance("RSA");cipher.init(Cipher.ENCRYPT_MODE, pubKey);String outStr = encryptBASE64(cipher.doFinal(str.getBytes("UTF-8")));return outStr;}/*** RSA私钥解密** @param str 加密字符串* @param privateKey 私钥* @return 明⽂* @throws Exception 解密过程中的异常信息*/public static String decrypt(String str, String privateKey) throws Exception {//64位解码加密后的字符串byte[] inputByte = decryptBASE64(str);//base64编码的私钥byte[] decoded = decryptBASE64(privateKey);RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));//RSA解密Cipher cipher = Cipher.getInstance("RSA");cipher.init(Cipher.DECRYPT_MODE, priKey);String outStr = new String(cipher.doFinal(inputByte));return outStr;}public static void main(String[] args) throws Exception {long temp = System.currentTimeMillis();//⽣成公钥和私钥genKeyPair();//加密字符串System.out.println("公钥:" + keyMap.get(0));System.out.println("私钥:" + keyMap.get(1));System.out.println("⽣成密钥消耗时间:" + (System.currentTimeMillis() - temp) / 1000.0 + "秒");String message = "RSA测试aaa";System.out.println("原⽂:" + message);temp = System.currentTimeMillis();String messageEn = encrypt(message, keyMap.get(0));System.out.println("密⽂:" + messageEn);System.out.println("加密消耗时间:" + (System.currentTimeMillis() - temp) / 1000.0 + "秒");temp = System.currentTimeMillis();String messageDe = decrypt(messageEn, keyMap.get(1));System.out.println("解密:" + messageDe);System.out.println("解密消耗时间:" + (System.currentTimeMillis() - temp) / 1000.0 + "秒");}}以上这篇java RSAUtils 加密⼯具类操作就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。

JAVARSA私钥加密（签名）对应C#RSA私钥加密（签名）⾮对称密钥RSA算法加解密在C#和Java之间交互的问题，这两天看了很多其他⼈写的⽂章，碰到了⼏个问题，最终解决问题。

需求⽬的：完成c#请求端RSA加密(签名)问题，客户端采⽤C#开发，服务器端采⽤Java开发。

服务器端给客户端提供私钥，进⾏数据加密(签名)，客户端加密(签名)后提数据提交给服务器，服务器⽤公钥对数据解密，进⾏验证。

解决过程碰到的问题：1.JAVA 需要的 RSA私钥格式和 C# 需要的 RSA私钥不⼀致。

JAVA 需要是 PKCS8格式私钥:-----BEGIN PRIVATE KEY-----MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAOwuOHH/OIRE+0ifmEPYGuhYRTyKdd6VLFIsNqy/SO5xZitHfA7xEymJKnpEUGgDJKr5zbFbytnWs5Jjgen6TXkUh9LG/fhPGGHdUVB42pAHv5yzoyEaOnJxBAxd6UstoWTaEgbT6GUbzMr/Az25zuxw7c+skAlnUETVE5GL3tD7AgMBAAECgYEAxdNZODMctb3J9OSo93rV3vPA2prna87rVtDt4vg+MGsPtwSjZyiKcmoQCGWcK+MmHYgrwHkwihKKSv3KXZ9or3xQ2wNZGuTHLymWEzqfEfVb0igvxbe85EGwsaN3qSK62CK8vok/Bi+fZVa3UNCn0WFslUS0qn+K3SECM9I1iwECQQD+2Pl2AJGQs2bRXSsnJk0FIwjpqdpGZFPlAUYaXkuTMqpwefP/bwwiuWqq9QIt2vAAKgy5T16tpPBcGpT6cvxBAkEA7T+i1gVwrXcozTuT9oCwkF2MGBaXkv3mN9H/Pfy/oIhTsgiDxX8t+0KapAEQogvCuAOq19JvGw5e91H2g0suOwJAJOMnCIuAhl9RTJCdxGbo0wuFKL0rGPFAq28JxJtNeRrmTK16QcjDCuunouMf059TCdMMUG5Kl/u9xrcaRT4LgQJAZPiUYOnnzqvMHayhiGO0wXxOx2G2GMUeWdtx+fu7wqLCnB6rlj5OX4U1M1+QqKbAtHg7Gadhye4P1Mp5U9+HSQJBANLVzcCXyAX2D12UPTPkhcNRaCRXFp3aJGMxI4iluUC+ukAdiapohqZ7vMQyWRq/tDyiwjirqMcg/AJIuQWmPyc=-----END PRIVATE KEY-----C# 需要的是 PKCS1 格式私钥:-----BEGIN RSA PRIVATE KEY-----MIICXQIBAAKBgQDsLjhx/ziERPtIn5hD2BroWEU8inXelSxSLDasv0jucWYrR3wO8RMpiSp6RFBoAySq+c2xW8rZ1rOSY4Hp+k15FIfSxv34Txhh3VFQeNqQB7+cs6MhGjpycQQMXelLLaFk2hIG0+hlG8zK/wM9uc7scO3PrJAJZ1BE1RORi97Q+wIDAQABAoGBAMXTWTgzHLW9yfTkqPd61d7zwNqa52vO61bQ7eL4PjBrD7cEo2coinJqEAhlnCvjJh2IK8B5MIoSikr9yl2faK98UNsDWRrkxy8plhM6nxH1W9IoL8W3vORBsLGjd6kiutgivL6JPwYvn2VWt1DQp9FhbJVEtKp/it0hAjPSNYsBAkEA/tj5dgCRkLNm0V0rJyZNBSMI6anaRmRT5QFGGl5LkzKqcHnz/28MIrlqqvUCLdrwACoMuU9eraTwXBqU+nL8QQJBAO0/otYFcK13KM07k/aAsJBdjBgWl5L95jfR/z38v6CIU7IIg8V/LftCmqQBEKILwrgDqtfSbxsOXvdR9oNLLjsCQCTjJwiLgIZfUUyQncRm6NMLhSi9KxjxQKtvCcSbTXka5kytekHIwwrrp6LjH9OfUwnTDFBuSpf7vca3GkU+C4ECQGT4lGDp586rzB2soYhjtMF8TsdhthjFHlnbcfn7u8Kiwpweq5Y+Tl+FNTNfkKimwLR4OxmnYcnuD9TKeVPfh0kCQQDS1c3Al8gF9g9dlD0z5IXDUWgkVxad2iRjMSOIpblAvrpAHYmqaIame7zEMlkav7Q8osI4q6jHIPwCSLkFpj8n-----END RSA PRIVATE KEY-----2.私钥格式之间的转换问题java 代码，注意这⾥的私钥：是Pem私钥⽂件中去除头（-----BEGIN PRIVATE KEY-----）和尾（-----END PRIVATE KEY-----）以及换⾏符后的字符串1 /**2 * @data: 待加密的字符串3 * @privateKey: 私钥4 */5 public static String sign(byte[] data, String privateKey) throws Exception {67 byte[] keyBytes = new BASE64Decoder().decodeBuffer(privateKey);8 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);910 KeyFactory keyFactory = KeyFactory.getInstance("RSA");1112 PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);1314 Signature signature = Signature.getInstance("SHA1withRSA");15 signature.initSign(priKey);16 signature.update(data);1718 return byte2hex(signature.sign());19 }c# 代码，注意这⾥的私钥：是Pem私钥⽂件中去除头（-----BEGIN RSA PRIVATE KEY-----）和尾（-----END RSA PRIVATE KEY-----）以及换⾏符后的字符串1 /// <summary>2 /// 签名3 /// </summary>4 /// <param name="data">待加密的字符串</param>5 /// <param name="privateKey">私钥</param>6 /// <returns></returns>7 public static string Sign(string data, string privateKey)8 {9 RSACryptoServiceProvider rsaCsp = LoadCertificate(privateKey);10 byte[] dataBytes = Encoding.UTF8.GetBytes(data);11 byte[] signatureBytes = rsaCsp.SignData(dataBytes, "SHA1");12 return Hex_2To16(signatureBytes);13 }1415 private static RSACryptoServiceProvider LoadCertificate(string privateKey)16 {17 byte[] res = res = Convert.FromBase64String(privateKey);18 try19 {20 RSACryptoServiceProvider rsa = DecodeRSAPrivateKey(res);21 return rsa;22 }23 catch (Exception ex)24 {25 }26 return null;27 }2829 private static RSACryptoServiceProvider DecodeRSAPrivateKey(byte[] privkey)30 {31 byte[] MODULUS, E, D, P, Q, DP, DQ, IQ;3233 // --------- Set up stream to decode the asn.1 encoded RSA private key ------34 MemoryStream mem = new MemoryStream(privkey);35 BinaryReader binr = new BinaryReader(mem); //wrap Memory Stream with BinaryReader for easy reading36 byte bt = 0;37 ushort twobytes = 0;38 int elems = 0;39 try40 {41 twobytes = binr.ReadUInt16();42 if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)43 binr.ReadByte(); //advance 1 byte44 else if (twobytes == 0x8230)45 binr.ReadInt16(); //advance 2 bytes46 else47 return null;4849 twobytes = binr.ReadUInt16();50 if (twobytes != 0x0102) //version number51 return null;52 bt = binr.ReadByte();53 if (bt != 0x00)54 return null;555657 //------ all private key components are Integer sequences ----58 elems = GetIntegerSize(binr);59 MODULUS = binr.ReadBytes(elems);6061 elems = GetIntegerSize(binr);62 E = binr.ReadBytes(elems);6364 elems = GetIntegerSize(binr);65 D = binr.ReadBytes(elems);6667 elems = GetIntegerSize(binr);68 P = binr.ReadBytes(elems);6970 elems = GetIntegerSize(binr);71 Q = binr.ReadBytes(elems);7273 elems = GetIntegerSize(binr);74 DP = binr.ReadBytes(elems);7576 elems = GetIntegerSize(binr);77 DQ = binr.ReadBytes(elems);7879 elems = GetIntegerSize(binr);80 IQ = binr.ReadBytes(elems);818283 // ------- create RSACryptoServiceProvider instance and initialize with public key -----84 CspParameters CspParameters = new CspParameters();85 CspParameters.Flags = eMachineKeyStore;86 RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(1024, CspParameters);87 RSAParameters RSAparams = new RSAParameters();88 RSAparams.Modulus = MODULUS;89 RSAparams.Exponent = E;90 RSAparams.D = D;91 RSAparams.P = P;92 RSAparams.Q = Q;93 RSAparams.DP = DP;94 RSAparams.DQ = DQ;95 RSAparams.InverseQ = IQ;96 RSA.ImportParameters(RSAparams);97 return RSA;98 }99 catch (Exception ex)100 {101 return null;102 }103 finally104 {105 binr.Close();106 }107 }108109 private static int GetIntegerSize(BinaryReader binr)110 {111 byte bt = 0;112 byte lowbyte = 0x00;113 byte highbyte = 0x00;114 int count = 0;115 bt = binr.ReadByte();116 if (bt != 0x02) //expect integer117 return 0;118 bt = binr.ReadByte();119120 if (bt == 0x81)121 count = binr.ReadByte(); // data size in next byte122 else123 if (bt == 0x82)124 {125 highbyte = binr.ReadByte(); // data size in next 2 bytes126 lowbyte = binr.ReadByte();127 byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };128 count = BitConverter.ToInt32(modint, 0);129 }130 else131 {132 count = bt; // we already have the data size133 }134135 while (binr.ReadByte() == 0x00)136 { //remove high order zeros in data137 count -= 1;138 }139 binr.BaseStream.Seek(-1, SeekOrigin.Current); //last ReadByte wasn't a removed zero, so back up a byte 140 return count;141 }142143144 /// <summary>145 /// 2进制转16进制146 /// </summary>147 public static String Hex_2To16(Byte[] bytes)148 {149 String hexString = String.Empty;150 Int32 iLength = 65535;151 if (bytes != null)152 {153 StringBuilder strB = new StringBuilder();154155 if (bytes.Length < iLength)156 {157 iLength = bytes.Length;158 }159160 for (int i = 0; i < iLength; i++)161 {162 strB.Append(bytes[i].ToString("X2"));163 }164 hexString = strB.ToString(); 165 }166 return hexString;167 }。

Java读取pem格式公钥私钥实现RSA加解密代码如下：⽣成.pem，这⾥使⽤2048位长度：openssl genrsa -out private_key.pem 1024将.pem转为.der：openssl pkcs8 -topk8 -inform PEM -outform DER -in private_key.pem -out private_key.der -nocryptopenssl rsa -in private_key.pem -pubout -outform DER -out public_key.der读取public_key.der：import java.nio.file.Files;import java.nio.file.Paths;import java.security.KeyFactory;import java.security.PublicKey;import java.security.spec.X509EncodedKeySpec;public class PublicKeyReader {public static PublicKey get(String filename) throws Exception {byte[] keyBytes = Files.readAllBytes(Paths.get(filename));X509EncodedKeySpec spec = new X509EncodedKeySpec(keyBytes);KeyFactory kf = KeyFactory.getInstance("RSA");return kf.generatePublic(spec);}}读取private_key.der：import java.io.DataInputStream;import java.io.File;import java.io.FileInputStream;import java.nio.file.Files;import java.nio.file.Paths;import java.security.KeyFactory;import java.security.PrivateKey;import java.security.spec.PKCS8EncodedKeySpec;public class PrivateKeyReader {public static PrivateKey get(String filename) throws Exception {byte[] keyBytes = Files.readAllBytes(Paths.get(filename));PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);KeyFactory kf = KeyFactory.getInstance("RSA");return kf.generatePrivate(spec);}}测试：import sun.misc.BASE64Decoder;import sun.misc.BASE64Encoder;import java.io.IOException;import java.nio.charset.StandardCharsets;import java.security.PrivateKey;import java.security.PublicKey;public class RSAReadKeyTest {public static void main(String[] args) throws Exception {String text = "When and where\n" +"Join us on June 25, 2020 10:00 Pacific Daylight Time. The workshops will be livestreamed to YouTube via Google Cloud Platform in partnership with AI Huddle.\n" +"\n" +"Is this for me?\n" +"This session is especially geared for professional working data scientists. You should be comfortable with Python to build machine or deep learning models. If you’re curious how accelerators can improve your workflow, this is for you "\n" +"Agenda\n" +"Session 1: 10:00-10:30 AM PDT\n" +"Compete in a Kaggle Competition Using TensorFlow GPUs with Chris Deotte \n" +"“Follow along as I make a simple notebook from my team's Gold medal solution to Bengali Handwriting Classification competition.”\n" +"\n" +"Session 2: 10:30-11:00 AM PDT \n" +"Approach (Almost) Any Deep Learning Problem Using PyTorch and TPUs with Abhishek Thakur\n" +"“Allow me to show you how to harness the power of TPUs and Pytorch to quickly train almost any model!”";PublicKey pubKey = PublicKeyReader.get("src/gj/secure/rsa_public_key.der");byte[] bytes = RSAUtil.encryptByPublicKey(pubKey, text.getBytes());String cipherText = toBase64(bytes);System.out.println(cipherText);PrivateKey priKey = PrivateKeyReader.get("src/gj/secure/rsa_private_key.der");byte[] cipherBytes = fromBase64(cipherText);byte[] result = RSAUtil.decryptByPrivateKey(priKey, cipherBytes);System.out.println(new String(result, StandardCharsets.UTF_8));}public static String toBase64(byte[] bytes) {return new BASE64Encoder().encode(bytes);}public static byte[] fromBase64(String b64String) throws IOException {return new BASE64Decoder().decodeBuffer(b64String);}}附RSAUtil.java代码：import javax.crypto.Cipher;import java.io.ByteArrayOutputStream;import java.security.*;/*** @author areful* Date: 2019/2/12*/public class RSAUtil {public static final String ALGORITHM_RSA = "RSA";public static final String ALGORITHM_RSA_PKCS1PADDING = "RSA/ECB/PKCS1PADDING";public static final String SIGNATURE_ALGORITHM = "MD5withRSA";private static final int MAX_ENCRYPT_BLOCK = 117;private static final int MAX_DECRYPT_BLOCK = 128;public static KeyPair genKeyPair() throws Exception {KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(ALGORITHM_RSA);keyPairGen.initialize(1024);return keyPairGen.generateKeyPair();}public static byte[] encryptByPublicKey(PublicKey pubKey, byte[] data) throws Exception {return doFinal(pubKey, Mode.ENCRYPT, data);}public static byte[] decryptByPrivateKey(PrivateKey priKey, byte[] data) throws Exception {return doFinal(priKey, Mode.DECRYPT, data);}public static byte[] encryptByPrivateKey(PrivateKey priKey, byte[] data) throws Exception {return doFinal(priKey, Mode.ENCRYPT, data);}public static byte[] decryptByPublicKey(PublicKey pubKey, byte[] data) throws Exception {return doFinal(pubKey, Mode.DECRYPT, data);}public static byte[] sign(PrivateKey priKey, byte[] data) throws Exception {Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);signature.initSign(priKey);signature.update(data);return signature.sign();}public static boolean verify(PublicKey pubKey, byte[] data, byte[] sign) throws Exception {Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);signature.initVerify(pubKey);signature.update(data);return signature.verify(sign);}private enum Mode {ENCRYPT(Cipher.ENCRYPT_MODE),DECRYPT(Cipher.DECRYPT_MODE);private final int value;Mode(int value) {this.value = value;}}private static byte[] doFinal(Key key, Mode mode, byte[] data) throws Exception {final int MAX = (mode == Mode.ENCRYPT) ? MAX_ENCRYPT_BLOCK : MAX_DECRYPT_BLOCK;final int LEN = data.length;byte[] cache;int i = 0, off = 0;ByteArrayOutputStream out = new ByteArrayOutputStream();Cipher cipher = Cipher.getInstance(ALGORITHM_RSA_PKCS1PADDING);cipher.init(mode.value, key);while (off < LEN) {cache = cipher.doFinal(data, off, Math.min(LEN - off, MAX));out.write(cache, 0, cache.length);i++;off = i * MAX;}byte[] result = out.toByteArray();out.close();return result;}}附RSAUtil.java测试代码：import java.security.KeyPair;import java.security.PrivateKey;import java.security.PublicKey;import java.util.Arrays;public class RSATest {public static void main(String[] args) throws Exception {KeyPair keyPair = RSAUtil.genKeyPair();PublicKey publicKey = keyPair.getPublic();PrivateKey privateKey = keyPair.getPrivate();System.err.println("公钥加密——私钥解密");String src = "第⼀次握⼿：Client将标志位SYN置为1，随机产⽣⼀个值seq=J，并将该数据包发送给Server，Client进⼊SYN_SENT状态，等待Server确认。

用java编程实现RSA加密算法RSA加密算法是目前应用最广泛的公钥加密算法，特别适用于通过Internet传送的数据，常用于数字签名和密钥交换。

那么我今天就给大家介绍一下如何利用Java编程来实现RSA加密算法。

一、RSA加密算法描述RSA加密算法是1978年提出的。

经过多年的分析和研究，在众多的公开密钥加密算法中，RSA加密算法最受推崇，它也被推荐为公开密钥数据加密标准。

由数论知识可知，若将一个具有大素数因子的合数进行分解是很困难的，或者说这个问题的计算量是令人望而生畏的，而RSA加密算法正是建立在这个基础上的。

在RSA加密算法中，—个用户A可根据以下步骤来选择密钥和进行密码转换：（1）随机的选取两个不同的大素数p和q（一般为100位以上的十进制数），予以保密；（2）计算n=p*q，作为用户A的模数，予以公开；（3）计算欧拉（Euler）函数z=（p-1）*（q-1），予以保密；（4）随机的选取d与z互质，作为A的公开密钥；（5）利用Euclid算法计算满足同余方程e*d≡1modz的解d，作为用户A的保密密钥；（6）任何向用户A发送信息M的用户，可以用A的公开模数D和公开密钥e根据C=Me mod n得到密文C；RSA加密算法的安全性是基于大素数分解的困难性。

攻击者可以分解已知的n，得到p和q，然后可得到z；最后用Euclid算法，由e和z得到d。

然而要分解200位的数，需要大约40亿年。

二、用Java语言描述RSA加密算法的原理假设我们需要将信息从机器A传到机器B，首先由机器B随机确定一个private_kcy（我们称之为密钥），可将这个private_key始终保存在机器B中而不发出来。

然后，由这个private_key计算出public_key（我们称之为公钥）。

这个public_key的特性是：几乎不可能通过该public_key计算生成它的priyate_key。

接下来通过网络把这个public_key 传给机器A，机器A收到public_key后，利用public_key将信息加密，并把加密后的信息通过网络发送到机器B，最后机器B利用已知的pri.rate_key，就可以解开加密信息。

基于Java的RSA公钥密码算法的实现与探讨摘要：鉴于Java语言在网络上的安全特性和RSA加密算法的优越性，介绍了公钥密码体制的概念和RSA加密算法的原理，并在Java环境下实现RSA公钥密码算法。

关键词：安全体制；Java；公钥密码；RSA算法0 引言随着计算机网络技术的迅速发展，人类已步入数字化的信息时代。

通过网络进行远距离的、快速的信息交流和信息处理已变得越来越普遍。

同时，人们对信息的安全存储、安全处理和安全传输的需求也越来越迫切，但是,由于Internet 网络协议本身存在着重要的安全问题(IP包本身并不继承任何安全特性,很容易伪造出IP包的地址、修改其内容以及在传输途中拦截并查看包的内容),使网上的信息传输存在巨大的安全风险，因而数据安全越来越受到重视，算法工程技术上的实现也就有着重要的意义。

为了解决这一问题，保证数据的保密性，我们可以采用不同的加密算法对数据进行加密。

因为Java语言的安全性和网络处理能力较强，而且RSA加密算法的强大和难破解性，本文主要介绍使用RSA数据加密算法在Java环境下实现数据的安全传输。

1 Java安全体制Java 是Sun 公司开发的一种面向对象的编程语言,并且由于它的平台无关性被大量应用于Internet 的开发。

由于Java 主要用于网络应用程序开发，因此对安全性有较高的要求。

如果没有安全保证，用户从网络下载程序执行就非常危险。

Java通过自己的安全机制防止了病毒程序的产生和下载程序对本地系统的威胁破坏。

当Java字节码进入解释器时，首先必须经过字节码校验器的检查，然后，Java解释器将决定程序中类的内存布局，随后，类装载器负责把来自网络的类装载到单独的内存区域，避免应用程序之间相互干扰破坏。

最后，客户端用户还可以限制从网络上装载的类只能访问某些文件系统。

2 密码体制及RSA公钥密码2.1 公钥密码体制的概念首先我们要理解什么是密码的概念，简单的说它就是一组含有参数k的变换E。

1.RSA加密算法java代码：import java.math.BigInteger;public class RSA {private long p,q,e,d,n;public RSA(){int pIndex = (int)(Math.random()*10);int qIndex;int eIndex;do{qIndex = (int)(Math.random()*10);}while(qIndex==pIndex);do{eIndex = (int)(Math.random()*10);}while(eIndex==pIndex||eIndex==pIndex); p = 1033;q = 2017;e = 29437;n = p*q;d = calculateD();}private long calculateD(){long t0 = 0,t1 = 1,t2 = -1;long r0 = (p-1)*(q-1), m = r0,r1 = e ,r2 = -1; do{long q = r0/r1;r2 = r0-r1*q;if(r2==0)break;t2 = t0 - t1*q;while(t2<0){t2+=m;}if(t2>=m){t2 %= m;}r0 = r1;r1 = r2;t0 = t1;t1 = t2;}while(r2!=0);if(r1!=1){return 0;}else{return t2;}}public long getE() {return e;}public long getN() {return n;}public long getD() {return d;}public BigInteger encode(BigInteger data){ return pow(data,d).mod(new BigInteger(n+"")); }public BigInteger decode(BigInteger code){ return pow(code,e).mod(new BigInteger(n+"")); }public BigInteger pow(BigInteger data,long p){ data = data.pow((int)p);return data;}public static void main(String args[]){RSA rsa = new RSA();BigInteger data = new BigInteger("222222");long oldtime = System.currentTimeMillis();BigInteger code = rsa.encode(data);long newtime = System.currentTimeMillis();double codetime = ((double)(newtime-oldtime))/1000; oldtime = System.currentTimeMillis();BigInteger decode = rsa.decode(code);newtime = System.currentTimeMillis();double decodetime = ((double)(newtime-oldtime))/1000; System.out.println("privateKey:"+rsa.d);System.out.println("publickKey:"+rsa.e);System.out.println("N:"+rsa.n);System.out.println("data:"+data);System.out.println("code:"+code+" time:"+codetime); System.out.println("decode:"+decode+" time:"+decodetime);}}2.运行结果截图：。