crsa私鑰加密
RSA演算法非常簡單，概述如下：
找兩素數p和q
取n=p*q
取t=(p-1)*(q-1)
取任何一個數e,要求滿足e<t並且e與t互素（就是最大公因數為1）
取d*e%t==1
這樣最終得到三個數： n d e
設消息為數M (M <n)
設c=(M**d)%n就得到了加密後的消息c
設m=(c**e)%n則 m == M，從而完成對c的解密。
註：**表示次方,上面兩式中的d和e可以互換。
在對稱加密中：
n d兩個數構成公鑰，可以告訴別人；
n e兩個數構成私鑰，e自己保留，不讓任何人知道。
給別人發送的信息使用e加密，只要別人能用d解開就證明信息是由你發送的，構成了簽名機制。
別人給你發送信息時使用d加密，這樣只有擁有e的你能夠對其解密。
rsa的安全性在於對於一個大數n，沒有有效的方法能夠將其分解
從而在已知n d的情況下無法獲得e；同樣在已知n e的情況下無法
求得d。
rsa簡潔幽雅，但計算速度比較慢，通常加密中並不是直接使用rsa 來對所有的信息進行加密，
最常見的情況是隨機產生一個對稱加密的密鑰，然後使用對稱加密演算法對信息加密，之後用
RSA對剛才的加密密鑰進行加密。
最後需要說明的是，當前小於1024位的N已經被證明是不安全的
自己使用中不要使用小於1024位的RSA，最好使用2048位的。
『貳』 RSA已知明文和公鑰能得到私鑰加密的密文嗎
首先破解RSA是指 密文 ->明文 的過程！
假設明文m，密文c，私鑰d，公鑰e，RSA加密的流程如下：
1、兩個較大的互不相等的質數p和q
2、n = p * q
3、fn = (p - 1) * (q - 1)
4、e 與 fn 互質， 且1 < e < fn
5、d滿足 de % fn = 1
6、加解密：
c = (m^e) % n
m = (c^d) % n
上面的公式可以理解為通過公鑰加密，而通過私鑰解密。
第一種情況：已知明文和公鑰得到私鑰加密的密文，這個是加密過程，與私鑰d關系不大，加密過程主要在於n的值！
假設這種情況已知明文m，公鑰e，私鑰d，密文c有無數種。
第二種情況：已知明文密文和公鑰得到私鑰。
已知明文m，密文c，公鑰e求私鑰d，套入次公式：c= (m^e) % n，n的值也是不唯一的，所以私鑰d的值也不唯一。
在有正確答案做對比的情況下個人感覺第二種情況比較容易求出吧。
個人見解，歡迎討論。
『叄』 RSA加密演算法怎樣用C語言實現 急急急！！！
/*數據只能是大寫字母組成的字元串。
加密的時候，輸入Y，然後輸入要加密的文本（大寫字母）
解密的時候，輸入N，然後輸入一個整數n表示密文的個數，然後n個整數表示加密時候得到的密文。
*/
/*RSA algorithm */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MM 7081
#define KK 1789
#define PHIM 6912
#define PP 85
typedef char strtype[10000];
int len;
long nume[10000];
int change[126];
char antichange[37];
void initialize()
{ int i;
char c;
for (i = 11, c = 'A'; c <= 'Z'; c ++, i ++)
{ change[c] = i;
antichange[i] = c;
}
}
void changetonum(strtype str)
{ int l = strlen(str), i;
len = 0;
memset(nume, 0, sizeof(nume));
for (i = 0; i < l; i ++)
{ nume[len] = nume[len] * 100 + change[str[i]];
if (i % 2 == 1) len ++;
}
if (i % 2 != 0) len ++;
}
long binamod(long numb, long k)
{ if (k == 0) return 1;
long curr = binamod (numb, k / 2);
if (k % 2 == 0)
return curr * curr % MM;
else return (curr * curr) % MM * numb % MM;
}
long encode(long numb)
{ return binamod(numb, KK);
}
long decode(long numb)
{ return binamod(numb, PP);
}
main()
{ strtype str;
int i, a1, a2;
long curr;
initialize();
puts("Input 'Y' if encoding, otherwise input 'N':");
gets(str);
if (str[0] == 'Y')
{ gets(str);
changetonum(str);
printf("encoded: ");
for (i = 0; i < len; i ++)
{ if (i) putchar('-');
printf(" %ld ", encode(nume[i]));
}
putchar('\n');
}
else
{ scanf("%d", &len);
for (i = 0; i < len; i ++)
{ scanf("%ld", &curr);
curr = decode(curr);
a1 = curr / 100;
a2 = curr % 100;
printf("decoded: ");
if (a1 != 0) putchar(antichange[a1]);
if (a2 != 0) putchar(antichange[a2]);
}
putchar('\n');
}
putchar('\n');
system("PAUSE");
return 0;
}
/*
測試：
輸入：
Y
FERMAT
輸出：
encoded: 5192 - 2604 - 4222
輸入
N
3 5192 2604 4222
輸出
decoded: FERMAT
*/
『肆』 有關C#中RSA加密方法的密鑰生成長度
/// <summary> /// 字元串加密操作類
/// </summary>
public class EncryptionOperation
{
/// <summary>
/// MD5 加密靜態方法
/// </summary>
/// <param name="EncryptString">待加密的密文</param>
/// <returns>returns</returns>
public static string MD5Encrypt(string EncryptString) {
if (string.IsNullOrEmpty(EncryptString)) { throw (new Exception("密文不得為空")); }
MD5 m_ClassMD5 = new MD5CryptoServiceProvider();
string m_strEncrypt = "";
try {
m_strEncrypt = BitConverter.ToString(m_ClassMD5.ComputeHash(Encoding.Default.GetBytes(EncryptString))).Replace("-", "");
}
catch (ArgumentException ex) { throw ex; }
catch (CryptographicException ex) { throw ex; }
catch (Exception ex) { throw ex; }
finally { m_ClassMD5.Clear(); }
return m_strEncrypt;
}
/// <summary>
/// DES 加密(數據加密標准，速度較快，適用於加密大量數據的場合)
/// </summary>
/// <param name="EncryptString">待加密的密文</param>
/// <param name="EncryptKey">加密的密鑰</param>
/// <returns>returns</returns>
public static string DESEncrypt(string EncryptString, string EncryptKey) {
if (string.IsNullOrEmpty(EncryptString)) { throw (new Exception("密文不得為空")); }
if (string.IsNullOrEmpty(EncryptKey)) { throw (new Exception("密鑰不得為空")); }
if (EncryptKey.Length != 8) { throw (new Exception("密鑰必須為8位")); }
byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
string m_strEncrypt = "";
DESCryptoServiceProvider m_DESProvider = new DESCryptoServiceProvider();
try {
byte[] m_btEncryptString = Encoding.Default.GetBytes(EncryptString);
MemoryStream m_stream = new MemoryStream();
CryptoStream m_cstream = new CryptoStream(m_stream, m_DESProvider.CreateEncryptor(Encoding.Default.GetBytes(EncryptKey), m_btIV), CryptoStreamMode.Write);
m_cstream.Write(m_btEncryptString, 0, m_btEncryptString.Length);
m_cstream.FlushFinalBlock();
m_strEncrypt = Convert.ToBase64String(m_stream.ToArray());
m_stream.Close(); m_stream.Dispose();
m_cstream.Close(); m_cstream.Dispose();
}
catch (IOException ex) { throw ex; }
catch (CryptographicException ex) { throw ex; }
catch (ArgumentException ex) { throw ex; }
catch (Exception ex) { throw ex; }
finally { m_DESProvider.Clear(); }
return m_strEncrypt;
}
/// <summary>
/// DES 解密(數據加密標准，速度較快，適用於加密大量數據的場合)
/// </summary>
/// <param name="DecryptString">待解密的密文</param>
/// <param name="DecryptKey">解密的密鑰</param>
/// <returns>returns</returns>
public static string DESDecrypt(string DecryptString, string DecryptKey) {
if (string.IsNullOrEmpty(DecryptString)) { throw (new Exception("密文不得為空")); }
if (string.IsNullOrEmpty(DecryptKey)) { throw (new Exception("密鑰不得為空")); }
if (DecryptKey.Length != 8) { throw (new Exception("密鑰必須為8位")); }
byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
string m_strDecrypt = "";
DESCryptoServiceProvider m_DESProvider = new DESCryptoServiceProvider();
try {
byte[] m_btDecryptString = Convert.FromBase64String(DecryptString);
MemoryStream m_stream = new MemoryStream();
CryptoStream m_cstream = new CryptoStream(m_stream, m_DESProvider.CreateDecryptor(Encoding.Default.GetBytes(DecryptKey), m_btIV), CryptoStreamMode.Write);
m_cstream.Write(m_btDecryptString, 0, m_btDecryptString.Length);
m_cstream.FlushFinalBlock();
m_strDecrypt = Encoding.Default.GetString(m_stream.ToArray());
m_stream.Close(); m_stream.Dispose();
m_cstream.Close(); m_cstream.Dispose();
}
catch (IOException ex) {
m_strDecrypt = "";
}
catch (CryptographicException ex) { m_strDecrypt = ""; }
catch (ArgumentException ex) { m_strDecrypt = ""; }
catch (Exception ex) { m_strDecrypt = ""; }
finally { m_DESProvider.Clear(); }
return m_strDecrypt;
}
/// <summary>
/// RC2 加密(用變長密鑰對大量數據進行加密)
/// </summary>
/// <param name="EncryptString">待加密密文</param>
/// <param name="EncryptKey">加密密鑰</param>
/// <returns>returns</returns>
public static string RC2Encrypt(string EncryptString, string EncryptKey) {
if (string.IsNullOrEmpty(EncryptString)) { throw (new Exception("密文不得為空")); }
if (string.IsNullOrEmpty(EncryptKey)) { throw (new Exception("密鑰不得為空")); }
if (EncryptKey.Length < 5 || EncryptKey.Length > 16) { throw (new Exception("密鑰必須為5-16位")); }
string m_strEncrypt = "";
byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
RC2CryptoServiceProvider m_RC2Provider = new RC2CryptoServiceProvider();
try {
byte[] m_btEncryptString = Encoding.Default.GetBytes(EncryptString);
MemoryStream m_stream = new MemoryStream();
CryptoStream m_cstream = new CryptoStream(m_stream, m_RC2Provider.CreateEncryptor(Encoding.Default.GetBytes(EncryptKey), m_btIV), CryptoStreamMode.Write);
m_cstream.Write(m_btEncryptString, 0, m_btEncryptString.Length);
m_cstream.FlushFinalBlock();
m_strEncrypt = Convert.ToBase64String(m_stream.ToArray());
m_stream.Close(); m_stream.Dispose();
m_cstream.Close(); m_cstream.Dispose();
}
catch (IOException ex) { throw ex; }
catch (CryptographicException ex) { throw ex; }
catch (ArgumentException ex) { throw ex; }
catch (Exception ex) { throw ex; }
finally { m_RC2Provider.Clear(); }
return m_strEncrypt;
}
/// <summary>
/// RC2 解密(用變長密鑰對大量數據進行加密)
/// </summary>
/// <param name="DecryptString">待解密密文</param>
/// <param name="DecryptKey">解密密鑰</param>
/// <returns>returns</returns>
public static string RC2Decrypt(string DecryptString, string DecryptKey) {
if (string.IsNullOrEmpty(DecryptString)) { throw (new Exception("密文不得為空")); }
if (string.IsNullOrEmpty(DecryptKey)) { throw (new Exception("密鑰不得為空")); }
if (DecryptKey.Length < 5 || DecryptKey.Length > 16) { throw (new Exception("密鑰必須為5-16位")); }
byte[] m_btIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
string m_strDecrypt = "";
RC2CryptoServiceProvider m_RC2Provider = new RC2CryptoServiceProvider();
try {
byte[] m_btDecryptString = Convert.FromBase64String(DecryptString);
MemoryStream m_stream = new MemoryStream();
CryptoStream m_cstream = new CryptoStream(m_stream, m_RC2Provider.CreateDecryptor(Encoding.Default.GetBytes(DecryptKey), m_btIV), CryptoStreamMode.Write);
m_cstream.Write(m_btDecryptString, 0, m_btDecryptString.Length);
m_cstream.FlushFinalBlock();
m_strDecrypt = Encoding.Default.GetString(m_stream.ToArray());
m_stream.Close(); m_stream.Dispose();
m_cstream.Close(); m_cstream.Dispose();
}
catch (IOException ex) { throw ex; }
catch (CryptographicException ex) { throw ex; }
catch (ArgumentException ex) { throw ex; }
catch (Exception ex) { throw ex; }
finally { m_RC2Provider.Clear(); }
return m_strDecrypt;
}
/// <summary>
/// 3DES 加密(基於DES，對一塊數據用三個不同的密鑰進行三次加密，強度更高)
/// </summary>
/// <param name="EncryptString">待加密密文</param>
/// <param name="EncryptKey1">密鑰一</param>
/// <param name="EncryptKey2">密鑰二</param>
/// <param name="EncryptKey3">密鑰三</param>
/// <returns>returns</returns>
public static string DES3Encrypt(string EncryptString, string EncryptKey1, string EncryptKey2, string EncryptKey3) {
string m_strEncrypt = "";
try {
m_strEncrypt = DESEncrypt(EncryptString, EncryptKey3);
m_strEncrypt = DESEncrypt(m_strEncrypt, EncryptKey2);
m_strEncrypt = DESEncrypt(m_strEncrypt, EncryptKey1);
}
catch (Exception ex) { throw ex; }
return m_strEncrypt;
}
/// <summary>
/// 3DES 解密(基於DES，對一塊數據用三個不同的密鑰進行三次加密，強度更高)
/// </summary>
/// <param name="DecryptString">待解密密文</param>
/// <param name="DecryptKey1">密鑰一</param>
/// <param name="DecryptKey2">密鑰二</param>
/// <param name="DecryptKey3">密鑰三</param>
/// <returns>returns</returns>
public static string DES3Decrypt(string DecryptString, string DecryptKey1, string DecryptKey2, string DecryptKey3) {
string m_strDecrypt = "";
try {
m_strDecrypt = DESDecrypt(DecryptString, DecryptKey1);
m_strDecrypt = DESDecrypt(m_strDecrypt, DecryptKey2);
m_strDecrypt = DESDecrypt(m_strDecrypt, DecryptKey3);
}
catch (Exception ex) { throw ex; }
return m_strDecrypt;
}
/// <summary>
/// AES 加密(高級加密標准，是下一代的加密演算法標准，速度快，安全級別高，目前 AES 標準的一個實現是 Rijndael 演算法)
/// </summary>
/// <param name="EncryptString">待加密密文</param>
/// <param name="EncryptKey">加密密鑰</param>
/// <returns></returns>
public static string AESEncrypt(string EncryptString, string EncryptKey) {
if (string.IsNullOrEmpty(EncryptString)) { throw (new Exception("密文不得為空")); }
if (string.IsNullOrEmpty(EncryptKey)) { throw (new Exception("密鑰不得為空")); }
string m_strEncrypt = "";
byte[] m_btIV = Convert.FromBase64String("Rkb4jvUy/ye7Cd7k89QQgQ==");
Rijndael m_AESProvider = Rijndael.Create();
try {
byte[] m_btEncryptString = Encoding.Default.GetBytes(EncryptString);
MemoryStream m_stream = new MemoryStream();
CryptoStream m_csstream = new CryptoStream(m_stream, m_AESProvider.CreateEncryptor(Encoding.Default.GetBytes(EncryptKey), m_btIV), CryptoStreamMode.Write);
m_csstream.Write(m_btEncryptString, 0, m_btEncryptString.Length); m_csstream.FlushFinalBlock();
m_strEncrypt = Convert.ToBase64String(m_stream.ToArray());
m_stream.Close(); m_stream.Dispose();
m_csstream.Close(); m_csstream.Dispose();
}
catch (IOException ex) { throw ex; }
catch (CryptographicException ex) { throw ex; }
catch (ArgumentException ex) { throw ex; }
catch (Exception ex) { throw ex; }
finally { m_AESProvider.Clear(); }
return m_strEncrypt;
}
/// <summary>
/// AES 解密(高級加密標准，是下一代的加密演算法標准，速度快，安全級別高，目前 AES 標準的一個實現是 Rijndael 演算法)
/// </summary>
/// <param name="DecryptString">待解密密文</param>
/// <param name="DecryptKey">解密密鑰</param>
/// <returns></returns>
public static string AESDecrypt(string DecryptString, string DecryptKey) {
if (string.IsNullOrEmpty(DecryptString)) { throw (new Exception("密文不得為空")); }
if (string.IsNullOrEmpty(DecryptKey)) { throw (new Exception("密鑰不得為空")); }
string m_strDecrypt = "";
byte[] m_btIV = Convert.FromBase64String("Rkb4jvUy/ye7Cd7k89QQgQ==");
Rijndael m_AESProvider = Rijndael.Create();
try {
byte[] m_btDecryptString = Convert.FromBase64String(DecryptString);
MemoryStream m_stream = new MemoryStream();
CryptoStream m_csstream = new CryptoStream(m_stream, m_AESProvider.CreateDecryptor(Encoding.Default.GetBytes(DecryptKey), m_btIV), CryptoStreamMode.Write);
m_csstream.Write(m_btDecryptString, 0, m_btDecryptString.Length); m_csstream.FlushFinalBlock();
m_strDecrypt = Encoding.Default.GetString(m_stream.ToArray());
m_stream.Close(); m_stream.Dispose();
m_csstream.Close(); m_csstream.Dispose();
}
catch (IOException ex) { throw ex; }
catch (CryptographicException ex) { throw ex; }
catch (ArgumentException ex) { throw ex; }
catch (Exception ex) { throw ex; }
finally { m_AESProvider.Clear(); }
return m_strDecrypt;
} }
『伍』 RSA演算法加密
RSA加密演算法是一種典型的非對稱加密演算法，它基於大數的因式分解數學難題，它也是應用最廣泛的非對稱加密演算法，於1978年由美國麻省理工學院（MIT）的三位學著：Ron Rivest、Adi Shamir 和 Leonard Adleman 共同提出。
它的原理較為簡單，假設有消息發送方A和消息接收方B，通過下面的幾個步驟，就可以完成消息的加密傳遞：
消息發送方A在本地構建密鑰對，公鑰和私鑰；
消息發送方A將產生的公鑰發送給消息接收方B；
B向A發送數據時，通過公鑰進行加密，A接收到數據後通過私鑰進行解密，完成一次通信；
反之，A向B發送數據時，通過私鑰對數據進行加密，B接收到數據後通過公鑰進行解密。
由於公鑰是消息發送方A暴露給消息接收方B的，所以這種方式也存在一定的安全隱患，如果公鑰在數據傳輸過程中泄漏，則A通過私鑰加密的數據就可能被解密。
如果要建立更安全的加密消息傳遞模型，需要消息發送方和消息接收方各構建一套密鑰對，並分別將各自的公鑰暴露給對方，在進行消息傳遞時，A通過B的公鑰對數據加密，B接收到消息通過B的私鑰進行解密，反之，B通過A的公鑰進行加密，A接收到消息後通過A的私鑰進行解密。
當然，這種方式可能存在數據傳遞被模擬的隱患，但可以通過數字簽名等技術進行安全性的進一步提升。由於存在多次的非對稱加解密，這種方式帶來的效率問題也更加嚴重。
『陸』 求正確的RSA加密解密演算法C語言的，多謝。
RSA演算法它是第一個既能用於數據加密也能用於數字簽名的演算法。它易於理解和操作，也很流行。演算法的名字以發明者的名字命名：RonRivest,AdiShamir和LeonardAdleman。但RSA的安全性一直未能得到理論上的證明。它經歷了各種攻擊，至今未被完全攻破。一、RSA演算法:首先,找出三個數,p,q,r,其中p,q是兩個相異的質數,r是與(p-1)(q-1)互質的數p,q,r這三個數便是privatekey接著,找出m,使得rm==1mod(p-1)(q-1)這個m一定存在,因為r與(p-1)(q-1)互質,用輾轉相除法就可以得到了再來,計算n=pqm,n這兩個數便是publickey編碼過程是,若資料為a,將其看成是一個大整數,假設a=n的話,就將a表成s進位(s因為rm==1mod(p-1)(q-1),所以rm=k(p-1)(q-1)+1,其中k是整數因為在molo中是preserve乘法的(x==ymodzan==vmodz=>xu==yvmodz),所以,c==b^r==(a^m)^r==a^(rm)==a^(k(p-1)(q-1)+1)modpq1.如果a不是p的倍數,也不是q的倍數時,則a^(p-1)==1modp(費馬小定理)=>a^(k(p-1)(q-1))==1modpa^(q-1)==1modq(費馬小定理)=>a^(k(p-1)(q-1))==1modq所以p,q均能整除a^(k(p-1)(q-1))-1=>pq|a^(k(p-1)(q-1))-1即a^(k(p-1)(q-1))==1modpq=>c==a^(k(p-1)(q-1)+1)==amodpq2.如果a是p的倍數,但不是q的倍數時,則a^(q-1)==1modq(費馬小定理)=>a^(k(p-1)(q-1))==1modq=>c==a^(k(p-1)(q-1)+1)==amodq=>q|c-a因p|a=>c==a^(k(p-1)(q-1)+1)==0modp=>p|c-a所以,pq|c-a=>c==amodpq3.如果a是q的倍數,但不是p的倍數時,證明同上4.如果a同時是p和q的倍數時,則pq|a=>c==a^(k(p-1)(q-1)+1)==0modpq=>pq|c-a=>c==amodpqQ.E.D.這個定理說明a經過編碼為b再經過解碼為c時,a==cmodn(n=pq)但我們在做編碼解碼時,限制0intcandp(inta,intb,intc){intr=1;b=b+1;while(b!=1){r=r*a;r=r%c;b--;}printf("%d\n",r);returnr;}voidmain(){intp,q,e,d,m,n,t,c,r;chars;printf("pleaseinputthep,q:");scanf("%d%d",&p,&q);n=p*q;printf("thenis%3d\n",n);t=(p-1)*(q-1);printf("thetis%3d\n",t);printf("pleaseinputthee:");scanf("%d",&e);if(et){printf("eiserror,pleaseinputagain:");scanf("%d",&e);}d=1;while(((e*d)%t)!=1)d++;printf("thencaculateoutthatthedis%d\n",d);printf("thecipherpleaseinput1\n");printf("theplainpleaseinput2\n");scanf("%d",&r);switch(r){case1:printf("inputthem:");/*輸入要加密的明文數字*/scanf("%d",&m);c=candp(m,e,n);printf("thecipheris%d\n",c);break;case2:printf("inputthec:");/*輸入要解密的密文數字*/scanf("%d",&c);m=candp(c,d,n);printf("thecipheris%d\n",m);break;}getch();}
『柒』 使用RSA公式密鑰體制進行加密。
a)選擇兩質數p、q。
b)計算n = p*q。
c)計算n的歐拉函數 (n)=(p-1)(q-1)。
d)選擇整數e，使e與 (n)互質，且1< (n)。
e)計算d,使d*e=1 mod (n)。
1n= p*q=7*17=119
2 (n)=6*16=96
3 d*e=1mod(96) 得 5d=1mod(96) 得d=19
第2個問題 有些看不明白 是M=9？還是 已知m=9 求C？
給出演算法 你看看 不會再問我
加密：C=Me mod n
解密：M＝Cd mod n=(Me)d mod n= Med mod n
『捌』 RSA加密解密過程
為了這道題把好幾年前學的東西重新看了一遍，累覺不愛。。。
不清楚你了不了解RSA過程，先跟說一下吧
隨機產生兩個大素數p和q作為密鑰對。此題：p=13,q=17,n =p*q=221
隨機產生一個加密密鑰e,使e 和(p-1)*(q-1)互素。此題：e=83
公鑰就是（n,e）。此題：（221,83）
通過e*d mod (p-1)*(q-1)=1生成解密密鑰d, ,n與d也要互素。此題：（d*83）≡1mod192
私鑰就是（n,d）。此題：（221,155）
之後發送者用公鑰加密明文M，得到密文C=M^e mod n
接受者利用私鑰解密M=C^d mod n
求解d呢，就是求逆元，de = 1 mod n這種形式就稱de於模數n說互逆元，可以看成de-ny=1，此題83e-192y=1.
用擴展的歐幾里得演算法。其實就是輾轉相除
此題：
192=2*83+26
83=3*26+5
26=5*5+1
求到余數為1了，就往回寫
1=26-5*5
=26-5*（83-3*26）
=（192-2*83）-5*（83-3*（192-2*83））
=16*192-37*83
則d=-37，取正後就是155.
記住，往回寫的時候數不該換的一定不要換，比如第二步中的26,一定不能換成(83-5)/3，那樣就求不出來了，最終一定要是192和83相關聯的表達式。還有，最好保持好的書寫格式，比如第一步2*83+26時第二步最好寫成3*26+5而不是26*3+5，要不步驟比較多的話容易亂
『玖』 如何用C語言實現RSA演算法
RSA演算法它是第一個既能用於數據加密也能用於數字簽名的演算法。它易於理解和操作，也很流行。演算法的名字以發明者的名字
命名：Ron Rivest, Adi Shamir 和Leonard
Adleman。但RSA的安全性一直未能得到理論上的證明。它經歷了各種攻擊，至今未被完全攻破。
一、RSA演算法 :
首先, 找出三個數, p, q, r,
其中 p, q 是兩個相異的質數, r 是與 (p-1)(q-1) 互質的數
p, q, r 這三個數便是 private key
接著, 找出 m, 使得 rm == 1 mod (p-1)(q-1)
這個 m 一定存在, 因為 r 與 (p-1)(q-1) 互質, 用輾轉相除法就可以得到了
再來, 計算 n = pq
m, n 這兩個數便是 public key
編碼過程是, 若資料為 a, 將其看成是一個大整數, 假設 a < n
如果 a >= n 的話, 就將 a 表成 s 進位 (s <= n, 通常取 s = 2^t),
則每一位數均小於 n, 然後分段編碼
接下來, 計算 b == a^m mod n, (0 <= b < n),
b 就是編碼後的資料
解碼的過程是, 計算 c == b^r mod pq (0 <= c < pq),
於是乎, 解碼完畢 等會會證明 c 和 a 其實是相等的 :)
如果第三者進行竊聽時, 他會得到幾個數: m, n(=pq), b
他如果要解碼的話, 必須想辦法得到 r
所以, 他必須先對 n 作質因數分解
要防止他分解, 最有效的方法是找兩個非常的大質數 p, q,
使第三者作因數分解時發生困難
<定理>
若 p, q 是相異質數, rm == 1 mod (p-1)(q-1),
a 是任意一個正整數, b == a^m mod pq, c == b^r mod pq,
則 c == a mod pq
證明的過程, 會用到費馬小定理, 敘述如下:
m 是任一質數, n 是任一整數, 則 n^m == n mod m
(換另一句話說, 如果 n 和 m 互質, 則 n^(m-1) == 1 mod m)
運用一些基本的群論的知識, 就可以很容易地證出費馬小定理的
<證明>
因為 rm == 1 mod (p-1)(q-1), 所以 rm = k(p-1)(q-1) + 1, 其中 k 是整數
因為在 molo 中是 preserve 乘法的
(x == y mod z and u == v mod z => xu == yv mod z),
所以, c == b^r == (a^m)^r == a^(rm) == a^(k(p-1)(q-1)+1) mod pq
1. 如果 a 不是 p 的倍數, 也不是 q 的倍數時,
則 a^(p-1) == 1 mod p (費馬小定理) => a^(k(p-1)(q-1)) == 1 mod p
a^(q-1) == 1 mod q (費馬小定理) => a^(k(p-1)(q-1)) == 1 mod q
所以 p, q 均能整除 a^(k(p-1)(q-1)) - 1 => pq | a^(k(p-1)(q-1)) - 1
即 a^(k(p-1)(q-1)) == 1 mod pq
=> c == a^(k(p-1)(q-1)+1) == a mod pq
2. 如果 a 是 p 的倍數, 但不是 q 的倍數時,
則 a^(q-1) == 1 mod q (費馬小定理)
=> a^(k(p-1)(q-1)) == 1 mod q
=> c == a^(k(p-1)(q-1)+1) == a mod q
=> q | c - a
因 p | a
=> c == a^(k(p-1)(q-1)+1) == 0 mod p
=> p | c - a
所以, pq | c - a => c == a mod pq
3. 如果 a 是 q 的倍數, 但不是 p 的倍數時, 證明同上
4. 如果 a 同時是 p 和 q 的倍數時,
則 pq | a
=> c == a^(k(p-1)(q-1)+1) == 0 mod pq
=> pq | c - a
=> c == a mod pq
Q.E.D.
這個定理說明 a 經過編碼為 b 再經過解碼為 c 時, a == c mod n (n = pq)
但我們在做編碼解碼時, 限制 0 <= a < n, 0 <= c < n,
所以這就是說 a 等於 c, 所以這個過程確實能做到編碼解碼的功能
二、RSA 的安全性
RSA的安全性依賴於大數分解，但是否等同於大數分解一直未能得到理論上的證明，因為沒有證明破解
RSA就一定需要作大數分解。假設存在一種無須分解大數的演算法，那它肯定可以修改成為大數分解演算法。目前， RSA
的一些變種演算法已被證明等價於大數分解。不管怎樣，分解n是最顯然的攻擊方法。現在，人們已能分解多個十進制位的大素數。因此，模數n
必須選大一些，因具體適用情況而定。
三、RSA的速度
由於進行的都是大數計算，使得RSA最快的情況也比DES慢上倍，無論是軟體還是硬體實現。速度一直是RSA的缺陷。一般來說只用於少量數據加密。
四、RSA的選擇密文攻擊
RSA在選擇密文攻擊面前很脆弱。一般攻擊者是將某一信息作一下偽裝( Blind)，讓擁有私鑰的實體簽署。然後，經過計算就可得到它所想要的信息。實際上，攻擊利用的都是同一個弱點，即存在這樣一個事實：乘冪保留了輸入的乘法結構：
( XM )^d = X^d *M^d mod n
前面已經提到，這個固有的問題來自於公鑰密碼系統的最有用的特徵--每個人都能使用公鑰。但從演算法上無法解決這一問題，主要措施有兩條：一條是採用好的公
鑰協議，保證工作過程中實體不對其他實體任意產生的信息解密，不對自己一無所知的信息簽名；另一條是決不對陌生人送來的隨機文檔簽名，簽名時首先使用
One-Way HashFunction 對文檔作HASH處理，或同時使用不同的簽名演算法。在中提到了幾種不同類型的攻擊方法。
五、RSA的公共模數攻擊
若系統中共有一個模數，只是不同的人擁有不同的e和d，系統將是危險的。最普遍的情況是同一信息用不同的公鑰加密，這些公鑰共模而且互質，那末該信息無需私鑰就可得到恢復。設P為信息明文，兩個加密密鑰為e1和e2，公共模數是n，則：
C1 = P^e1 mod n
C2 = P^e2 mod n
密碼分析者知道n、e1、e2、C1和C2，就能得到P。
因為e1和e2互質，故用Euclidean演算法能找到r和s，滿足：
r * e1 + s * e2 = 1
假設r為負數，需再用Euclidean演算法計算C1^(-1)，則
( C1^(-1) )^(-r) * C2^s = P mod n
另外，還有其它幾種利用公共模數攻擊的方法。總之，如果知道給定模數的一對e和d，一是有利於攻擊者分解模數，一是有利於攻擊者計算出其它成對的e』和d』，而無需分解模數。解決辦法只有一個，那就是不要共享模數n。
RSA的小指數攻擊。 有一種提高 RSA速度的建議是使公鑰e取較小的值，這樣會使加密變得易於實現，速度有
所提高。但這樣作是不安全的，對付辦法就是e和d都取較大的值。
RSA演算法是
第一個能同時用於加密和數字簽名的演算法，也易於理解和操作。RSA是被研究得最廣泛的公鑰演算法，從提出到現在已近二十年，經歷了各種攻擊的考驗，逐漸為人
們接受，普遍認為是目前最優秀的公鑰方案之一。RSA的安全性依賴於大數的因子分解，但並沒有從理論上證明破譯RSA的難度與大數分解難度等價。即RSA
的重大缺陷是無法從理論上把握它的保密性能
如何，而且密碼學界多數人士傾向於因子分解不是NPC問題。
RSA的缺點主要有：A)產生密鑰很麻煩，受到素數產生技術的限制，因而難以做到一次一密。B)分組長度太大，為保證安全性，n 至少也要 600
bits
以上，使運算代價很高，尤其是速度較慢，較對稱密碼演算法慢幾個數量級；且隨著大數分解技術的發展，這個長度還在增加，不利於數據格式的標准化。目
前，SET( Secure Electronic Transaction )協議中要求CA採用比特長的密鑰，其他實體使用比特的密鑰。
C語言實現
#include <stdio.h>
int candp(int a,int b,int c)
{ int r=1;
b=b+1;
while(b!=1)
{
r=r*a;
r=r%c;
b--;
}
printf("%d\n",r);
return r;
}
void main()
{
int p,q,e,d,m,n,t,c,r;
char s;
printf("please input the p,q: ");
scanf("%d%d",&p,&q);
n=p*q;
printf("the n is %3d\n",n);
t=(p-1)*(q-1);
printf("the t is %3d\n",t);
printf("please input the e: ");
scanf("%d",&e);
if(e<1||e>t)
{
printf("e is error,please input again: ");
scanf("%d",&e);
}
d=1;
while(((e*d)%t)!=1) d++;
printf("then caculate out that the d is %d\n",d);
printf("the cipher please input 1\n");
printf("the plain please input 2\n");
scanf("%d",&r);
switch(r)
{
case 1: printf("input the m: "); /*輸入要加密的明文數字*/
scanf("%d",&m);
c=candp(m,e,n);
printf("the cipher is %d\n",c);break;
case 2: printf("input the c: "); /*輸入要解密的密文數字*/
scanf("%d",&c);
m=candp(c,d,n);
printf("the cipher is %d\n",m);break;
}
getch();
}