基于Java的RSA公钥密码算法的实现与探讨

合集下载

用Java实现RSA加密算法

用Java实现RSA加密算法RSA加密算法是一种常用的非对称加密算法，它是由三位数学家Rivest、Shamir和Adleman共同发明的。

RSA加密算法的安全性源于对公钥的保护，因为在破解RSA加密算法的过程中需要得到私钥，而私钥只有持有者才能拥有。

本文将阐述如何使用Java语言实现RSA加密算法的过程和注意事项。

1. 概述首先，我们需要了解RSA加密算法的基本原理和流程。

RSA加密算法是以两个质数p和q的乘积N为基础进行加密和解密的。

其中，p和q是随机选择的两个质数。

通过选择p和q的值，可以计算出N的值。

在RSA加密算法中，N被称为“模数(m)”。

接着，从p和q中选择两个不同的质数e和d满足以下条件:1. 1<e<(p-1)×(q-1)，e必须是p-1和q-1的最小公倍数。

2. (d×e) mod((p-1)×(q-1))=1。

3. 选择的e和d满足前两个条件，那么e和d就是一对加密密钥和解密密钥。

在RSA加密算法中，加密和解密的过程如下:1. 加密:用户将消息m（明文）使用公钥加密成密文c：c=m^e(mod n),2. 解密:密文c使用私钥解密成明文m：m=c^d(mod n)。

2. 实现过程在Java中实现RSA加密算法需要使用Java Cryptography Extension (JCE)库。

以下为实现的基本步骤:1. 生成RSA密钥对：使用Java的KeyPairGenerator类生成公钥和私钥对。

调用KeyPairGenerator实例的initialize()方法，设置密钥大小（一般是1024位）和随机数源，接着调用generateKeyPair()方法，生成公钥和私钥对。

2. 加密和解密：使用根密钥(KeyPair)的getPublic()方法得到公钥，使用getPrivate()方法得到私钥。

加密和解密使用Java的实现，比如Cipher类。

java中rsa加密原理

java中rsa加密原理
RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，它使用一对密钥来进行加密和解密操作。

在Java中实现RSA加密的原理主要包括以下几个步骤：
1. 密钥生成：RSA算法需要一对密钥，包括一个公钥和一个私钥。

公钥用于加密数据，私钥用于解密数据。

密钥对是通过随机数生成器来生成的，私钥作为随机数的一部分，用于生成公钥。

在Java中，可以使用Java Cryptography Extension (JCE)来实现密钥对的生成。

2. 加密过程：加密过程使用公钥对数据进行加密。

RSA加密的基本原理是将明文数据按照一定的规则进行分组，然后使用公钥对每个分组进行加密。

加密的过程可以看作是使用公钥对每个分组进行一系列数学运算，最终得到密文数据。

在Java中，可以使用Java Cryptography Extension (JCE)提供的RSA加密方法来执行加密操作。

3. 解密过程：解密过程使用私钥对密文数据进行解密。

解密的过程可以看作是使用私钥对每个分组进行一系列数学运算，最终得到明文数据。

在Java 中，可以使用Java Cryptography Extension (JCE)提供的RSA解密方法来执行解密操作。

需要注意的是，由于RSA算法涉及到大量的数学运算和数据分组，因此在实际应用中需要考虑到性能和安全性的问题。

此外，RSA算法还涉及到证书和签名等安全机制，因此在实现过程中需要考虑到这些因素。

浅析用Java编程实现RSA算法的过程

本栏目责任编辑：代影网络通讯及安全浅析用Java 编程实现RSA 算法的过程周君（惠州工程技术学校，广东惠州516000）摘要：随着计算机技术迅速发展，人们已然步入数字化的时代，网络拉进了人与人之间的距离，愈发成熟的网络技术支持使得信息的处理与交流变得迅速且普遍，同时信息的存储与传递安全也一直为人们所追求，Java 致力于开发网络应用程序，对于网络处理能力非常出色，不仅如此，因其对于安全性本身就具有很高要求的特性，加上RSA 算法这种加密算法具有优越性，所以在Java 语言的环境下来实现RSA 算法可谓两全其美。

关键词：Java ；RSA 算法；公开秘钥密码中图分类号：TP311文献标识码：A文章编号：1009-3044(2016)32-0040-03由于Java 语言应用于网络时的安全特性和RSA 算法独具优越性，通过Java 编程去实现RSA 公钥密码算法，需要分析RSA 公钥密码这一体制概念和相应所需数学算法的原理，在数学算法基础上去研究可行性。

公开密钥密码是指使用一对不同的密钥，一个密钥是公开的，另一个是私密的，这种体制是为了验证在知道加密密钥前提时，推算出解密密钥在计算上很难真正实行。

RSA 算法是就目前来说，针对公钥密码十分安全，广泛应用于信息通讯和数字签名方面。

1Java 编程语言1.1Java 语言由来Java 是由Sun 公司根据嵌入式软件的需求，将C++语言进行了更改，开发出的命名为Oak 的面向对象语言更名而来，在1995年Sun 正式发布了Java 和HotJava 浏览器后，IBM ，Apple,微软等各大公司，都争相购买Java 的使用许可证，并建立了相应新的Java 平台来研发自己的产品。

在2006年，Sun 公司宣布要将Java 技术免费让外界使用，在2007年Java 的源代码已可以让任何开发人员使用并修改，为Java 语言的发展和其他语言的诞生奠定了良好的基础。

RSA非对称加密算法实现：Java

RSA⾮对称加密算法实现：Java RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）⼀起提出的。

当时他们三⼈都在⿇省理⼯学院⼯作。

RSA就是他们三⼈姓⽒开头字母拼在⼀起组成的。

RSA解决了对称加密的⼀个不⾜，⽐如AES算法加密和解密时使⽤的是同⼀个秘钥，因此这个秘钥不能公开，因此对于需要公开秘钥的场合，我们需要在加密和解密过程中使⽤不同的秘钥，加密使⽤的公钥可以公开，解密使⽤的私钥要保密，这就是⾮对称加密的好处。

　常⽤的开发语⾔来实现RSA加密：公钥与私钥公钥与私钥是成对的，⼀般的，我们认为的是公钥加密、私钥解密、私钥签名、公钥验证，有⼈说成私钥加密，公钥解密时不对的。

