rsa加密解密demo

㈠ 请问有没有c或c加加的openssl的rsa分段加密例子demo超过117个字节的明文

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<openssl/rsa.h>
#include<openssl/engine.h>

intmain(intargc,char*argv[])
{
printf("openssl_testbegin
");
RSA*rsa=NULL;
charoriginstr[]="hello
";//这是我们需要加密的原始数据
//allocateRSAstructure，首先需要申请一个RSA结构题用于存放生成的公私钥，这里rsa就是这个结构体的指针
rsa=RSA_new();
if(rsa==NULL)
{
printf("RSA_newfailed
");
return-1;
}

//generateRSAkeys
BIGNUM*exponent;
exponent=BN_new();//生成RSA公私钥之前需要选择一个奇数（oddnumber）来用于生成公私钥
if(exponent==NULL)
{
printf("BN_newfailed
");
gotoFAIL1;
}
if(0==BN_set_word(exponent,65537))//这里选择奇数65537
{
printf("BN_set_wordfailed
");
gotoFAIL1;
}


//这里molus的长度选择4096，小于1024的molus长度都是不安全的，容易被敬薯裂破解
if(0==RSA_generate_key_ex(rsa,4096,exponent,NULL))
{
printf("RSA_generate_key_exfailed
");亮闭
gotoFAIL;
}
char*cipherstr=NULL;
//分配一段空间用于存储加密后的数据，这个空间的大小由RSA_size函数根据rsa算出
cipherstr=malloc(RSA_size(rsa));
if(cipherstr==NULL)
{
printf("malloccipherstrbuffailed
");
gotoFAIL1;
}
//下面是实际的加密过程，最后一个参数paddingtype，有以下几种。
/*
RSA_PKCS1_PADDINGPKCS#1v1.5padding..
RSA_PKCS1_OAEP_PADDING
EME-OAEPasdefinedinPKCS#1v2.0withSHA-1,..
RSA_SSLV23_PADDING
PKCS#1v1.5paddingwithanSSL-.
RSA_NO_PADDING
RawRSAencryption.ntheapplicationcode..
*/
//这里首先用公钥进行加密，选择了RSA_PKCS1_PADDING

if(RSA_size(rsa)!=RSA_public_encrypt(strlen(originstr)+1,originstr,cipherstr,rsa,RSA_PKCS1_PADDING))
{
printf("encryptionfailure
");
gotoFAIL2;
}
printf("theoriginalstringis%s
",originstr);
printf("theencryptedstringis%s
",cipherstr);


//Now,let'
//下面来用私钥解密，首先需要一个buffer用于存储解密后的数据，这个buffer的长度要足够（小于RSA_size(rsa)）
//这里分配一个长度为250的字符数组，手州应该是够用的。
chardecrypted_str[250];
intdecrypted_len;
if(-1=(decrypted_len=RSA_private_decrypt(256,cipherstr,decrypted_str,rsa,RSA_PKCS1_PADDING)))
{
printf("decryptionfailure
");
gotoFAIL2;
}
printf("decryptedstringlengthis%d,decryped_stris%s
",decrypted_len,decrypted_str);
FAIL2:
free(cipherstr);
FAIL1:
BN_free(exponent);
FAIL:
RSA_free(rsa);
return0;
}

以上是源代码，下面使用下面的编译命令在源码所在路径下生成可执行文件
gcc *.c -o openssl_test -lcrypto -ldl -L/usr/local/ssl/lib -I/usr/local/ssl/include
其中，-lcrypto和-ldl是必须的，前者是OpenSSL中的加密算法库，后者是用于成功加载动态库。

㈡ RSA加密、解密、签名、验签的原理及方法

RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。

加密和签名都是为了安全性考虑，但略有不同。常有人问加密和签名是用私钥还是公钥？其实都是对加密和签名的作用有所混淆。简哪睁单的说，加密是为了防止信息被泄露，而签名是为了防止信息被篡改。这里举2个例子说明。

RSA的加密过程如下：

RSA签名的过程如下：

总结：公钥加密、私钥解密、私钥签名、公钥验签。

RSA加密对明文的长度有所限制，规定需加密的明文最大长度=密钥长度-11（单位是字节，即byte），所以在加密和解密的过程中需要分块进行。而密钥默认是1024位，即1024位/8位-11=128-11=117字节。所以默认加密前的明文最大长度117字节，解密密文最大长度为128字。那指知么李逗岁为啥两者相差11字节呢？是因为RSA加密使用到了填充模式（padding），即内容不足117字节时会自动填满，用到填充模式自然会占用一定的字节，而且这部分字节也是参与加密的。

㈢ RSA 加密解密

RSA 是一种非对称加密算法，很多表单的密码都采用 RSA 加密。
使用 RSA 一般需要先产生一对公钥和私钥，当采用公钥丛橘毕伍宽加密时，使用私钥解密；采用私钥加密时，使用公钥解密。

执行结果如下：

在实际应用中，我们可以先执行 genKeyPair 先生成一对密钥，将该对密钥保存在配置文件中，然后在加密时，调用 encrypt(str, publicKey) 方法使用公钥对文本进行加密，在解密时，调用 decrypt(strEn, privateKey) 方法使用私钥对文本进行解密，渗芹即可。

㈣ 用RSA对下列数据实现加密和解密:

分类: 电脑/网络 >> 程序设计 >> 其他编程语言
问题描述:

用RSA对下列数据实现加密和解密:

a. p=3,q=11,e=7;M=5

b. p=7,q=11,e=3;M=9

解析:

拜托:老大,你的家庭作业也来问?

你自己学吧:下面是课文^

RSA加密算法

该算法于1977年由美国麻省理工学院MIT(Massachusetts Institute of Technology)的Ronal Rivest，Adi Shamir和Len Adleman三位年轻教授提出，并以三人的姓氏Rivest，Shamir和Adlernan命名为RSA算法。该算法利用了数论领域的一个事实，那就是虽然把两个大质数相乘生成一个合数是件十分容易的事情，但要把一个合数分解为两个质数却十分困难。合数分解问题目前仍然是数学领域尚未解决的一大难题，至今没有任何高效的分解方法。与Diffie-Hellman算法相比，RSA算法具有明显的优越性，因为它无须收发双方同时参与加密过程，且非常适合于电子函件系统的加密。

RSA算法可以表述如下：

(1) 密钥配制。假设m是想要传送的报文，现任选两个很大的质数p与q，使得：

(12-1)；

选择正整数e，使得e与(p－1)(q－1)互质；这里(p－1)(q－1)表示二者相乘。再利用辗转相除法，求得d，使得：

(12-2)；

其中x mod y是整数求余运算，其结果是x整除以y后剩余的余数，如5 mod 3 = 2。

这样得：

(e，n)，是用于加密的公共密钥，可以公开出去；以及

(d，n)，是用于解密的专用钥匙，必须保密。

(2) 加密过程。使用(e，n)对明文m进行加密，算法为：

(12-3)；

这里的c即是m加密后的密文。

(3) 解密过程。使用(d，n)对密文c进行解密，算法为：

(12-4)；

求得的m即为对应于密文c的明文。

RSA算法实现起来十分简捷，据说英国的一位程序员只塌仔用了3行Perl程序便实现了加密和解密运算。

RSA算法建立在正整数求余运算基础之上，同时还保持了指数运算的性质，这一点我们不难证明。例如：

(12-5)；

(12-6)。

RSA公共密钥加密算法的核心是欧拉(Euler)函数ψ。对于正整数n，ψ(n)定义为小于n且与n互质的正整数的个数。例如ψ(6) = 2，这是因为小于6且与6互质的数有1和5共两个数；再如ψ(7) = 6，这是因为互质数有1，2，3，5，6共6个。

欧拉在公元前300多年就发现了ψ函数的一个十分有趣的性质，那就是对于任意小于n且与n互质的正整数m，总有mψ(n) mod n = 1。例如，5ψ(6) mod 6 = 52 mod 6= 25 mod 6 =1。也就是说，在对n求余的运算下，ψ(n)指数具有周期性。

当n很小时，计算ψ(n)并不难，使用穷举法即可求出；但当n很大时，计算ψ(n)就十分困难了，其运算量与判断n是否为质数的情况相当。不过在特殊情况下，利用ψ函数的两个性质，可以极大地减少运算量。

性质1：如果p是质数，则ψ(p) = (p－1)。

性质2：如果p与q均为质数，则ψ(p·q) = ψ(p)·ψ(q) = (p－1)(q－1)。

RSA算法正是注意到这两条性质来设计公共密钥加密系统的，p与q的乘积n可以作为公共密钥公布出来，而n的因子p和q则包含在专用密钥中，可以用来解密。如果解密需要用到ψ(n)，衡桐收信方由于知道因子p和q，可以方便地算出ψ(n) = (p－咐衫坦1)(q－1)。如果窃听者窃得了n，但由于不知道它的因子p与q，则很难求出ψ(n)。这时，窃听者要么强行算出ψ(n)，要么对n进行因数分解求得p与q。然而，我们知道，在大数范围内作合数分解是十分困难的，因此窃密者很难成功。

有了关于ψ函数的认识，我们再来分析RSA算法的工作原理：

(1) 密钥配制。设m是要加密的信息，任选两个大质数p与q，使得 ；选择正整数e，使得e与ψ(n) = (p－1)(q－1)互质。

利用辗转相除法，计算d，使得ed mod ψ(n) = ，即ed = kψ(n) +1，其中k为某一正整数。

公共密钥为(e，n)，其中没有包含任何有关n的因子p和q的信息。

专用密钥为(d，n)，其中d隐含有因子p和q的信息。

(2) 加密过程。使用公式(12-3)对明文m进行加密，得密文c。

(3) 解密过程。使用(d，n)对密文c进行解密，计算过程为：

cd mod n = (me mod n)d mod n

= med mod n

= m(kψ(n) + 1) mod n

= (mkψ(n) mod n)·(m mod n)

= m

m即为从密文c中恢复出来的明文。

例如，假设我们需要加密的明文代码信息为m = 14，则：

选择e = 3，p = 5，q = 11；

计算出n = p·q = 55，(p－1)(q－1) = 40，d = 27；

可以验证：(e·d) mod (p－1)(q－1) = 81 mod 40 = 1；

加密：c = me mod n = 143 mod 55 = 49；

解密：m = cd mod n = 4927 mod 55 = 14。

关于RSA算法，还有几点需要进一步说明：

(1) 之所以要求e与(p－1)(q－1)互质，是为了保证 ed mod (p－1)(q－1)有解。

(2) 实际操作时，通常先选定e，再找出并确定质数p和q，使得计算出d后它们能满足公式(12-3)。常用的e有3和65537，这两个数都是费马序列中的数。费马序列是以17世纪法国数学家费马命名的序列。

(3) 破密者主要通过将n分解成p·q的办法来解密，不过目前还没有办法证明这是唯一的办法，也可能有更有效的方法，因为因数分解问题毕竟是一个不断发展的领域，自从RSA算法发明以来，人们已经发现了不少有效的因数分解方法，在一定程度上降低了破译RSA算法的难度，但至今还没有出现动摇RSA算法根基的方法。

(4) 在RSA算法中，n的长度是控制该算法可靠性的重要因素。目前129位、甚至155位的RSA加密勉强可解，但目前大多数加密程序均采用231、308甚至616位的RSA算法，因此RSA加密还是相当安全的。

据专家测算，攻破512位密钥RSA算法大约需要8个月时间；而一个768位密钥RSA算法在2004年之前无法攻破。现在，在技术上还无法预测攻破具有2048位密钥的RSA加密算法需要多少时间。美国Lotus公司悬赏1亿美元，奖励能破译其Domino产品中1024位密钥的RSA算法的人。从这个意义上说，遵照SET协议开发的电子商务系统是绝对安全的。

㈤ C#中RSA加密解密

代码 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;

namespace MyRSA
{
public class MyRSA
{

private static string publicKey = "<RSAKeyValue><Molus>6CdsXgYOyya//+q+UfUYTHYCsMH2cnqGVtnQiE/PMRMmY0RwEfMIo+TDpq3QyO03MaEsDGf13sPw9YRXiac=</Molus><Exponent>AQAB</Exponent></RSAKeyValue>";
private static string privateKey = "<RSAKeyValue><Molus>6CdsXgYOyya//+q+UfUYTHYCsMH2cnqGVtnQiE/PMRMmY0RwEfMIo+TDpq3QyO03MaEsDGf13sPw9YRXiac=</Molus><Exponent>AQAB</Exponent><P>/aoce2r6tonjzt1IQI6FM4ysR40j//DUvAQdrRdVgzvvAxXD7ESw==<Q>6kqclrEunX/FuelQ==</Q><DP>3XEvxB40GD5v/+/oW40YqJ2Q==</DP><DQ>LK0XmQCmY/ArYgw2Kci5t51rluRrl4f5l+aFzO2K+==</DQ><InverseQ>+XxfewIIq26+4Etm2A8IAtRdwPl4aPjSfWdA==</InverseQ><D>+WQryoHdbiIAiNpFKxL/DIEERur4sE1Jt9VdZsH24CJE=</D></RSAKeyValue>";

static public string Decrypt(string base64code)
{
try
{

//Create a UnicodeEncoder to convert between byte array and string.
UnicodeEncoding ByteConverter = new UnicodeEncoding();

//Create a new instance of RSACryptoServiceProvider to generate
//public and private key data.
RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
RSA.FromXmlString(privateKey);

byte[] encryptedData;
byte[] decryptedData;
encryptedData = Convert.FromBase64String(base64code);

//Pass the data to DECRYPT, the private key information
//(using RSACryptoServiceProvider.ExportParameters(true),
//and a boolean flag specifying no OAEP padding.
decryptedData = RSADecrypt(encryptedData, RSA.ExportParameters(true), false);

//Display the decrypted plaintext to the console.
return ByteConverter.GetString(decryptedData);
}
catch (Exception exc)
{
//Exceptions.LogException(exc);
Console.WriteLine(exc.Message);
return "";
}
}

static public string Encrypt(string toEncryptString)
{
try
{
//Create a UnicodeEncoder to convert between byte array and string.
UnicodeEncoding ByteConverter = new UnicodeEncoding();

//Create byte arrays to hold original, encrypted, and decrypted data.
byte[] dataToEncrypt = ByteConverter.GetBytes(toEncryptString);
byte[] encryptedData;
byte[] decryptedData;

//Create a new instance of RSACryptoServiceProvider to generate
//public and private key data.
RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();

RSA.FromXmlString(privateKey);

//Pass the data to ENCRYPT, the public key information
//(using RSACryptoServiceProvider.ExportParameters(false),
//and a boolean flag specifying no OAEP padding.
encryptedData = RSAEncrypt(dataToEncrypt, RSA.ExportParameters(false), false);

string base64code = Convert.ToBase64String(encryptedData);
return base64code;
}
catch (Exception exc)
{
//Catch this exception in case the encryption did
//not succeed.
//Exceptions.LogException(exc);
Console.WriteLine(exc.Message);
return "";
}

}

static private byte[] RSAEncrypt(byte[] DataToEncrypt, RSAParameters RSAKeyInfo, bool DoOAEPPadding)
{
try
{
//Create a new instance of RSACryptoServiceProvider.
RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();

//Import the RSA Key information. This only needs
//toinclude the public key information.
RSA.ImportParameters(RSAKeyInfo);

//Encrypt the passed byte array and specify OAEP padding.
//OAEP padding is only available on Microsoft Windows XP or
//later.
return RSA.Encrypt(DataToEncrypt, DoOAEPPadding);
}
//Catch and display a CryptographicException
//to the console.
catch (CryptographicException e)
{
//Exceptions.LogException(e);
Console.WriteLine(e.Message);

return null;
}

}

static private byte[] RSADecrypt(byte[] DataToDecrypt, RSAParameters RSAKeyInfo, bool DoOAEPPadding)
{
try
{
//Create a new instance of RSACryptoServiceProvider.
RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();

//Import the RSA Key information. This needs
//to include the private key information.
RSA.ImportParameters(RSAKeyInfo);

//Decrypt the passed byte array and specify OAEP padding.
//OAEP padding is only available on Microsoft Windows XP or
//later.
return RSA.Decrypt(DataToDecrypt, DoOAEPPadding);
}
//Catch and display a CryptographicException
//to the console.
catch (CryptographicException e)
{
//Exceptions.LogException(e);
Console.WriteLine(e.Message);

return null;
}

}

}
}

测试代码： static void Main(string[] args)
{
string encodeString = MyRSA.Encrypt("1234567");
Console.WriteLine(encodeString);

string decode = MyRSA.Decrypt(encodeString);
Console.WriteLine(decode);

Console.ReadLine();
}

㈥ RSA PKCS#1在java中怎么实现

楼主看看下面的代码是不是你所需要的，这是我原来用的时候收集的
import javax.crypto.Cipher;
import java.security.*;
import java.security.spec.RSAPublicKeySpec;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.InvalidKeySpecException;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.io.*;
import java.math.BigInteger;

/**
* RSA 工具类。提供加密，解密，生成密钥对等方法。
* 需要到http://www.bouncycastle.org下载bcprov-jdk14-123.jar。
* RSA加密原理概述
* RSA的安全性依赖于大数的分解，公钥和私钥都是两个大素数（大于100的十进制位）的函数。
* 据猜测，从一个密钥和密文推断出明文的难度等同于分解两个大素数的积
* ===================================================================
* （该算法的安全性未得到理论的证明）
* ===================================================================
* 密钥的产生：
* 1.选择两个大素数 p,q ,计算 n=p*q;
* 2.随机选择加密密钥 e ,要求 e 和 (p-1)*(q-1)互质
* 3.利用 Euclid 算法计算解密密钥 d , 使其满足 e*d = 1(mod(p-1)*(q-1)) (其中 n,d 也要互质)
* 4:至此得出公钥为 (n,e) 私钥为 (n,d)
* ===================================================================
* 加解密方法：
* 1.首先将要加密的信息 m(二进制表示) 分成等长的数据块 m1,m2,...,mi 块长 s(尽可能大) ,其中 2^s<n
* 2:对应的密文是： ci = mi^e(mod n)
* 3:解密时作如下计算： mi = ci^d(mod n)
* ===================================================================
* RSA速度
* 由于进行的都是大数计算，使得RSA最快的情况也比DES慢上100倍，无论是软件还是硬件实现。
* 速度一直是RSA的缺陷。一般来说只用于少量数据加密。
* 文件名：RSAUtil.java<br>
* @author 赵峰<br>
* 版本:1.0.1<br>
* 描述：本算法摘自网络，是对RSA算法的实现<br>
* 创建时间:2009-7-10 下午09:58:16<br>
* 文件描述：首先生成两个大素数，然后根据Euclid算法生成解密密钥<br>
*/
public class RSAUtil {

//密钥对
private KeyPair keyPair = null;

/**
* 初始化密钥对
*/
public RSAUtil(){
try {
this.keyPair = this.generateKeyPair();
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 生成密钥对
* @return KeyPair
* @throws Exception
*/
private KeyPair generateKeyPair() throws Exception {
try {
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA",new org.bouncycastle.jce.provider.BouncyCastleProvider());
//这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低
final int KEY_SIZE = 1024;
keyPairGen.initialize(KEY_SIZE, new SecureRandom());
KeyPair keyPair = keyPairGen.genKeyPair();
return keyPair;
} catch (Exception e) {
throw new Exception(e.getMessage());
}

}

/**
* 生成公钥
* @param molus
* @param publicExponent
* @return RSAPublicKey
* @throws Exception
*/
private RSAPublicKey generateRSAPublicKey(byte[] molus, byte[] publicExponent) throws Exception {

KeyFactory keyFac = null;
try {
keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
} catch (NoSuchAlgorithmException ex) {
throw new Exception(ex.getMessage());
}
RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(molus), new BigInteger(publicExponent));
try {
return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);
} catch (InvalidKeySpecException ex) {
throw new Exception(ex.getMessage());
}

}

/**
* 生成私钥
* @param molus
* @param privateExponent
* @return RSAPrivateKey
* @throws Exception
*/
private RSAPrivateKey generateRSAPrivateKey(byte[] molus, byte[] privateExponent) throws Exception {
KeyFactory keyFac = null;
try {
keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
} catch (NoSuchAlgorithmException ex) {
throw new Exception(ex.getMessage());
}
RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(molus), new BigInteger(privateExponent));
try {
return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);
} catch (InvalidKeySpecException ex) {
throw new Exception(ex.getMessage());
}
}

/**
* 加密
* @param key 加密的密钥
* @param data 待加密的明文数据
* @return 加密后的数据
* @throws Exception
*/
public byte[] encrypt(Key key, byte[] data) throws Exception {
try {
Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
cipher.init(Cipher.ENCRYPT_MODE, key);
// 获得加密块大小，如:加密前数据为128个byte，而key_size=1024 加密块大小为127 byte,加密后为128个byte;
// 因此共有2个加密块，第一个127 byte第二个为1个byte
int blockSize = cipher.getBlockSize();
// System.out.println("blockSize:"+blockSize);
int outputSize = cipher.getOutputSize(data.length);// 获得加密块加密后块大小
// System.out.println("加密块大小："+outputSize);
int leavedSize = data.length % blockSize;
// System.out.println("leavedSize:"+leavedSize);
int blocksSize = leavedSize != 0 ? data.length / blockSize + 1 : data.length / blockSize;
byte[] raw = new byte[outputSize * blocksSize];
int i = 0;
while (data.length - i * blockSize > 0) {
if (data.length - i * blockSize > blockSize)
cipher.doFinal(data, i * blockSize, blockSize, raw, i * outputSize);
else
cipher.doFinal(data, i * blockSize, data.length - i * blockSize, raw, i * outputSize);
// 这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到ByteArrayOutputStream中
// 而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了OutputSize所以只好用dofinal方法。
i++;
}
return raw;
} catch (Exception e) {
throw new Exception(e.getMessage());
}
}

/**
* 解密
* @param key 解密的密钥
* @param raw 已经加密的数据
* @return 解密后的明文
* @throws Exception
*/
@SuppressWarnings("static-access")
public byte[] decrypt(Key key, byte[] raw) throws Exception {
try {
Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
cipher.init(cipher.DECRYPT_MODE, key);
int blockSize = cipher.getBlockSize();
ByteArrayOutputStream bout = new ByteArrayOutputStream(64);
int j = 0;
while (raw.length - j * blockSize > 0) {
bout.write(cipher.doFinal(raw, j * blockSize, blockSize));
j++;
}
return bout.toByteArray();
} catch (Exception e) {
throw new Exception(e.getMessage());
}
}

/**
* 返回公钥
* @return
* @throws Exception
*/
public RSAPublicKey getRSAPublicKey() throws Exception{
//获取公钥
RSAPublicKey pubKey = (RSAPublicKey) keyPair.getPublic();
//获取公钥系数(字节数组形式)
byte[] pubModBytes = pubKey.getMolus().toByteArray();
//返回公钥公用指数(字节数组形式)
byte[] pubPubExpBytes = pubKey.getPublicExponent().toByteArray();
//生成公钥
RSAPublicKey recoveryPubKey = this.generateRSAPublicKey(pubModBytes,pubPubExpBytes);
return recoveryPubKey;
}

/**
* 获取私钥
* @return
* @throws Exception
*/
public RSAPrivateKey getRSAPrivateKey() throws Exception{
// 获取私钥
RSAPrivateKey priKey = (RSAPrivateKey) keyPair.getPrivate();
// 返回私钥系数(字节数组形式)
byte[] priModBytes = priKey.getMolus().toByteArray();
// 返回私钥专用指数(字节数组形式)
byte[] priPriExpBytes = priKey.getPrivateExponent().toByteArray();
// 生成私钥
RSAPrivateKey recoveryPriKey = this.generateRSAPrivateKey(priModBytes,priPriExpBytes);
return recoveryPriKey;
}

/**
* 测试
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
RSAUtil rsa = new RSAUtil();
String str = "天龙八部、神雕侠侣、射雕英雄传白马啸西风";
RSAPublicKey pubKey = rsa.getRSAPublicKey();
RSAPrivateKey priKey = rsa.getRSAPrivateKey();
// System.out.println("加密后==" + new String(rsa.encrypt(pubKey,str.getBytes())));
String mw = new String(rsa.encrypt(pubKey, str.getBytes()));
System.out.println("加密后："+mw);
// System.out.println("解密后：");
System.out.println("解密后==" + new String(rsa.decrypt(priKey,rsa.encrypt(pubKey,str.getBytes()))));
}
}

㈦ RSA加解密原理以及三种填充模式

如果需要理解RSA的加密原理，需要理解以下理论：

​ 等同于求一元二次方程 23 * d + 192 * y = 1

​ 可以求得其中一解为（d=167，y=-20）

​ 至此就完成了所有的计算

​ 对于上述例子的到公钥（221，23）和私钥（221，167）

在上述的计算过程中一共用到了

上面用到的数中只有公钥部分是公开的，即（221，23）。那么我们是否可以通过公钥来推到出私钥部分，即已知n和e，推到出d？

（1）ed 1(mod (n))，只有知道 (n)才能解出d

（2） (n)= (p) (q)= (p-1) (q-1)，只有知道p和q才能得到 (n)

（3）n=p q，就需要对n进行因式分解

那么如果可以对n因式分解就可以求出d，也就意味着私匙被破解

那么RSA加密的可靠性就在于对n因式分解的难度，而现在对一个整数n做因式分解并没有巧妙的算法，只有通过暴力破解计算。在实际应用中的n取值通常在1024位以上，而公开已知的可因式分解的最大数为768位。所以现阶段来说RSA加密是可靠的。

现在我们就可以进行加密和解密了

我们使用上面生成的公钥（221，23）来加密。如果我们需要加密的信息是m（ m必须为整数并且m要小于n ），m取56，可以用以下公式求出加密串c：

​ c (mod n)

​ 10 (mod 221)

可以求出加密后的结果c为10

密钥为（221，167），加密结果c=10，可以使用以下公式求出被加密的信息

​ m (mod n) 即加密结果的d次方除以n的余数为m

​ 56 (mod 221)

RSA加密属于块加密算法，总是在一个固定长度的块上进行操作。如果被加密的字符串过长，则需要对字符串进行切割，如果字符串过短则需要进行填充。

以下主介绍一下RSA_PKCS1_PADDING填充模式以及RSA_NO_PADDING模式

此填充模式是最常用的填充模式，在此填充模式下输入的长度受加密钥的长度限制，输入的最大长度为加密钥的位数k-11。如果公钥的长度为1024位即128字节，那么输入的长度最多为128-11=117字节。如果长度小于117就需要填充。如果输入T的长度为55字节，填充后的块为EM，则EM格式如下：

EM= 0x00 || BT || PS || 0x00 || T

在此填充模式下，输入的长度最多和RSA公钥长度一样长，如果小于公钥长度则会在前面填充0x00。如果公钥长度是128字节，输入T的长度为55字节，填充后的块为EM，则EM格式如下：

EM=P || T

参考：
http://www.ruanyifeng.com/blog/2013/06/rsa_algorithm_part_one.html
http://www.ruanyifeng.com/blog/2013/07/rsa_algorithm_part_two.html
https://my.oschina.net/3pgp/blog/749195

㈧ RSA加密原理

RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。公钥加密--私钥解密，私钥加密--公钥解密

在 整数 中， 离散对数 是一种基于 同余 运算和 原根 的一种 对数 运算。而在实数中对数的定义 log _b a 是指对于给定的 a 和 b ，有一个数 x ，使得 b ^x = a 。相同地在任何群 G 中可为所有整数 k 定义一个幂数为 b ^K ，而 离散对数 log _b a 是指使得 b ^K = a 的整数 k 。

当3为17的 原根 时，我们会发现一个规律

对 正整数 n，欧拉函数是小于或等于n的正整数中与n 互质 的数的数目（因此φ(1)=1）。有以下几个特点

服务端根据生成一个随机数15，根据 3 ¹⁵ _mod 17 计算出6，服务端将6传递给客户端，客户端生成一个随机数13，根据 3 ¹³ _mod 17 计算出12后，将12再传回给服务端，客户端收到服务端传递的6后，根据 6 ¹³ _mod 17 计算出 10 ，服务端收到客户端传递的12后，根据 12 ¹⁵ _mod 17 计算出 10 ，我们会发现我们通过 迪菲赫尔曼密钥交换 将 10 进行了加密传递

说明：

安全性：
除了 公钥 用到 n 和 e ，其余的4个数字是 不公开 的（p1、p2、φ(n)、d）
目前破解RSA得到的方式如下：

缺点
RSA加密 效率不高 ，因为是纯粹的数学算法，大数据不适合RSA加密，所以我们在加密大数据的时候，我们先用 对称加密 算法加密大数据得到 KEY ，然后再用 RSA 加密 KEY ，再把大数据和KEY一起进行传递

因为Mac系统内置了OpenSSL（开源加密库），所以我们开源直接在终端进行RSA加密解密

生成RSA私钥，密钥名为private.pem,密钥长度为1024bit

因为在iOS中是无法使用 .pem 文件进行加密和解密的，需要进行下面几个步骤

生成一个10年期限的crt证书

crt证书格式转换成der证书

㈨ RSA加密解密算法示例（C语言）

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <math.h>

#include <time.h>

#define PRIME_MAX 200   // 生成素数范围

#define EXPONENT_MAX 200 // 生成指数e范围

#define Element_Max 127    // 加密单元的最大值，这里为一个char, 即1Byte

char str_read[100]="hello world !";  // 待加密的原文

int str_encrypt[100];                // 加密后的内容

char str_decrypt[100];              // 解密出来的内容

int str_read_len;                    // str_read 的长度

int prime1, prime2;                  // 随机生成的两个质数

int mod, eular;                      // 模数和欧拉数

int pubKey, priKey;                  // 公钥指数和私钥指数

// 生成随机素数，实际应用中，这两个质数越大，就越难破解。

int randPrime()

{

int prime, prime2, i;

next:

prime = rand() % PRIME_MAX;   // 随机产生数

if (prime <= 1) goto next;      // 不是质数，生成下一个随机数

if (prime == 2 || prime == 3) return prime;

prime2 = prime / 2;              // prime>=4, prime2 的平方必定大于 prime , 因此只检查小于等于prime2的数

for (i = 2; i <= prime2; i++)   // 判断是否为素数

{

if (i * i > prime) return prime;

if (prime % i == 0) goto next;  // 不是质数，生成下一个随机数

}

}

// 欧几里德算法，判断a,b互质

int gcd(int a, int b)

{

int temp;

while (b != 0) {

temp = b;

b = a % b;

a = temp;

}

return a;

}

//生成公钥指数，条件是 1< e < 欧拉数，且与欧拉数互质。

int randExponent()

{

int e;

while (1)

{

e = rand() % eular; if (e < EXPONENT_MAX) break;

}

while (1)

{

if (gcd(e, eular) == 1) return e; e = (e + 1) % eular; if (e == 0 || e > EXPONENT_MAX) e = 2;

}

}

//生成私钥指数

int inverse()

{

int d, x;

while (1)

{

d = rand() % eular;

x = pubKey * d % eular;

if (x == 1)

{

return d;

}

}

}

//加密函数

void jiami()           

{

str_read_len = strlen(str_read);      //从参数表示的地址往后找，找到第一个'\0'，即串尾。计算'\0'至首地址的“距离”，即隔了几个字符，从而得出长度。

printf("密文是：");

for (int i = 0; i < str_read_len; i++)

{

int C = 1; int a = str_read[i], b = a % mod;

for (int j = 0; j < pubKey; j++) //实现加密

{

C = (C*b) % mod;

}

str_encrypt[i] = C;

printf("%d ", str_encrypt[i]);

}

printf("\n");

}

//解密函数

void jiemi()         

{

int i=0;  for (i = 0; i < str_read_len; i++)

{

int C = 1; int a = str_encrypt[i], b=a%mod;

for (int j = 0; j < priKey; j++)

{

C = (C * b) % mod;

}

str_decrypt[i] = C;

}

str_decrypt[i] = '\0'; printf("解密文是：%s \n", str_decrypt);

}

int main()

{

srand(time(NULL));

while (1)

{

prime1 = randPrime(); prime2 = randPrime(); printf("随机产生两个素数：prime1 = %d , prime2 = %d ", prime1, prime2);

mod = prime1 * prime2; printf("模数：mod = prime1 * prime2 = %d \n", mod); if (mod > Element_Max) break; // 模数要大于每个加密单元的值

}

eular = (prime1 - 1) * (prime2 - 1);  printf("欧拉数：eular=(prime1-1)*(prime2-1) = %d \n", eular);

pubKey = randExponent(); printf("公钥指数：pubKey = %d\n", pubKey);

priKey = inverse(); printf("私钥指数：priKey = %d\n私钥为 (%d, %d)\n", priKey, priKey, mod);

jiami(); jiemi();

return 0;

}

㈩ 非对称加密解密RSA的实现例子

最近有接触到加密相关的内容，本期以非对称加密为例子，做个简单的总结和记录。首先了解下非对称加密，简单来说非对称指的是加密和解密用不同的秘钥，典型的RSA，这个算法名称是基于三个发明人的名字首字母取的；辩含碧而对称加密必须要在加解密使用相同的秘钥携举，典型的AES。这里细节不多展开阐述，涉及到很多数学原理，如大数的质因数分解等，感兴趣的可以找找李永乐等网上比较优秀的科普。这篇文章只是java原生实现的加解密例子。至于其他的如md5,hash等，如果从主观可读的角度来说，也可以称为加密。

如下的示例是使用Java原生实现RSA的加密解密，包括用公钥加密，然后私钥解密；或者使用私钥加密，然后公钥解密。注意不同key大小，限制的解密内容大小也不一样，感老备兴趣的同学可以试试修改key大小和加密内容长度来试试。还有要注意的是RSA加密有一定的性能损耗。

想了解原理相关的内容可以看如下的参考内容。
[1]. RSA原理