<一>基础
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。
<二>实践
接下来我们来一个实践，看看实际的 *** 作：
找两个素数：
p=47
q=59
这样
n=p*q=2773
t=(p-1)*(q-1)=2668
取e=63，满足e<t并且e和t互素
用perl简单穷举可以获得满主 e*d%t ==1的数d：
C:\Temp>perl -e "foreach $i (1..9999){ print($i),last if $i*63%2668==1 }"
847
即d＝847
最终我们获得关键的
n=2773
d=847
e=63
取消息M=244我们看看
加密：
c=M**d%n = 244**847%2773
用perl的大数计算来算一下：
C:\Temp>perl -Mbigint -e "print 244**847%2773"
465
即用d对M加密后获得加密信息c＝465
解密：
我们可以用e来对加密后的c进行解密，还原M：
m=c**e%n=465**63%2773 ：
C:\Temp>perl -Mbigint -e "print 465**63%2773"
244
即用e对c解密后获得m=244 , 该值和原始信息M相等。
<三>字符串加密
把上面的过程集成一下我们就能实现一个对字符串加密解密的示例了。
每次取腊闹字符串中的一个字符的ascii值作为M进行计算，其输出为加密后16进制
的数的字符串形式，按3字节表示，如01F
代码如下：
#!/usr/bin/perl -w
#RSA 计算过程学习程序编写的测试程序
#watercloud 2003-8-12
#
use strict
use Math::BigInt
my %RSA_CORE = (n=>2773,e=>63,d=>847)#p=47,q=59
my $N=new Math::BigInt($RSA_CORE{n})
my $E=new Math::BigInt($RSA_CORE{e})
my $D=new Math::BigInt($RSA_CORE{d})
print "N=$N D=$D E=$E\n"
sub RSA_ENCRYPT
{
my $r_mess = shift @_
my ($c,$i,$M,$C,$cmess)
for($i=0$i <length($$r_mess)$i++)
{
$c=ord(substr($$r_mess,$i,1))
$M=Math::BigInt->new($c)
$C=$M->copy()$C->bmodpow($D,$N)
$c=sprintf "%03X",$C
$cmess.=$c
}
return \$cmess
}
sub RSA_DECRYPT
{
my $r_mess = shift @_
my ($c,$i,$M,$C,$dmess)
for($i=0$i <length($$r_mess)$i+=3)
{
$c=substr($$r_mess,$i,3)
$c=hex($c)
$M=Math::BigInt->new($c)
$C=$M->copy()$C->bmodpow($E,$N)
$c=chr($C)
$dmess.=$c
}
return \$dmess
}
my $mess="RSA 娃哈哈哈～～～"
$mess=$ARGV[0] if @ARGV >= 1
print "原始串：",$mess,"\n"
my $r_cmess = RSA_ENCRYPT(\$mess)
print "加密串：",$$r_cmess,"\n"
my $r_dmess = RSA_DECRYPT($r_cmess)
print "解密串：",$$r_dmess,"\n"
#EOF
测试一下：
C:\Temp>perl rsa-test.pl
N=2773 D=847 E=63
原始串：RSA 娃哈哈哈～～～
加密串：5CB6CD6BC58A7709470AA74A0AA74A0AA74A6C70A46C70A46C70A4
解密串：RSA 娃哈哈哈～～～
C:\Temp>perl rsa-test.pl 安全焦点（xfocus）
N=2773 D=847 E=63
原始串：安全焦点（xfocus）
加密串：3393EC12F0A466E0AA9510D025D7BA0712DC3379F47D51C325D67B
解密串：安全焦点（xfocus）
<四>提高
前面已经提到，rsa的安全来源于n足够大，我们测试中使用的n是非常小的，根本不能保障安全性，
我们可以通过RSAKit、RSATool之类的工具获得足够大的N 及D E。
通过工具，我们获得1024位的N及D E来测试一下：
n=0x328C74784DF31119C526D18098EBEBB943B0032B599CEE13CC2BCE7B5FCD15F90B66EC3A85F5005D
BDCDED9BDFCB3C4C265AF164AD55884D8278F791C7A6BFDAD55EDBC4F017F9CCF1538D4C2013433B383B
47D80EC74B51276CA05B5D6346B9EE5AD2D7BE7ABFB36E37108DD60438941D2ED173CCA50E114705D7E2
BC511951
d=0x10001
e=0xE760A3804ACDE1E8E3D7DC0197F9CEF6282EF552E8CEBBB7434B01CB19A9D87A3106DD28C523C2995
4C5D86B36E943080E4919CA8CE08718C3B0930867A98F635EB9EA9200B25906D91B80A47B77324E66AFF2
C4D70D8B1C69C50A9D8B4B7A3C9EE05FFF3A16AFC023731D80634763DA1DCABE9861A4789BD782A592D2B
1965
设原始信息
M=0x11111111111122222222222233333333333
完成这么大数字的计算依赖于大数运算库，用perl来运算非常简单：
A) 用d对M进行加密如下：
c=M**d%n :
C:\Temp>perl -Mbigint -e " $x=Math::BigInt->bmodpow(0x11111111111122222222222233
333333333, 0x10001, 0x328C74784DF31119C526D18098EBEBB943B0032B599CEE13CC2BCE7B5F
CD15F90B66EC3A85F5005DBDCDED9BDFCB3C4C265AF164AD55884D8278F791C7A6BFDAD55EDBC4F0
17F9CCF1538D4C2013433B383B47D80EC74B51276CA05B5D6346B9EE5AD2D7BE7ABFB36E37108DD6
0438941D2ED173CCA50E114705D7E2BC511951)print $x->as_hex"
0x17b287be418c69ecd7c39227ab681ac422fcc84bb35d8a632543b304de288a8d4434b73d2576bd
45692b007f3a2f7c5f5aa1d99ef3866af26a8e876712ed1d4cc4b293e26bc0a1dc67e247715caa6b
3028f9461a3b1533ec0cb476441465f10d8ad47452a12db0601c5e8beda686dd96d2acd59ea89b91
f1834580c3f6d90898
即用d对M加密后信息为：
c=0x17b287be418c69ecd7c39227ab681ac422fcc84bb35d8a632543b304de288a8d4434b73d2576bd
45692b007f3a2f7c5f5aa1d99ef3866af26a8e876712ed1d4cc4b293e26bc0a1dc67e247715caa6b
3028f9461a3b1533ec0cb476441465f10d8ad47452a12db0601c5e8beda686dd96d2acd59ea89b91
f1834580c3f6d90898
B) 用e对c进行解密如下：
m=c**e%n ：
C:\Temp>perl -Mbigint -e " $x=Math::BigInt->bmodpow(0x17b287be418c69ecd7c39227ab
681ac422fcc84bb35d8a632543b304de288a8d4434b73d2576bd45692b007f3a2f7c5f5aa1d99ef3
866af26a8e876712ed1d4cc4b293e26bc0a1dc67e247715caa6b3028f9461a3b1533ec0cb4764414
65f10d8ad47452a12db0601c5e8beda686dd96d2acd59ea89b91f1834580c3f6d90898, 0xE760A
3804ACDE1E8E3D7DC0197F9CEF6282EF552E8CEBBB7434B01CB19A9D87A3106DD28C523C29954C5D
86B36E943080E4919CA8CE08718C3B0930867A98F635EB9EA9200B25906D91B80A47B77324E66AFF
2C4D70D8B1C69C50A9D8B4B7A3C9EE05FFF3A16AFC023731D80634763DA1DCABE9861A4789BD782A
592D2B1965, 0x328C74784DF31119C526D18098EBEBB943B0032B599CEE13CC2BCE7B5FCD15F90
B66EC3A85F5005DBDCDED9BDFCB3C4C265AF164AD55884D8278F791C7A6BFDAD55EDBC4F017F9CCF
1538D4C2013433B383B47D80EC74B51276CA05B5D6346B9EE5AD2D7BE7ABFB36E37108DD60438941
D2ED173CCA50E114705D7E2BC511951)print $x->as_hex"
0x11111111111122222222222233333333333
(我的P4 1.6G的机器上计算了约5秒钟）
得到用e解密后的m=0x11111111111122222222222233333333333 == M
C) RSA通常的实现
RSA简洁幽雅，但计算速度比较慢，通常加密中并不是直接使用RSA 来对所有的信息进行加密，
最常见的情况是随机产生一个对称加密的密钥，然后使用对称加密算法对信息加密，之后用
RSA对刚才的加密密钥进行加密。
最后需要说明的是，当前小于1024位的N已经被证明是不安全的
自己使用中不要使用小于1024位的RSA，最好使用2048位的。
----------------------------------------------------------
一个简单的RSA算法实现JAVA源代码：
filename:RSA.java
/*
* Created on Mar 3, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
import java.math.BigInteger
import java.io.InputStream
import java.io.OutputStream
import java.io.FileInputStream
import java.io.FileOutputStream
import java.io.FileNotFoundException
import java.io.IOException
import java.io.FileWriter
import java.io.FileReader
import java.io.BufferedReader
import java.util.StringTokenizer
/**
* @author Steve
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class RSA {
/**
* BigInteger.ZERO
*/
private static final BigInteger ZERO = BigInteger.ZERO
/**
* BigInteger.ONE
*/
private static final BigInteger ONE = BigInteger.ONE
/**
* Pseudo BigInteger.TWO
*/
private static final BigInteger TWO = new BigInteger("2")
private BigInteger myKey
private BigInteger myMod
private int blockSize
public RSA (BigInteger key, BigInteger n, int b) {
myKey = key
myMod = n
blockSize = b
}
public void encodeFile (String filename) {
byte[] bytes = new byte[blockSize / 8 + 1]
byte[] temp
int tempLen
InputStream is = null
FileWriter writer = null
try {
is = new FileInputStream(filename)
writer = new FileWriter(filename + ".enc")
}
catch (FileNotFoundException e1){
System.out.println("File not found: " + filename)
}
catch (IOException e1){
System.out.println("File not found: " + filename + ".enc")
}
/**
* Write encoded message to 'filename'.enc
*/
try {
while ((tempLen = is.read(bytes, 1, blockSize / 8)) >0) {
for (int i = tempLen + 1i <bytes.length++i) {
bytes[i] = 0
}
writer.write(encodeDecode(new BigInteger(bytes)) + " ")
}
}
catch (IOException e1) {
System.out.println("error writing to file")
}
/**
* Close input stream and file writer
*/
try {
is.close()
writer.close()
}
catch (IOException e1) {
System.out.println("Error closing file.")
}
}
public void decodeFile (String filename) {
FileReader reader = null
OutputStream os = null
try {
reader = new FileReader(filename)
os = new FileOutputStream(filename.replaceAll(".enc", ".dec"))
}
catch (FileNotFoundException e1) {
if (reader == null)
System.out.println("File not found: " + filename)
else
System.out.println("File not found: " + filename.replaceAll(".enc", "dec"))
}
BufferedReader br = new BufferedReader(reader)
int offset
byte[] temp, toFile
StringTokenizer st = null
try {
while (br.ready()) {
st = new StringTokenizer(br.readLine())
while (st.hasMoreTokens()){
toFile = encodeDecode(new BigInteger(st.nextToken())).toByteArray()
System.out.println(toFile.length + " x " + (blockSize / 8))
if (toFile[0] == 0 &&toFile.length != (blockSize / 8)) {
temp = new byte[blockSize / 8]
offset = temp.length - toFile.length
for (int i = toFile.length - 1(i <= 0) &&((i + offset) <= 0)--i) {
temp[i + offset] = toFile[i]
}
toFile = temp
}
/*if (toFile.length != ((blockSize / 8) + 1)){
temp = new byte[(blockSize / 8) + 1]
System.out.println(toFile.length + " x " + temp.length)
for (int i = 1i <temp.lengthi++) {
temp[i] = toFile[i - 1]
}
toFile = temp
}
else
System.out.println(toFile.length + " " + ((blockSize / 8) + 1))*/
os.write(toFile)
}
}
}
catch (IOException e1) {
System.out.println("Something went wrong")
}
/**
* close data streams
*/
try {
os.close()
reader.close()
}
catch (IOException e1) {
System.out.println("Error closing file.")
}
}
/**
* Performs <tt>base</tt>^<sup><tt>pow</tt></sup>within the modular
* domain of <tt>mod</tt>.
*
* @param base the base to be raised
* @param pow the power to which the base will be raisded
* @param mod the modular domain over which to perform this operation
* @return <tt>base</tt>^<sup><tt>pow</tt></sup>within the modular
* domain of <tt>mod</tt>.
*/
public BigInteger encodeDecode(BigInteger base) {
BigInteger a = ONE
BigInteger s = base
BigInteger n = myKey
while (!n.equals(ZERO)) {
if(!n.mod(TWO).equals(ZERO))
a = a.multiply(s).mod(myMod)
s = s.pow(2).mod(myMod)
n = n.divide(TWO)
}
return a
}
}
看你催就仓促写了个，自我感觉写的不是很好，但是能用了。数据只能是大写字母组成的字符串。加密的时候，输入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 = 0i <li ++)
{ 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 = 0i <leni ++)
{ if (i) putchar('-')
printf(" %ld ", encode(nume[i]))
}
putchar('\n')
}
else
{ scanf("%d", &len)
for (i = 0i <leni ++)
{ 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
#include <stdio.h>#include <stdlib.h>
#include <time.h>
//RSA??????
typedef struct RSA_PARAM_Tag
{
unsigned __int64p, q //皮行????,?????????
unsigned __int64f //f=(p-1)*(q-1),?????????
unsigned __int64n, e //??,n=p*q,gcd(e,f)=1
unsigned __int64d //??,e*d=1 (mod f),gcd(n,d)=1
unsigned __int64s //??,??2^s<=n????s,?log2(n)
} RSA_PARAM
//????
const static long g_PrimeTable[]=
{
3,
5,
7,
11,
13,
17,
19,
23,
29,
31,
37,
41,
43,
47,
53,
59,
61,
67,
71,
73,
79,
83,
89,
97
}
const static long g_PrimeCount=sizeof(g_PrimeTable) / sizeof(long)const unsigned __int64 multiplier=12747293821
const unsigned __int64 adder=1343545677842234541//如握神????
typedef struct _RandNumber
{
/* */
unsigned __int64randSeed/* */
}RandNumber
static voidCreateRandNumber(RandNumber *pRand, unsigned __int64 s)
static unsigned __int64Random(RandNumber *pRand, unsigned __int64 n)
/渣亏* */
void CreateRandNumber(RandNumber *pRand, unsigned __int64 s)
{
if(!s)
{
pRand->randSeed= (unsigned __int64)time(NULL)
}
else
{
pRand->randSeed=s
}
}
/* */
unsigned __int64 Random(RandNumber *pRand, unsigned __int64 n)
{
pRand->randSeed=multiplier * pRand->randSeed + adder
return pRand->randSeed % n
}
static RandNumber g_Rnd
/*
????,??? x=a*b mod n
*/
unsigned __int64 MulMod(unsigned __int64 a, unsigned __int64 b, unsigned __int64 n)
{
return a * b % n
}
/*
????,??? x=base^pow mod n
*/
unsigned __int64 PowMod(unsigned __int64 base, unsigned __int64 pow, unsigned __int64 n)
{
unsigned __int64a=base, b=pow, c=1
while(b)
{
while(!(b &1))
{
b>>=1 //a=a * a % n //?????????64????,?????a*a?a>=2^32????????,??????????64?
a=MulMod(a, a, n)
}
b-- //c=a * c % n //??????,??64???????32????????????????
c=MulMod(a, c, n)
}
return c
}
/*
Rabin-Miller????,??????1,????0?
n??????
??:????????????,???????????1/4
*/
long RabinMillerKnl(unsigned __int64 n)
{
unsigned __int64b, m, j, v, i
unsigned __int64 TWO = 2
m=n - 1
j=0 //0?????m?j,??n-1=m*2^j,??m????,j?????
while(!(m &1))
{
++j
m>>=1
}
//1??????b,2<=b<n-1
b=2 + Random(&g_Rnd, n - 3)
//2???v=b^m mod n
v=PowMod(b, m, n)
//3???v==1,????
if(v == 1)
{
return 1
}
//4??i=1
i=1
//5???v=n-1,????
while(v != n - 1)
{
//6???i==l,???,??
if(i == j)
{
return 0
}
//7?v=v^2 mod n,i=i+1
v=PowMod(v, TWO, n)
++i
//8????5
}
return 1
}
/*
Rabin-Miller????,??????loop?
??????1,????0
*/
long RabinMiller(unsigned __int64 n, long loop)
{
long i=0
//?????????,????
for(i=0i <g_PrimeCounti++)
{
if(n % g_PrimeTable[i] == 0)
{
return 0
}
}
//????Rabin-Miller??loop?,??????????????(1/4)^loop
for(i=0i <loopi++)
{
if(!RabinMillerKnl(n))
{
return 0
}
}
return 1
}
/*
??????bits?(????)???,??32?
*/
unsigned __int64 RandomPrime(char bits)
{
unsigned __int64base
do
{
base= (unsigned long)1 <<(bits - 1) //??????1
base+=Random(&g_Rnd, base) //????????
base|=1 //??????1,??????
} while(!RabinMiller(base, 30)) //????-????30?
return base //?????????
}
/*
???????????
*/
unsigned __int64 EuclidGcd(unsigned __int64 p, unsigned __int64 q)
{
unsigned __int64a=p >q ? p : q
unsigned __int64b=p <q ? p : q
unsigned __int64t
if(p == q)
{
return p //????,?????????
}
else
{
while(b)//?????,gcd(a,b)=gcd(b,a-qb)
{
a=a % b
t=a
a=b
b=t
}
return a
}
}
/*
Stein???????
*/
unsigned __int64 SteinGcd(unsigned __int64 p, unsigned __int64 q)
{
unsigned __int64a=p >q ? p : q
unsigned __int64b=p <q ? p : q
unsigned __int64t, r=1
if(p == q)
{
return p //????,?????????
}
else
{
while((!(a &1)) &&(!(b &1)))
{
r<<=1 //a?b?????,gcd(a,b)=2*gcd(a/2,b/2)
a>>=1
b>>=1
}
if(!(a &1))
{
t=a //??a???,??a,b
a=b
b=t
}
do
{
while(!(b &1))
{
b>>=1 //b???,a????,gcd(b,a)=gcd(b/2,a)
}if(b <a)
{
t=a //??b??a,??a,b
a=b
b=t
}b=(b - a) >>1//b?a????,gcd(b,a)=gcd((b-a)/2,a)
} while(b)
return r * a
}
}
/*
??a?b,?x,??a*x =1 (mod b)
?????a*x-b*y=1??????
*/
unsigned __int64 Euclid(unsigned __int64 a, unsigned __int64 b)
{
unsigned __int64m, e, i, j, x, y
longxx, yy
m=b
e=a
x=0
y=1
xx=1
yy=1
while(e)
{
i=m / e
j=m % e
m=e
e=j
j=y
y*=i
if(xx == yy)
{
if(x >y)
{
y=x - y
}
else
{
y-=x
yy=0
}
}
else
{
y+=x
xx=1 - xx
yy=1 - yy
}x=j
}if(xx == 0)
{
x=b - x
}return x
}
/*
??????RSA????
*/
RSA_PARAM RsaGetParam(RandNumber Rnd)
{
RSA_PARAM Rsa={ 0 }
unsigned __int64t
Rsa.p=RandomPrime(16) //????????
Rsa.q=RandomPrime(16)
Rsa.n=Rsa.p * Rsa.q
Rsa.f=(Rsa.p - 1) * (Rsa.q - 1)
do
{
Rsa.e=Random(&Rnd, 65536) //??2^16,65536=2^16
Rsa.e|=1 //??????1,??????,?f?????,???,?????
} while(SteinGcd(Rsa.e, Rsa.f) != 1)
Rsa.d=Euclid(Rsa.e, Rsa.f)
Rsa.s=0
t=Rsa.n >>1
while(t)
{
Rsa.s++ //s=log2(n)
t>>=1
}
return Rsa
}
/*
??-????
*/
void TestRM(void)
{
unsigned long k=0
unsigned __int64 i = 0
printf(" - Rabin-Miller prime check.\n\n")
for(i=4197900001i <4198000000i+=2)
{
if(RabinMiller(i, 30))
{
k++
printf("%ul\n", i)
}
}
printf("Total: %ul\n", k)
}
void Usage(void)
{
printf("0. exit\n")
printf("1. encryption\n")
printf("2. decrypt\n")
printf("enter your choice:")
}
int GetChoice(void)
{
char s[80] = {0}
fgets(s, sizeof(s), stdin)
if ('0' >s[0] || '9' <s[0] || '\n' != s[1])
{
return -1
}
else
{
return s[0] - '0'
}
}
#define ENCRYPT_CODE 1
#define DECRYPT_CODE 2
#define EXIT_CODE 0
#define MAX_SIZE 1024
int main(void)
{
RSA_PARAM r
charpSrc[MAX_SIZE]={0}
unsigned long n = 0
unsigned char *q = NULL
unsigned char pDec[MAX_SIZE] = {0}
unsigned __int64pEnc[MAX_SIZE] = {0}
unsigned __int64tmp = 0
unsigned long i=0
int choice = 0
unsigned __int64 s = 0
CreateRandNumber(&g_Rnd, s)
r=RsaGetParam(g_Rnd)
/*
printf("p=%ul\n", r.p)
printf("q=%ul\n", r.q)
printf("f=(p-1)*(q-1)=%ul\n", r.f)
printf("n=p*q=%ul\n", r.n)
printf("e=%ul\n", r.e)
printf("d=%ul\n", r.d)
printf("s=%ul\n", r.s)
*/
while (1)
{
memset(pSrc, 0, MAX_SIZE)
memset(pDec, 0, MAX_SIZE)
memset(pEnc, 0, MAX_SIZE)
Usage()
choice = GetChoice()
switch(choice)
{
case ENCRYPT_CODE:
printf("Source:%s", pSrc)
scanf("%s", pSrc)
n = strlen(pSrc)
getchar()
q= (unsigned char *)pSrc
printf("Encode:")
for(i = 0i <ni++)
{
tmp = q[i]
pEnc[i]=PowMod(tmp, r.e, r.n)
printf("%x ", pEnc[i])
}
printf("\n")
break
case DECRYPT_CODE:
printf("Enter length of ciphertext:")
scanf("%d", &n)
getchar()
for(i=0i <ni++)
{
printf("Enter ciphertext(%d):", i+1)
scanf("%x", &pEnc[i])
getchar()
}
printf("Decode:")
for(i=0i <ni++)
{
pDec[i]=PowMod(pEnc[i], r.d, r.n)
printf("%x ", (unsigned long)pDec[i])
}
printf("\n")
printf("%s\n", (char *)pDec)
break
case EXIT_CODE:
break
default:
break
}
if (EXIT_CODE == choice)
{
break
}
else
{
continue
}
}
return 0
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）