公钥与私钥的⽣成有多种⽅式，可以通过程序⽣成（下⽂具体实现），可以通过openssl⼯具： # ⽣成⼀个私钥，推荐使⽤1024位的秘钥，秘钥以pem格式保存到-out参数指定的⽂件中，采⽤PKCS1格式openssl genrsa -out rsa.pem 1024# ⽣成与私钥对应的公钥，⽣成的是Subject Public Key，⼀般配合PKCS8格式私钥使⽤openssl rsa -in rsa.pem -pubout -out rsa.pub RSA⽣成公钥与私钥⼀般有两种格式：PKCS1和PKCS8，上⾯的命令⽣成的秘钥是PKCS1格式的，⽽公钥是Subject Public Key，⼀般配合PKCS8格式私钥使⽤，所以就可能会涉及到PKCS1和PKCS8之间的转换：# PKCS1格式私钥转换为PKCS8格式私钥，私钥直接输出到-out参数指定的⽂件中openssl pkcs8 -topk8 -inform PEM -in rsa.pem -outform pem -nocrypt -out rsa_pkcs8.pem# PKCS8格式私钥转换为PKCS1格式私钥，私钥直接输出到-out参数指定的⽂件中openssl rsa -in rsa_pkcs8.pem -out rsa_pkcs1.pem# PKCS1格式公钥转换为PKCS8格式公钥，转换后的内容直接输出openssl rsa -pubin -in rsa.pub -RSAPublicKey_out# PKCS8格式公钥转换为PKCS1格式公钥，转换后的内容直接输出openssl rsa -RSAPublicKey_in -pubout -in rsa.pub 现实中，我们往往从pem、crt、pfx⽂件获取公私和私钥，crt、pfx的制作可以参考：，或者使⽤现成的： (提取码：c6tj)，密码都是：123456 Java实现为简化说明介绍，这⾥我直接封装了⼀个⼯具类，因为要从pem、crt、pfx⽂件获取公私和私钥，因此引⽤了⼀个第三⽅包：BouncyCastle，可以直接在pom.xml中添加依赖： <dependency><groupId>org.bouncycastle</groupId><artifactId>bcprov-jdk15on</artifactId><version>1.68</version></dependency> 或者去mvn上下载：简单封装的RsaUtil.java: import java.io.FileInputStream;import java.io.FileReader;import java.io.FileWriter;import java.math.BigInteger;import java.security.KeyFactory;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.KeyStore;import java.security.PrivateKey;import java.security.PublicKey;import java.security.SecureRandom;import java.security.Security;import java.security.Signature;import java.security.cert.Certificate;import java.security.cert.CertificateFactory;import java.security.cert.X509Certificate;import java.security.interfaces.RSAPrivateKey;import java.security.interfaces.RSAPublicKey;import java.security.spec.KeySpec;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.RSAPrivateCrtKeySpec;import java.security.spec.RSAPublicKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.Enumeration;import javax.crypto.Cipher;import org.bouncycastle.asn1.ASN1Integer;import org.bouncycastle.asn1.ASN1Primitive;import org.bouncycastle.asn1.DLSequence;import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;import org.bouncycastle.asn1.x509.AlgorithmIdentifier;import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.bouncycastle.util.io.pem.PemObject;import org.bouncycastle.util.io.pem.PemReader;import org.bouncycastle.util.io.pem.PemWriter;public class RsaUtil {static {Security.addProvider(new BouncyCastleProvider());}/*** 随机⽣成密钥对** @param usePKCS8* 是否采⽤PKCS8填充模式*/public static Object[] generateRsaKey(boolean usePKCS8) throws Exception {KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA", BouncyCastleProvider.PROVIDER_NAME);// 初始化keyPairGen.initialize(1024, new SecureRandom());// ⽣成⼀个密钥对，保存在keyPair中KeyPair keyPair = keyPairGen.generateKeyPair();RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); // 得到私钥RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); // 得到公钥// 这两个公私钥是PKCS8格式的byte[] publicKeyBytes = publicKey.getEncoded();byte[] privateKeyBytes = privateKey.getEncoded();if (!usePKCS8) {// 将PSCK8格式公私钥转换为PKCS1格式publicKeyBytes = pkcs8ToPkcs1(false, publicKeyBytes);privateKeyBytes = pkcs8ToPkcs1(true, privateKeyBytes);}return new Object[] { publicKeyBytes, privateKeyBytes };}/*** 从Pem⽂件读取密钥对** @param reader* 输⼊流* @param pemFileName* pem⽂件*/public static byte[] readFromPem(String pemFileName) throws Exception {PemReader pemReader = new PemReader(new FileReader(pemFileName));PemObject pemObject = pemReader.readPemObject();byte[] publicKey = pemObject.getContent();pemReader.close();return publicKey;}/*** 从Pem⽂件读取密钥** @param isPrivateKey* 是否是私钥* @param buffer* 字节* @param pemFileName* pem⽂件*/public static void writeToPem(byte[] buffer, boolean isPrivateKey, String pemFileName) throws Exception {PemObject pemObject = new PemObject(isPrivateKey ? "RSA PRIVATE KEY" : "RSA PUBLIC KEY", buffer); FileWriter fileWriter = new FileWriter(pemFileName);PemWriter pemWriter = new PemWriter(fileWriter);pemWriter.writeObject(pemObject);pemWriter.close();}/*** 从crt⽂件读取公钥(pkcs8)** @param crtFileName* crt⽂件* @return公钥*/public static byte[] readPublicKeyFromCrt(String crtFileName) throws Exception {CertificateFactory cf = CertificateFactory.getInstance("X.509");X509Certificate cert = (X509Certificate) cf.generateCertificate(new FileInputStream(crtFileName));PublicKey publicKey = cert.getPublicKey();return publicKey.getEncoded();}/*** 从pfx⽂件读取秘钥对(pkcs8)** @param pfxFileName* pfx⽂件* @return秘钥对*/public static Object[] readFromPfx(String pfxFileName, String password) throws Exception {KeyStore keystore = KeyStore.getInstance("PKCS12");char[] passwordChars = null;if (password == null || password.equals("")) {passwordChars = null;} else {passwordChars = password.toCharArray();}keystore.load(new FileInputStream(pfxFileName), passwordChars);Enumeration<String> enums = keystore.aliases();PrivateKey privateKey = null;Certificate certificate = null;while (enums.hasMoreElements()) {String alias = enums.nextElement();System.out.println(alias);if (keystore.isKeyEntry(alias)) {privateKey = (PrivateKey) keystore.getKey(alias, passwordChars);certificate = keystore.getCertificate(alias);}if (privateKey != null && certificate != null)break;}if (privateKey == null || certificate == null) {throw new Exception("fail to read key from pfx");}PublicKey publicKey = certificate.getPublicKey();return new Object[] { publicKey.getEncoded(), privateKey.getEncoded() };}/*** Pkcs8转Pkcs1** @param isPrivateKey* 是否是私钥转换* @param buffer* Pkcs1秘钥* @return Pkcs8秘钥* @throws Exception* 加密过程中的异常信息*/public static byte[] pkcs8ToPkcs1(boolean isPrivateKey, byte[] buffer) throws Exception {if (isPrivateKey) {PrivateKeyInfo privateKeyInfo = PrivateKeyInfo.getInstance(buffer);return privateKeyInfo.parsePrivateKey().toASN1Primitive().getEncoded();} else {SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfo.getInstance(buffer);return subjectPublicKeyInfo.parsePublicKey().toASN1Primitive().getEncoded();}}/*** Pkcs1转Pkcs8** @param isPrivateKey* 是否是私钥转换* @param buffer* Pkcs1秘钥* @return Pkcs8秘钥* @throws Exception* 加密过程中的异常信息*/public static byte[] pkcs1ToPkcs8(boolean isPrivateKey, byte[] buffer) throws Exception {AlgorithmIdentifier algorithmIdentifier = new AlgorithmIdentifier(PKCSObjectIdentifiers.rsaEncryption);ASN1Primitive asn1Primitive = ASN1Primitive.fromByteArray(buffer);if (isPrivateKey) {PrivateKeyInfo privateKeyInfo = new PrivateKeyInfo(algorithmIdentifier, asn1Primitive);return privateKeyInfo.getEncoded();} else {SubjectPublicKeyInfo subjectPublicKeyInfo = new SubjectPublicKeyInfo(algorithmIdentifier, asn1Primitive);return subjectPublicKeyInfo.getEncoded();}}/*** RSA公钥** @param usePKCS8* 是否采⽤PKCS8填充模式* @param publicKey* 公钥* @return公钥* @throws Exception* 加密过程中的异常信息*/public static RSAPublicKey generatePublicKey(boolean usePKCS8, byte[] publicKey) throws Exception {KeySpec keySpec;if (usePKCS8) {// PKCS8填充keySpec = new X509EncodedKeySpec(publicKey);} else {// PKCS1填充DLSequence sequence = (DLSequence) ASN1Primitive.fromByteArray(publicKey);BigInteger v1 = ((ASN1Integer) sequence.getObjectAt(0)).getValue();BigInteger v2 = ((ASN1Integer) sequence.getObjectAt(1)).getValue();keySpec = new RSAPublicKeySpec(v1, v2);}RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA", BouncyCastleProvider.PROVIDER_NAME).generatePublic(keySpec);return pubKey;}/*** RSA私钥** @param usePKCS8* 是否采⽤PKCS8填充模式* @param privateKey* 私钥* @return私钥* @throws Exception* 解密过程中的异常信息*/public static RSAPrivateKey generatePrivateKey(boolean usePKCS8, byte[] privateKey) throws Exception {KeySpec keySpec;if (usePKCS8) {// PKCS8填充keySpec = new PKCS8EncodedKeySpec(privateKey);} else {// PKCS1填充DLSequence sequence = (DLSequence) ASN1Primitive.fromByteArray(privateKey);// BigInteger v1= ((ASN1Integer)sequence.getObjectAt(0)).getValue();BigInteger v2 = ((ASN1Integer) sequence.getObjectAt(1)).getValue();BigInteger v3 = ((ASN1Integer) sequence.getObjectAt(2)).getValue();BigInteger v4 = ((ASN1Integer) sequence.getObjectAt(3)).getValue();BigInteger v5 = ((ASN1Integer) sequence.getObjectAt(4)).getValue();BigInteger v6 = ((ASN1Integer) sequence.getObjectAt(5)).getValue();BigInteger v7 = ((ASN1Integer) sequence.getObjectAt(6)).getValue();BigInteger v8 = ((ASN1Integer) sequence.getObjectAt(7)).getValue();BigInteger v9 = ((ASN1Integer) sequence.getObjectAt(8)).getValue();keySpec = new RSAPrivateCrtKeySpec(v2, v3, v4, v5, v6, v7, v8, v9);}RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA", BouncyCastleProvider.PROVIDER_NAME).generatePrivate(keySpec);return priKey;}/*** RSA公钥加密** @param value* 加密字符串* @param publicKey* 公钥* @return密⽂* @throws Exception* 加密过程中的异常信息*/public static String rsaEncrypt(String value, RSAPublicKey publicKey) throws Exception {if (value == null || value.length() == 0)return "";// RSA加密Cipher cipher = Cipher.getInstance("RSA");cipher.init(Cipher.ENCRYPT_MODE, publicKey);byte[] buffer = cipher.doFinal(value.getBytes("utf-8"));// 使⽤hex格式输出公钥StringBuffer result = new StringBuffer();for (int i = 0; i < buffer.length; i++) {result.append(String.format("%02x", buffer[i]));}return result.toString();}/*** RSA私钥解密** @param value* 加密字符串* @param privateKey* 私钥* @return明⽂* @throws Exception* 解密过程中的异常信息*/public static String rsaDecrypt(String value, RSAPrivateKey privateKey) throws Exception {if (value == null || value.length() == 0)return "";byte[] buffer = new byte[value.length() / 2];for (int i = 0; i < buffer.length; i++) {buffer[i] = (byte) Integer.parseInt(value.substring(i * 2, i * 2 + 2), 16);}// RSA解密Cipher cipher = Cipher.getInstance("RSA");cipher.init(Cipher.DECRYPT_MODE, privateKey);buffer = cipher.doFinal(buffer);return new String(buffer, "utf-8");}/*** RSA签名** @param value* 加密字符串* @param privateKey* 私钥* @param halg* 加密算法，如MD5, SHA1, SHA256, SHA384, SHA512等* @return签名* @throws Exception* 签名过程中的异常信息*/public static String sign(String value, RSAPrivateKey privateKey, String halg) throws Exception {Signature s = Signature.getInstance(halg.toUpperCase().endsWith("WithRSA") ? halg : (halg + "WithRSA"));s.initSign(privateKey);s.update(value.getBytes("utf-8"));byte[] buffer = s.sign();// 使⽤hex格式输出公钥StringBuffer result = new StringBuffer();for (int i = 0; i < buffer.length; i++) {result.append(String.format("%02x", buffer[i]));}return result.toString();}/*** RSA签名验证** @param value* 加密字符串* @param publicKey* 公钥* @param halg* 加密算法，如MD5, SHA1, SHA256, SHA384, SHA512等* @return签名合法则返回true，否则返回false* @throws Exception* 验证过程中的异常信息*/public static boolean verify(String value, RSAPublicKey publicKey, String signature, String halg) throws Exception {Signature s = Signature.getInstance(halg.toUpperCase().endsWith("WithRSA") ? halg : (halg + "WithRSA"));s.initVerify(publicKey);s.update(value.getBytes("utf-8"));byte[] buffer = new byte[signature.length() / 2];for (int i = 0; i < buffer.length; i++) {buffer[i] = (byte) Integer.parseInt(signature.substring(i * 2, i * 2 + 2), 16);}return s.verify(buffer);}}RsaUtil ⽣成公钥和私钥： // ⽣成公私钥Object[] rsaKey = RsaUtil.generateRsaKey(usePKCS8); //usePKCS8=true表⽰是否成PKCS8格式的公私秘钥,否则乘车PKCS1格式的公私秘钥byte[] publicKey = (byte[]) rsaKey[0];byte[] privateKey = (byte[]) rsaKey[1]; ⽣成秘钥后，需要保存，⼀般保存到pem⽂件中： // 保存到pem⽂件，filePath是保存⽬录RsaUtil.writeToPem(publicKey, false, filePath + "rsa.pub");RsaUtil.writeToPem(privateKey, true, filePath + "rsa.pem"); 可以保存到pem⽂件中，当然也可以从pem⽂件中读取了： // 从Pem⽂件读取公私钥，filePath是⽂件⽬录byte[] publicKey = RsaUtil.readFromPem(filePath + "rsa.pub");byte[] privateKey = RsaUtil.readFromPem(filePath + "rsa.pem"); 还可以从crt证书中读取公钥，⽽crt⽂件不包含私钥，因此需要单独获取私钥： // 从crt⽂件读取公钥（crt⽂件中不包含私钥），filePath是⽂件⽬录byte[] publicKey = RsaUtil.readPublicKeyFromCrt(filePath + "demo.crt");byte[] privateKey = RsaUtil.readFromPem(filePath + "demo.key"); pfx⽂件中包含了公钥和私钥，可以很⽅便就读取到： // 从pfx⽂件读取公私钥，filePath是⽂件⽬录Object[] rsaKey = RsaUtil.readFromPfx(filePath + "demo.pfx", "123456");byte[] publicKey = (byte[]) rsaKey[0];byte[] privateKey = (byte[]) rsaKey[1]; 有时候我们还可能需要进⾏秘钥的转换： // Pkcs8格式公钥转换为Pkcs1格式公钥publicKey = RsaUtil.pkcs8ToPkcs1(false, publicKey);// Pkcs8格式私钥转换为Pkcs1格式私钥privateKey = RsaUtil.pkcs8ToPkcs1(true, privateKey);// Pkcs1格式公钥转换为Pkcs8格式公钥publicKey = RsaUtil.pkcs1ToPkcs8(false, publicKey);// Pkcs1格式私钥转换为Pkcs8格式私钥privateKey = RsaUtil.pkcs1ToPkcs8(true, privateKey); 有了公钥和私钥，接下就就能实现加密、解密、签名、验证签名等操作了： RSAPublicKey rsaPublicKey = RsaUtil.generatePublicKey(usePKCS8, publicKey);RSAPrivateKey rsaPrivateKey = RsaUtil.generatePrivateKey(usePKCS8, privateKey);String encryptText = RsaUtil.rsaEncrypt(text, rsaPublicKey);System.out.printf("【%s】经过【RSA】加密后：%s\n", text, encryptText);String decryptText = RsaUtil.rsaDecrypt(encryptText, rsaPrivateKey);System.out.printf("【%s】经过【RSA】解密后：%s\n", encryptText, decryptText);String signature = RsaUtil.sign(text, rsaPrivateKey, "MD5");System.out.printf("【%s】经过【RSA】签名后：%s\n", text, signature);boolean result = RsaUtil.verify(text, rsaPublicKey, signature, "MD5");System.out.printf("【%s】的签名【%s】经过【RSA】验证后结果是：" + result, text, signature); 这⾥完整的demo代码： import java.security.interfaces.RSAPrivateKey;import java.security.interfaces.RSAPublicKey;public class RsaMain {public static void main(String[] args) {try {String text = "上⼭打⽼虎";boolean usePKCS8 = true; // usePKCS8=true表⽰是否成PKCS8格式的公私秘钥,否则乘车PKCS1格式的公私秘钥String filePath = RsaUtil.class.getClassLoader().getResource("").getPath();System.out.printf("⽂件路径：%s\n", filePath);// 存放pem,crt,pfx等⽂件的⽬录byte[] publicKey, privateKey;// 公钥和私钥// ⽣成公私钥Object[] rsaKey = RsaUtil.generateRsaKey(usePKCS8); // usePKCS8=true表⽰是否成PKCS8格式的公私秘钥,否则乘车PKCS1格式的公私秘钥 publicKey = (byte[]) rsaKey[0];privateKey = (byte[]) rsaKey[1];// 从Pem⽂件读取公私钥，filePath是⽂件⽬录// publicKey = RsaUtil.readFromPem(filePath + "rsa.pub");// privateKey = RsaUtil.readFromPem(filePath + "rsa.pem");// 从pfx⽂件读取公私钥，filePath是⽂件⽬录// Object[] rsaKey = RsaUtil.readFromPfx(filePath + "demo.pfx",// "123456");// publicKey = (byte[]) rsaKey[0];// privateKey = (byte[]) rsaKey[1];// 从crt⽂件读取公钥（crt⽂件中不包含私钥），filePath是⽂件⽬录// publicKey = RsaUtil.readPublicKeyFromCrt(filePath + "demo.crt");// privateKey = RsaUtil.readFromPem(filePath + "demo.key");// 保存到pem⽂件，filePath是保存⽬录RsaUtil.writeToPem(publicKey, false, filePath + "rsa.pub");RsaUtil.writeToPem(privateKey, true, filePath + "rsa.pem");// Pkcs8格式公钥转换为Pkcs1格式公钥publicKey = RsaUtil.pkcs8ToPkcs1(false, publicKey);// Pkcs8格式私钥转换为Pkcs1格式私钥privateKey = RsaUtil.pkcs8ToPkcs1(true, privateKey);// Pkcs1格式公钥转换为Pkcs8格式公钥publicKey = RsaUtil.pkcs1ToPkcs8(false, publicKey);// Pkcs1格式私钥转换为Pkcs8格式私钥privateKey = RsaUtil.pkcs1ToPkcs8(true, privateKey);RSAPublicKey rsaPublicKey = RsaUtil.generatePublicKey(usePKCS8, publicKey);RSAPrivateKey rsaPrivateKey = RsaUtil.generatePrivateKey(usePKCS8, privateKey);String encryptText = RsaUtil.rsaEncrypt(text, rsaPublicKey);System.out.printf("【%s】经过【RSA】加密后：%s\n", text, encryptText);String decryptText = RsaUtil.rsaDecrypt(encryptText, rsaPrivateKey);System.out.printf("【%s】经过【RSA】解密后：%s\n", encryptText, decryptText);String signature = RsaUtil.sign(text, rsaPrivateKey, "MD5");System.out.printf("【%s】经过【RSA】签名后：%s\n", text, signature);boolean result = RsaUtil.verify(text, rsaPublicKey, signature, "MD5");System.out.printf("【%s】的签名【%s】经过【RSA】验证后结果是：" + result, text, signature);} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}}}。

用java编程实现RSA加密算法

用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，就可以解开加密信息。

rsa 公钥密码算法

rsa 公钥密码算法摘要：一、RSA 公钥密码算法简介二、RSA 算法的生成过程1.随机生成两个素数P 和Q2.计算N、E 和D三、RSA 算法的加密和解密过程1.加密过程2.解密过程四、RSA 算法的Java 实现正文：RSA 公钥密码算法是一种非常常见的加密算法，其安全性高、可靠性好，被广泛应用于各种网络通信和数据存储场景。

下面我们将详细介绍RSA 公钥密码算法的生成过程、加密和解密过程以及Java 实现。

一、RSA 公钥密码算法简介RSA 公钥密码算法是一种非对称加密算法，即加密和解密所使用的密钥不同。

它由美国计算机科学家RSA（Rivest-Shamir-Adleman）三人于1977 年提出，是一种基于大数因子分解的算法。

二、RSA 算法的生成过程RSA 算法的生成过程主要分为以下几个步骤：1.随机生成两个素数P 和Q在RSA 算法中，我们需要选择两个大素数P 和Q，这两个素数是用来生成公钥和私钥的。

素数是指只能被1 和本身整除的正整数，且越大越难被分解。

2.计算N、E 和D根据P 和Q，我们可以计算出N、E 和D。

其中，N = P * Q，E 是一个与T（T = P * Q - 1）互质的正整数，且E 小于T；D 是满足D * E mod T = 1 的整数。

3.RSA 算法的加密和解密过程RSA 算法的加密和解密过程分为以下两个步骤：1.加密过程在加密过程中，发送方使用接收方的公钥（N、E）对明文进行加密。

加密公式为：M = C * E mod N，其中M 为密文，C 为明文。

2.解密过程在解密过程中，接收方使用自己的私钥（N、D）对密文进行解密。

解密公式为：M = C * D mod N，其中M 为明文，C 为密文。

三、RSA 算法的Java 实现在Java 中，我们可以通过以下步骤实现RSA 算法：1.创建一个RSA 类，其中包含N、E 和D 三个属性。

2.在RSA 类中，实现createKey() 方法，用于生成RSA 密钥。

基于Java的RSA公钥密码算法的实现与探讨

基于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。

基于JAVA的RSA文件加密软件的设计与实现

基于JAVA的RSA文件加密软件的设计与实现基于JAVA的RSA文件加密软件的设计与实现分析RSA算法的应用现状，论证文件加密应用RSA算法的可行性和意义。

设计一套完整实用的RSA文件加密解决方案，具体编码实现。

对RSA算法进行研究，从常规RSA算法出发，用C++实现RSA加密算法类库，并在32位windows平台封装成组件。

在.Net平台引用此组件，实现可以对任意文件进行RSA加密操作的窗体应用程序。

经过加密的文件以及密钥文件都是文本文件。

给出关键类类图、整个应用程序的结构描述文档、关键模块流程图、较详细的接口文档、所有源代码。

对应用程序进行测试，对测试结果进行分析研究，进而对应用程序进行改进，对关键算法进行尽可能的优化，最终得到一个在windows运行的可以用指定密钥对任意文件进行RSA加密并可解密的完整应用程序，和一些相关的可移植组件。

关键词RSA RSA算法文件加密加密成文本目录前言 (3)第1章RSA应用现状及应用于文件加密的分析 (4)1.1 RSA算法介绍与应用现状 (4)1.2 RSA应用于文件加密的分析 (5)1.2.1 文件加密使用RSA的可行性 (5)1.2.2 文件加密使用RSA的意义 (6)第2章RSA文件加密软件的设计与实现 (8)2.1 需求分析与总体设计 (8)2.1.1 功能分析 (8)2.1.2 工程方案选择 (9)2.2 各部分的设计与开发 (10)2.2.1 实现RSA加密算法的C++核心类库 (10)2.2.2 封装C++核心类库的DLL组件 (20)2.2.3 引用DLL的.Net类与实现文件操作功能的窗体应用程序 (21)第3章软件整体测试与分析改进 (22)3.1 编写测试各项性能需要的精确计时类 (22)3.2 测试数据与分析改进 (22)3.2.1 密钥生成测试 (22)3.2.2 数据输入输出测试 (25)3.2.3 加密解密测试 (25)3.2.4 性能分析与改进优化 (28)3.3 使用中国余数定理 (29)第4章可移植模块的简要说明与开发前景 (31)结束语 (32)前言RSA公钥加密算法是第一个既能用于数据加密也能用于数字签名的算法。

java加密之RSA算法加密与解密的实例详解

java加密之RSA算法加密与解密的实例详解java 加密之RSA算法加解密与解密的实例详解前⾔：RSA是第⼀个⽐较完善的公开密钥算法，它既能⽤于加密，也能⽤于数字签名。

RSA以它的三个发明者Ron Rivest, Adi Shamir, Leonard Adleman的名字⾸字母命名，这个算法经受住了多年深⼊的密码分析，虽然密码分析者既不能证明也不能否定RSA的安全性，但这恰恰说明该算法有⼀定的可信性，⽬前它已经成为最流⾏的公开密钥算法。

RSA的安全基于⼤数分解的难度。

其公钥和私钥是⼀对⼤素数（100到200位⼗进制数或更⼤）的函数。

从⼀个公钥和密⽂恢复出明⽂的难度，等价于分解两个⼤素数之积（这是公认的数学难题）。

RSA加密与解密RSA算法的密钥由公钥和私钥组成，公钥⽤于加密，私钥⽤于解密。

顾名思义，公钥就是可以进⾏公开的密钥，⼀般可以公开给你的合作伙伴；私钥就是私有的，也就是只有你知道的，你的合作伙伴通过你提供的公钥进⾏加密的内容只有你能进⾏解密，这样也就只有你知道他发的是什么内容。

⽤于加密的公钥和私钥是配对的。

这样的⼀对密钥在Java中由java.security.KeyPairGenerator来产⽣。

以下是⼀个⽣成密钥对的⽰例，该⽰例中还将⽣成的密钥对分别保存到了⽂件中。

private static final String ALGORITHM = "RSA";private static final String PRIVATE_KEY_PATH = "D:\\rsa_private.isa";private static final String PUBLIC_KEY_PATH = "D:\\rsa_public.isa";/*** ⽣成公钥和私钥并存储到⽂件中* @throws Exception*/@Testpublic void geneKeyPair() throws Exception {KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);keyPairGenerator.initialize(1024);KeyPair keyPair = keyPairGenerator.generateKeyPair();PrivateKey privateKey = keyPair.getPrivate();//私钥PublicKey publicKey = keyPair.getPublic();//公钥byte[] privateKeyBytes = privateKey.getEncoded();//私钥对应的字节数组byte[] publicKeyBytes = publicKey.getEncoded();//公钥对应的字节数组Files.write(Paths.get(PRIVATE_KEY_PATH), privateKeyBytes);Files.write(Paths.get(PUBLIC_KEY_PATH), publicKeyBytes);}加密加密的过程跟使⽤AES算法进⾏加密的过程类似，唯⼀需要注意的是使⽤存储起来的公钥时需要使⽤X509EncodedKeySpec 进⾏封装，然后通过KeyFactory.generatePublic(KeySpec)进⾏⽣成。

基于JAVA的RSA文件加密软件的设计与实现

基于JAVA的RSA文件加密软件的设计与实现分析RSA算法的应用现状，论证文件加密应用RSA算法的可行性和意义。

设计一套完整实用的RSA文件加密解决方案，具体编码实现。

对RSA算法进行研究，从常规RSA算法出发，用C++实现RSA加密算法类库，并在32位windows平台封装成组件。

在.Net平台引用此组件，实现可以对任意文件进行RSA加密操作的窗体应用程序。

经过加密的文件以及密钥文件都是文本文件。

给出关键类类图、整个应用程序的结构描述文档、关键模块流程图、较详细的接口文档、所有源代码。

RSA加密算法java简单实现方法（必看）

RSA加密算法java简单实现⽅法（必看）简单完整的代码，通过这个代码你将对RSA加密算法在Java中的实现⽅法有⼀个初步的了解，这个类，你可以直接使⽤，⽔平⾼的，就⾃⼰修改完善下代码。

package security;import java.security.*;import java.security.spec.*;import java.security.interfaces.*;import javax.crypto.spec.*;import javax.crypto.interfaces.*;import java.io.*;import java.math.*;public class RSADemo {public RSADemo() {}public static void generateKey() {try {KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");kpg.initialize(1024);KeyPair kp = kpg.genKeyPair();PublicKey pbkey = kp.getPublic();PrivateKey prkey = kp.getPrivate();// 保存公钥FileOutputStream f1 = new FileOutputStream("pubkey.dat");ObjectOutputStream b1 = new ObjectOutputStream(f1);b1.writeObject(pbkey);// 保存私钥FileOutputStream f2 = new FileOutputStream("privatekey.dat");ObjectOutputStream b2 = new ObjectOutputStream(f2);b2.writeObject(prkey);} catch (Exception e) {}}public static void encrypt() throws Exception {String s = "Hello World!";// 获取公钥及参数e,nFileInputStream f = new FileInputStream("pubkey.dat");ObjectInputStream b = new ObjectInputStream(f);RSAPublicKey pbk = (RSAPublicKey) b.readObject();BigInteger e = pbk.getPublicExponent();BigInteger n = pbk.getModulus();System.out.println("e= " + e);System.out.println("n= " + n);// 获取明⽂mbyte ptext[] = s.getBytes("UTF-8");BigInteger m = new BigInteger(ptext);// 计算密⽂cBigInteger c = m.modPow(e, n);System.out.println("c= " + c);// 保存密⽂String cs = c.toString();BufferedWriter out =new BufferedWriter(new OutputStreamWriter(new FileOutputStream("encrypt.dat")));out.write(cs, 0, cs.length());out.close();}public static void decrypt() throws Exception {// 读取密⽂BufferedReader in =new BufferedReader(new InputStreamReader(new FileInputStream("encrypt.dat")));String ctext = in.readLine();BigInteger c = new BigInteger(ctext);// 读取私钥FileInputStream f = new FileInputStream("privatekey.dat");ObjectInputStream b = new ObjectInputStream(f);RSAPrivateKey prk = (RSAPrivateKey) b.readObject();BigInteger d = prk.getPrivateExponent();// 获取私钥参数及解密BigInteger n = prk.getModulus();System.out.println("d= " + d);System.out.println("n= " + n);BigInteger m = c.modPow(d, n);// 显⽰解密结果System.out.println("m= " + m);byte[] mt = m.toByteArray();System.out.println("PlainText is ");for (int i = 0; i < mt.length; i++) {System.out.print((char) mt[i]);}}public static void main(String args[]) {try {generateKey();encrypt();decrypt();} catch (Exception e) {System.out.println(e.toString());}}}以上这篇RSA加密算法java简单实现⽅法(必看)就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。

java rsa加密算法原理

java rsa加密算法原理
Java RSA是一种非对称加密算法，它是目前广泛使用的公钥加密算法之一，RSA算法基于大数因子分解的数学难题，加密算法原理：
1.随机选择两个不同的大素数p和q，计算n=p*q，n被称为模数。

2.计算欧拉函数φ(n)=(p-1)*(q-1)。

3.选择一个小于φ(n)且与φ(n)互质的整数e，e被称为公钥指数。

4.计算满足以下条件的整数d，d被称为私钥指数，公钥由(n,e)组成，私钥由
(n,d)组成。

5.加密时，将明文m转换为整数M，然后使用公式C=M^e mod n对明文进
行加密，得到密文C。

6.解密时，使用私钥指数d，对密文C进行解密得到明文M，再将M转换为
明文m。

RSA算法的安全性基于大素数因子分解问题的难度，即找到n的两个大素数因子p和q。

当前，只要使用足够大的密钥长度，如2048位或以上，RSA算法被认为是安全的。

RSA算法不仅可以用于加密和解密数据，还可以用于数字签名、密钥协商和密钥交换等密码学应用。

RSA公钥加密算法的设计与实现本科毕业论文

RSA公钥加密算法的设计与实现本科毕业论⽂RSA公钥加密算法的设计与实现RSA公钥加密算法的设计与实现【论⽂摘要】RSA公钥加密算法是⽬前最有影响⼒的⾮对称加密算法，为ISO的推荐的加密标准。

⽽⾮对称加密因其安全性、开放性以及在数字签名技术中的重要性，在我们的⽣活中被使⽤得越加频繁。

RSA的安全性建⽴在⼤整数的分解困难上，其基本原理是初等数论中的欧拉定理。

在⼯业实现上，为了保证加密的安全性，通常要求密钥对⼤于1Kbits，然⽽计算机的整型变量为32bits，这构成⼀个⽭盾。

此外，RSA密钥的⽣成需要产⽣随机的⼤素数，这也是本⽂需要解决的问题。

【关键词】RSA；⾮对称加密；素数The d esign and implementation of RSA public keyencryption algorithm【ABSTRACT】RSA public key encryption algorithms are the most influential dissymmetrical encryption algorithms, the recommended encryption standard to ISO. And dissymmetrical encryption is used more and more frequently in our lives because of its security, openness and the importance in digital signature technology.RSA's security is built on the difficulties of big integer factorization, whose basic principle is the Euler's theorem in elementary number theory. In order to ensure the security of encryption, when it comes to industry, we often require the key pair is greater than 1Kbits. However, the integer class of computers occupies 32bits, which constitutes a contradiction. In addition, RSA's key-generation needs a random large prime number, which is also a problem to be solved.【Keywords】RSA; dissymmetrical encryption; prime number⽬录RSA公钥加密算法的设计与实现 ...................... II The design and implementation of RSA public key encryption algorithm .............................................. II ⽬录............................................... III ⼀．前⾔ (1)（⼀）引论 (1)（⼆）背景知识 (2)1. 密码技术的发展 (2)2. 密码学的主要任务 (4)3. 密码系统的安全性 (5)4. 对称与⾮对称密码的区别 (5)5. 公钥：RSA密码体制 (6)⼆、实验部分 (8)（⼀）实验⽬的 (8)（⼆）实验环境 (8)（三）实验步骤 (8)1. ⼤整数类 (8)2. 快速模幂运算 (9)3. 快速产⽣随机素数 (9)4. 扩展的欧⼏⾥德算法 (10)（四）代码设计 (11)1. ⼤整数类 (11)2. Rsa类 (14)3. 关键代码 (16)三、结果与讨论 (17)（⼀）程序展⽰ (17)1. 程序主界⾯ (17)2. RSA密钥产⽣ (18)3. 加密解密展⽰ (20)（⼆）RSA分析 (21)1. RSA的安全性 (21)2. RSA效率 (22)（三）⼩结 (24)注释 (25)参考⽂献 (26)致谢 (27)⼀．前⾔（⼀）引论从公元前5世纪，古希腊斯巴达⼈⽤⽊棍和带⼦进⾏换位密码，到现在的⽹上购物、⽹上银⾏，密码学在我们⽣活中占着越来越重要的地位。

java实现的RSA加密算法详解

java实现的RSA加密算法详解本⽂实例讲述了java实现的RSA加密算法。

分享给⼤家供⼤家参考，具体如下：⼀、什么是⾮对称加密1、加密的密钥与加密的密钥不相同，这样的加密算法称之为⾮对称加密2、密钥分为：公钥，私钥公钥：可以对外给任何⼈的加密和解密的密码，是公开的私钥：通过私钥可以⽣成公钥，但从公钥被认为⽆法⽣成公钥（被推导出的概率⼩到不考虑）3、当将要加密的内容⽤公钥加密的时候，只能⽤私钥来解密当将要加密的内容⽤私钥加密的时候，只能⽤公钥来解密4、公钥与私钥的关系，利⽤⼀个简单的公式来⽣成公钥和私钥，即⾮对称加密的公钥和私钥之间存在某⼀个公式关系5、常见的⾮对称加密算法RSA，DSA⼆、什么是RSA算法RSA算法是⼀种⾮对称密码算法，所谓⾮对称，就是指该算法需要⼀对密钥，使⽤其中⼀个加密，则需要⽤另⼀个才能解密。

RSA的算法涉及三个参数，n、e1、e2。

其中，n是两个⼤质数p、q的积，n的⼆进制表⽰时所占⽤的位数，就是所谓的密钥长度。

e1和e2是⼀对相关的值，e1可以任意取，但要求e1与(p-1）*(q-1）互质；再选择e2，要求（e2*e1）mod((p-1）*(q-1））=1。

（n，e1）,(n，e2）就是密钥对。

其中(n，e1）为公钥，(n，e2）为私钥。

RSA加解密的算法完全相同，设A为明⽂，B为密⽂，则：A=B^e2 mod n；B=A^e1 mod n；（公钥加密体制中，⼀般⽤公钥加密，私钥解密）e1和e2可以互换使⽤，即：A=B^e1 mod n；B=A^e2 mod n;三、RSA加密算法的使⽤1、RSA密钥的⽣成，返回⼀个KeyPair对象KeyPair ⽤于⾮对称加密，KeyPair中包含了⼀个公钥和⼀个私钥/*** 通过指定的密钥长度⽣成⾮对称的密钥对* @param keySize 推荐使⽤1024,2048 ，不允许低于1024* @return*/public static KeyPair generateRSAKeyPair(int keySize){KeyPair ret = null;try {//1、准备⽣成KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");//2、初始化，设置秘钥长度generator.initialize(keySize);//3、⽣成，并且返回ret = generator.generateKeyPair();} catch (NoSuchAlgorithmException e) {e.printStackTrace();}return ret;}2、获取私钥和公钥PublicKey 和 PrivateKey 都是Key类型的KeyPair keyPair = EncryptUtil.generateRSAKeyPair(1024); //获取公钥，可以给任何⼈PublicKey publicKey = keyPair.getPublic();//获取私钥PrivateKey privateKey = keyPair.getPrivate();3、RSA加密/*** RSA 加密* @param data 需要加密的数据* @param key 可以是 PublicKey,也可以是PrivateKey* @return*/public static byte[] rsaEncrypt(byte[] data ,Key key){byte[] ret = null;if (data != null&& data.length>0&& key!=null) {// 1、创建Cipher 使⽤RSAtry {Cipher cipher = Cipher.getInstance("RSA");//设置Keycipher.init(Cipher.ENCRYPT_MODE,key);ret = cipher.doFinal(data);} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (NoSuchPaddingException e) {e.printStackTrace();} catch (InvalidKeyException e) {e.printStackTrace();} catch (BadPaddingException e) {e.printStackTrace();} catch (IllegalBlockSizeException e) {e.printStackTrace();}}return ret;}4、RSA解密/*** RSA 解密* @param data 要解密的数据* @param key 可以是 PublicKey,也可以是PrivateKey* @return*/public static byte[] rsaDecrypt(byte[] data ,Key key){byte[] ret = null;if (data != null&& data.length>0&& key!=null) {// 1、创建Cipher 使⽤RSAtry {Cipher cipher = Cipher.getInstance("RSA");//设置Keycipher.init(Cipher.DECRYPT_MODE,key);ret = cipher.doFinal(data);} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (NoSuchPaddingException e) {e.printStackTrace();} catch (InvalidKeyException e) {e.printStackTrace();} catch (BadPaddingException e) {e.printStackTrace();} catch (IllegalBlockSizeException e) {e.printStackTrace();}}return ret;}5、公钥与私钥的存储⼀对公钥和私钥创建好之后，我们需要存储起来以后使⽤//获得公钥私钥PrivateKey privateKey = keyPair.getPrivate();PublicKey publicKey = keyPair.getPublic();//编码将PublicKey和PrivateKey对象转换为字节数组，该字节数组为公钥、私钥的实际数据byte[] publicKeyEncoded = publicKey.getEncoded();byte[] privateKeyEncoded = privateKey.getEncoded();//将字节数组通过Base64编码算法编码成可见的字符形式String publickey = Base64.encodeToString(publicKeyEncoded, Base64.NO_WRAP);String privatekey = Base64.encodeToString(privateKeyEncoded, Base64.NO_WRAP);//进⾏存储操作。

基于JAVA的RSA数据加密器的设计与实现

理是一个非常重要的问题。在对称加密中：

对称加密算法中，有一个密钥用来只加密和解密信息。管单密钥加密是一个尽对方，都持有这个密钥的备份。但要达并建立信任关系时可能一个安全破坏已经
别人给你发送信息时使用ｄ加密，这Ｂｇｎｅｅ（ｅｌ．ｅｄｉｅ）６；ｉＩｔｇｒｋｙｎｒａＬｎ（，１）ＲＡ的安全性在于对于一个大数，Ｂｇｎｅｅ（ｅｌ．ｅｄｉｅ）１）ＳｉＩｔｇｒｋｙｎｒａＬｎ（，６；
题，果它被截取，么这个密钥以及相如那
，个数构成公钥，以告诉别人；Ｂｆｒｄａｅｄ两可ｕｅｅＲｅｄｒ，个数构成私钥，ｅ两ｅ自己保留，不（ＦｌＮｒｅ）ｐｉａｎ）；ｅ
（ｎｗｅ
ＦｌａｅｉＲｅｄｒｅ
维普资讯
・７・（４８４总４）
基于ＪＡＶＡ的ＲＡ数据加密器的设计与实现Ｓ
２００７拒
基于ＪＶ的ＲＡ数据加密器的设计与实现ＡＡＳ
广东松山职业技术学院王浩亮
在保障信息安全诸多技术中，码技（一）口１，任何一个数ｅ要求满足２２密钥的读取ＲｗＳＫｅ．ａａ密１＊（一）取，．ａＲＡｙｊｖ术是信息安全的核心和关键。过数据加ｅ￡且ｅ与ｔ素（是最大公因数为通＜并互就密技术，以在一定程度上提高数据传输１，ｄ＊％一１这样最终得到三个可）取Ｐ一，数据加密系统包括加密算法、明文、文一（＊＊ｅ％就得到了加密后的消息密）以及密钥，钥控制加密和解密过程，密一ｃ设ｍ一（＊＊）则ｍ一一Ｍ，而，ｃ％从 ① 相关ＡＰＩｊｖ．ｔ．ｉＩｔｇｒ不可变的任意ａａｍａｈＢｇｎｅｅ： ② 重要源码ｐｂｉｕｌｃＩｘｅｔｎ｛ＯＥｃｐｉｏ

Java中使用RSA算法加密

Java中使⽤RSA算法加密Java中使⽤RSA算法加密概述RSA加密算法是⼀种⾮对称加密算法RSA加密的⽅式使⽤公钥加密的数据,利⽤私钥进⾏解密使⽤私钥加密的数据,利⽤公钥进⾏解密RSA是⼀对密钥。

分别是公钥和私钥,这个公钥和私钥其实就是⼀组数字!其⼆进制位长度可以是1024位或者2048位.长度越长其加密强度越⼤,⽬前为⽌公之于众的能破解的最⼤长度为768位密钥,只要⾼于768位,相对就⽐较安全.RSA加密的缺点由于RSA算法的原理都是⼤数计算，使得RSA最快的情况也⽐对称加密算法慢上好⼏倍。

public class RSAUtils {public static String RSA_ALGORITHM = "RSA";public static String UTF8 = "UTF-8";/*** 密钥长度，DSA算法的默认密钥长度是1024* 密钥长度必须是64的倍数，在512到65536位之间* */private static final int KEY_SIZE=1024;public static void main(String[] args) throws Exception {String password = "1234abcd5678";KeyStore keys = createKeys();byte[] publicKey = getPublicKey(keys);byte[] privateKey = getPrivateKey(keys);System.out.println("公钥："+Base64.encode(publicKey));System.out.println("私钥："+ Base64.encode(privateKey));byte[] encryptByPublicKey = encryptByPublicKey(password.getBytes(), publicKey);System.out.println("使⽤公钥加密后的数据："+Base64.encode(encryptByPublicKey));byte[] decryptByPrivateKey = decryptByPrivateKey(encryptByPublicKey, privateKey);System.out.println("使⽤私钥解密后的数据："+new String(decryptByPrivateKey));}/*** ⽣成密钥对* @return 密钥对对象* @throws NoSuchAlgorithmException*/public static KeyStore createKeys() throws NoSuchAlgorithmException {//KeyPairGenerator⽤于⽣成公钥和私钥对。