Ⅰ c语言有关快速幂的问题
type
arrty=array[1..10000] of longint;
var
n,mn,len,lenm,i,mnl:longint;
a,m:arrty;
procere mxm;
var
c:arrty;
i,j:longint;
begin
fillchar(c,sizeof(c),0);
for i:=1 to lenm do
for j:=1 to lenm do
begin
inc(c[i+j-1],m[i]*m[j]);
inc(c[i+j],c[i+j-1] div 10);
c[i+j-1]:=c[i+j-1] mod 10;
end;
lenm:=lenm+lenm+1;
while (lenm>1) and (c[lenm]=0) do
dec(lenm);
for i:=1 to lenm do
m[i]:=c[i];
end;
procere axm;
var
c:arrty;
i,j:longint;
begin
fillchar(c,sizeof(c),0);
for i:=1 to len do
for j:=1 to lenm do
begin
inc(c[i+j-1],a[i]*m[j]);
inc(c[i+j],c[i+j-1] div 10);
c[i+j-1]:=c[i+j-1] mod 10;
end;
len:=len+lenm+1;
while (len>1) and (c[len]=0) do
dec(len);
for i:=1 to len do
a[i]:=c[i];
end;
begin
fillchar(a,sizeof(a),0);
readln(mn,n);
mnl:=mn;
len:=0;
while mnl>0 do
begin
inc(lenm);
m[lenm]:=mnl mod 10;
mnl:=mnl div 10;
end;
a[1]:=1;
len:=1;
while n>0 do
begin
if n mod 2=1 then
axm;
n:=n div 2;
mxm;
end;
for i:=len downto 1 do
write(a[i]);
writeln;
end.
Ⅱ 在C语言中,0%2=
在C语言中，0%2= 0 。
在C语言中，这是一个取模运算，定义如下：
给定一个正整数p，任意一个整数n，一定存在等式 ：
n = kp + r ；
其中 k、r 是整数，且 0 ≤ r < p，则称 k 为 n 除以 p 的商，r 为 n 除以 p 的余数。
对于正整数 p 和整数 a,b，定义如下运算：
取模运算：a % p（或a mod p），表示a除以p的余数。
模p加法： ，其结果是a+b算术和除以p的余数。
模p减法： ，其结果是a-b算术差除以p的余数。
模p乘法： ，其结果是 a * b算术乘法除以p的余数。
说明：
1. 同余式：正整数a，b对p取模，它们的余数相同，记做 或者a ≡ b (mod p)。
2. n % p 得到结果的正负由被除数n决定,与p无关。例如：7%4 = 3， -7%4 = -3， 7%-4 = 3， -7%-4 = -3。
(2)模幂算法c语言扩展阅读：
1、运算规则
模运算与基本四则运算有些相似，但是除法例外。其规则如下：
(a + b) % p = (a % p + b % p) % p
(a - b) % p = (a % p - b % p) % p
(a * b) % p = (a % p * b % p) % p
a ^ b % p = ((a % p)^b) % p
结合律：
((a+b) % p + c) % p = (a + (b+c) % p) % p
((a*b) % p * c)% p = (a * (b*c) % p) % p
交换律：
(a + b) % p = (b+a) % p
(a * b) % p = (b * a) % p
分配律：
(a+b) % p = ( a % p + b % p ) % p
((a +b)% p * c) % p = ((a * c) % p + (b * c) % p) % p
2、重要定理
若a≡b (% p)，则对于任意的c，都有(a + c) ≡ (b + c) (%p)；
若a≡b (% p)，则对于任意的c，都有(a * c) ≡ (b * c) (%p)；
若a≡b (% p)，c≡d (% p)，则 (a + c) ≡ (b + d) (%p)，(a - c) ≡ (b - d) (%p)，(a * c) ≡ (b * d) (%p)；
Ⅲ C语言取余的原理是怎么回事 比如 int X，Y X-X/Y*Y=x%y
取余实际上就是模运算
基本理论
基本概念：
给定一个正整数p，任意一个整数n，一定存在等式 n = kp + r ；
其中k、r是整数，且 0 ≤ r < p，称呼k为n除以p的商，r为n除以p的余数。
对于正整数p和整数a,b，定义如下运算：
取模运算：a % p（或a mod p），表示a除以p的余数。
模p加法：(a + b) % p ，其结果是a+b算术和除以p的余数，也就是说，(a+b) = kp +r，则(a + b) % p = r。
模p减法：(a-b) % p ，其结果是a-b算术差除以p的余数。
模p乘法：(a * b) % p，其结果是 a * b算术乘法除以p的余数。
说明：
1. 同余式：正整数a，b对p取模，它们的余数相同，记做 a ≡ b % p或者a ≡ b (mod p)。
2. n % p得到结果的正负由被除数n决定,与p无关。例如：7%4 = 3， -7%4 = -3， 7%-4 = 3， -7%-4 = -3。
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->
基本性质
（1）若p|(a-b)，则a≡b (% p)。例如 11 ≡ 4 (% 7)， 18 ≡ 4(% 7)
（2）(a % p)=(b % p)意味a≡b (% p)
（3）对称性：a≡b (% p)等价于b≡a (% p)
（4）传递性：若a≡b (% p)且b≡c (% p) ，则a≡c (% p)
运算规则
模运算与基本四则运算有些相似，但是除法例外。其规则如下：
(a + b) % p = (a % p + b % p) % p （1）
(a - b) % p = (a % p - b % p) % p （2）
(a * b) % p = (a % p * b % p) % p （3）
ab % p = ((a % p)b) % p （4）
结合率： ((a+b) % p + c) % p = (a + (b+c) % p) % p （5）
((a*b) % p * c)% p = (a * (b*c) % p) % p （6）
交换率： (a + b) % p = (b+a) % p （7）
(a * b) % p = (b * a) % p （8）
分配率： ((a +b)% p * c) % p = ((a * c) % p + (b * c) % p) % p （9）
重要定理：若a≡b (% p)，则对于任意的c，都有(a + c) ≡ (b + c) (%p)；（10）
若a≡b (% p)，则对于任意的c，都有(a * c) ≡ (b * c) (%p)；（11）
若a≡b (% p)，c≡d (% p)，则 (a + c) ≡ (b + d) (%p)，(a - c) ≡ (b - d) (%p)，
(a * c) ≡ (b * d) (%p)，(a / c) ≡ (b / d) (%p)； （12）
若a≡b (% p)，则对于任意的c，都有ac≡ bc (%p)； （13）
编辑本段
基本应用
1.判别奇偶数
奇偶数的判别是模运算最基本的应用，也非常简单。易知一个整数n对2取模，如果余数为0，则表示n为偶数，否则n为奇数。
C++实现功能函数：
/*
函数名：IsEven
函数功能：判别整数n的奇偶性。能被2整除为偶数，否则为奇数
输入值：int n，整数n
返回值：bool，若整数n是偶数，返回true，否则返回false
*/
bool IsEven(int n)
{
return (n % 2 == 0);
}
2.判别素数
一个数，如果只有1和它本身两个因数，这样的数叫做质数（或素数）。例如 2，3，5，7 是质数，而 4，6，8，9 则不是，后者称为合成数或合数。
判断某个自然数是否是素数最常用的方法就是试除法：用比该自然数的平方根小的正整数去除这个自然数，若该自然数能被整除，则说明其非素数。
C++实现功能函数：
/*
函数名：IsPrime
函数功能：判别自然数n是否为素数。
输入值：int n，自然数n
返回值：bool，若自然数n是素数，返回true，否则返回false
*/
bool IsPrime(unsigned int n)
{
unsigned maxFactor = sqrt(n); //n的最大因子
for (unsigned int i=2; i<=maxFactor; i++)
{
if (n % i == 0) //n能被i整除，则说明n非素数
{
return false;
}
}
return true;
}
3. 最大公约数
求最大公约数最常见的方法是欧几里德算法（又称辗转相除法），其计算原理依赖于定理：gcd(a,b) = gcd(b,a mod b)
证明：a可以表示成a = kb + r，则r = a mod b
假设d是a,b的一个公约数，则有d|a, d|b，而r = a - kb，因此d|r
因此d是(b,a mod b)的公约数
假设d 是(b,a mod b)的公约数，则d | b , d |r ，但是a = kb +r
因此d也是(a,b)的公约数
因此(a,b)和(b,a mod b)的公约数是一样的，其最大公约数也必然相等，得证。
C++实现功能函数：
/*
函数功能：利用欧几里德算法，采用递归方式，求两个自然数的最大公约数
函数名：Gcd
输入值：unsigned int a，自然数a
unsigned int b，自然数b
返回值：unsigned int，两个自然数的最大公约数
*/
unsigned int Gcd(unsigned int a, unsigned int b)
{
if (b == 0)
return a;
return Gcd(b, a % b);
}
/*
函数功能：利用欧几里德算法，采用迭代方式，求两个自然数的最大公约数 函数名：Gcd
输入值：unsigned int a，自然数a
unsigned int b，自然数b
返回值：unsigned int，两个自然数的最大公约数
*/
unsigned int Gcd(unsigned int a, unsigned int b)
{
unsigned int temp;
while (b != 0)
{
temp = a % b;
a = b;
b = temp;
}
return a;
}
4．模幂运算
利用模运算的运算规则，我们可以使某些计算得到简化。例如，我们想知道3333^5555的末位是什么。很明显不可能直接把3333^5555的结果计算出来，那样太大了。但我们想要确定的是3333^5555（%10），所以问题就简化了。
根据运算规则（4）ab % p = ((a % p)b) % p ，我们知道3333^5555（%10）= 3^5555（%10）。由于3^4 = 81，所以3^4（%10）= 1。
根据运算规则（3） (a * b) % p = (a % p * b % p) % p ，由于5555 = 4 * 1388 + 3，我们得到3^5555（%10）=（3^(4*1388) * 3^3）（%10）=（（3^(4*1388)（%10）* 3^3（%10））（%10）
=（1 * 7）（%10）= 7。
计算完毕。
利用这些规则我们可以有效地计算X^N(% P)。简单的算法是将result初始化为1，然后重复将result乘以X，每次乘法之后应用%运算符（这样使得result的值变小，以免溢出），执行N次相乘后，result就是我们要找的答案。
这样对于较小的N值来说，实现是合理的，但是当N的值很大时，需要计算很长时间，是不切实际的。下面的结论可以得到一种更好的算法。
如果N是偶数，那么X^N =（X*X）^[N/2]；
如果N是奇数，那么X^N = X*X^(N-1) = X *（X*X）^[N/2]；
其中[N]是指小于或等于N的最大整数。
C++实现功能函数：
/*
函数功能：利用模运算规则，采用递归方式，计算X^N(% P)
函数名：PowerMod
输入值：unsigned int x，底数x
unsigned int n，指数n
unsigned int p，模p
返回值：unsigned int，X^N(% P)的结果
*/
unsigned int PowerMod(unsigned int x, unsigned int n, unsigned int p)
{
if (n == 0)
{
return 1;
}
unsigned int temp = PowerMod((x * x)%p, n/2, p); //递归计算（X*X）^[N/2]
if ((n & 1) != 0) //判断n的奇偶性
{
temp = (temp * x) % p;
}
return temp;
}
5.《孙子问题(中国剩余定理)》
在我国古代算书《孙子算经》中有这样一个问题：
“今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二，问物几何？”意思是，“一个数除以3余2，除以5余3，除以7余2.求适合这个条件的最小数。”
这个问题称为“孙子问题”.关于孙子问题的一般解法，国际上称为“中国剩余定理”.
我国古代学者早就研究过这个问题。例如我国明朝数学家程大位在他着的《算法统宗》（1593年）中就用四句很通俗的口诀暗示了此题的解法：
三人同行七十稀，五树梅花甘一枝，七子团圆正半月，除百零五便得知。
"正半月"暗指15。"除百零五"的原意是，当所得的数比105大时，就105、105地往下减，使之小于105；这相当于用105去除，求出余数。
这四句口诀暗示的意思是：当除数分别是3、5、7时，用70乘以用3除的余数，用21乘以用5除的余数，用15乘以用7除的余数，然后把这三个乘积相加。加得的结果如果比105大，就除以105，所得的余数就是满足题目要求的最小正整数解。
根据剩余定理，我把此种解法推广到有n(n为自然数）个除数对应n个余数，求最小被除数的情况。输入n个除数（除数不能互相整除）和对应的余数，计算机将输出最小被除数。
C++实现功能函数：
/*
函数名：ResieTheorem
函数功能：运用剩余定理，解决推广了的孙子问题。通过给定n个除数（除数不能互相整除）和对应的余数，返回最小被除数
输入值：unsigned int devisor[]，存储了n个除数的数组
unsigned int remainder[]，存储了n个余数的数组
int length，数组的长度
返回值：unsigned int， 最小被除数
*/
unsigned int ResieTheorem(const unsigned int devisor[], const unsigned int remainder[], int length)
{
unsigned int proct = 1; //所有除数之乘积
for (int i=0; i<length; i++)//计算所有除数之乘积
{
proct *= devisor[i];
}
//公倍数数组，表示除该元素（除数）之外其他除数的公倍数
unsigned int *commonMultiple = new unsigned int(length);
for (int i=0; i<length; i++)//计算除该元素（除数）之外其他除数的公倍数
{
commonMultiple[i] = proct / devisor[i];
}
unsigned int dividend = 0; //被除数，就是函数要返回的值
for (int i=0; i<length; i++)//计算被除数，但此时得到的不是最小被除数
{
unsigned int tempMul = commonMultiple[i];
//按照剩余理论计算合适的公倍数，使得tempMul % devisor[i] == 1
while (tempMul % devisor[i] != 1)
{
tempMul += commonMultiple[i];
}
dividend += tempMul * remainder[i]; //用本除数得到的余数乘以其他除数的公倍数
}
delete []commonMultiple;
return (dividend % proct); //返回最小被除数
}
6. 凯撒密码
凯撒密码（caeser）是罗马扩张时期朱利斯o凯撒（Julius Caesar）创造的，用于加密通过信使传递的作战命令。
它将字母表中的字母移动一定位置而实现加密。注意26个字母循环使用，z的后面可以堪称是a。
例如，当密匙为k = 3，即向后移动3位时，若明文为”How are you!”，则密文为”Krz h btx!”。
凯撒密码的加密算法极其简单。其加密过程如下：
在这里，我们做此约定：明文记为m，密文记为c，加密变换记为E(key1,m)（其中key1为密钥），
解密变换记为D(key2,m)（key2为解密密钥）（在这里key1=key2,不妨记为key）。
凯撒密码的加密过程可记为如下一个变换：c≡m+key (mod n） （其中n为基本字符个数）
同样，解密过程可表示为：m≡c+key (mod n） （其中n为基本字符个数）
C++实现功能函数：
/*
函数功能：使用凯撒密码原理，对明文进行加密，返回密文 函数名：Encrypt
输入值：const char proclaimedInWriting[]，存储了明文的字符串
char cryptograph[]，用来存储密文的字符串
int keyey，加密密匙，正数表示后移，负数表示前移
返回值：无返回值，但是要将新的密文字符串返回
*/
void Encrypt(const char proclaimedInWriting[], char cryptograph[], int key)
{
const int NUM = 26; //字母个数
int len = strlen(proclaimedInWriting);
for (int i=0; i<len; i++)
{
if (proclaimedInWriting[i] >= 'a' && proclaimedInWriting[i] <= 'z')
{//明码是大写字母，则密码也为大写字母
cryptograph[i] = (proclaimedInWriting[i] - 'a' + key) % NUM + 'a';
}
else if (proclaimedInWriting[i] >= 'A' && proclaimedInWriting[i] <= 'Z')
{//明码是小写字母，则密码也为小写字母
cryptograph[i] = (proclaimedInWriting[i] - 'A' + key) % NUM + 'A';
}
else
{//明码不是字母，则密码与明码相同
cryptograph[i] = proclaimedInWriting[i];
}
}
cryptograph[len] = '\0';
}
/*
函数功能：使用凯撒密码原理，对密文进行解密，返回明文 函数名：Decode
输入值：char proclaimedInWriting[]，用来存储明文的字符串
const char cryptograph[]，存储了密文的字符串
int keyey，解密密匙，正数表示前移，负数表示后移（与加密相反）
返回值：无返回值，但是要将新的明文字符串返回
*/
void Decode(const char cryptograph[], char proclaimedInWriting[], int key)
{
const int NUM = 26; //字母个数
int len = strlen(cryptograph);
for (int i=0; i<len; i++)
{
if (cryptograph[i] >= 'a' && cryptograph[i] <= 'z')
{//密码是大写字母，则明码也为大写字母，为防止出现负数，转换时要加个NUM
proclaimedInWriting[i] = (cryptograph[i] - 'a' - key + NUM) % NUM + 'a';
}
else if (cryptograph[i] >= 'A' && cryptograph[i] <= 'Z')
{//密码是小写字母，则明码也为小写字母
proclaimedInWriting[i] = (cryptograph[i] - 'A' - key + NUM) % NUM + 'A';
}
else
{//密码不是字母，则明码与明密相同
proclaimedInWriting[i] = cryptograph[i];
}
}
proclaimedInWriting[len] = '\0';
}
Ⅳ C语言里 0%2是多少
0%2=0，0%2是没有余数，%是表示“取余数”0除以任何数后都不会存在余数，所,以说余数为0。这是一个取模运算，在数论和程序设计中都有着广泛的应用，奇偶数的判别到素数的判别，从模幂运算到最大公约数的求法，从孙子问题到凯撒密码问题，无不充斥着模运算的身影。
(4)模幂算法c语言扩展阅读：
对于整型数a，b来说，取模运算或者求余运算的方法都是：
1、求整数商： c = [a/b];
2、计算模或者余数： r = a - c*b.
求模运算和求余运算在第一步不同: 取余运算在取c的值时，向0 方向舍入(fix()函数)；而取模运算在计算c的值时，向负无穷方向舍入(floor()函数)。
例如计算：-7 Mod 4
那么：a = -7；b = 4；
第一步：求整数商c，如进行求模运算c = -2（向负无穷方向舍入），求余c = -1（向0方向舍入）；
第二步：计算模和余数的公式相同，但因c的值不同，求模时r = 1，求余时r = -3。
归纳：当a和b符号一致时，求模运算和求余运算所得的c的值一致，因此结果一致。
当符号不一致时，结果不一样。
Ⅳ c语言计算一个数q的1次方到n次方的和，而q和n的数量级都是10的9次方，结果取模，怎么减少时间呢
首先，将求和改为利用等比公式求和的公式来计算。其次，计算q的n+1次方时，使用快速幂的计算方法。为了防止溢出，每次乘积以后都先取模，再进行下一次的运算并取模。
Ⅵ c语言如何取模运算
取模运算：a % p（或a mod p），表示a除以p的余数。
比如给定一个正整数p，任意一个整数n，一定存在等式 ：n = kp + r ；其中 k、r 是整数，且 0 ≤ r < p，则称 k 为 n 除以 p 的商，r 为 n 除以 p 的余数。
取模运算的规则如下：
1、(a + b) % p = (a % p + b % p) % p 。
2、(a - b) % p = (a % p - b % p) % p 。
3、(a * b) % p = (a % p * b % p) % p 。
4、a ^ b % p = ((a % p)^b) % p 。
(6)模幂算法c语言扩展阅读：
模运算与基本四则运算有些相似，但是除法例外。其规则如下：
(a + b) % p = (a % p + b % p) % p （1）
(a - b) % p = (a % p - b % p) % p （2）
(a * b) % p = (a % p * b % p) % p （3）
a ^ b % p = ((a % p)^b) % p （4）
结合律：
((a+b) % p + c) % p = (a + (b+c) % p) % p （5）
((a*b) % p * c)% p = (a * (b*c) % p) % p （6）
交换律：
(a + b) % p = (b+a) % p （7）
(a * b) % p = (b * a) % p （8）
分配律：
(a+b) % p = ( a % p + b % p ) % p （9）
((a +b)% p * c) % p = ((a * c) % p + (b * c) % p) % p （10）
参考资料：网络-取模运算
Ⅶ 如何用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();
}
Ⅷ C语言用递归算法实现：整数模幂运算 x的r次模p。 用循环控制比较简单，但是自己用递归写了个运行时结果不
需要输入x，r，p
#include <stdio.h>
void Run(int x,int r,int p,int t)
{
int a,b,c;
a=x;b=r;c=t;
if(b==0)
{
printf("%d",c);
return;
}
if((b>0)&&(b%2==0))
{
b=b/2;
a=(a*a)%p;
}
else
{
b=b-1;
c=(a*c)%p;
}
Run(a,b,p,c);
}
void main()
{
int x,r,p,t=1;
printf("please enter x :");
scanf("%d",&x);
printf("please enter r :");
scanf("%d",&r);
printf("please enter p :");
scanf("%d",&p);
Run(x,r,p,t);
}
Ⅸ 一道关于大数幂运算的题目，c语言实现
x^y=(x*x)^y/2
根据这个递归可以得到时间复杂度
为 lgn的算法！
但是栈上的空间估计会爆！
.....
Ⅹ c语言，快速幂代码是什么，怎么用
所谓的快速幂，实际上是快速幂取模的缩写，简单的说，就是快速的求一个幂式的模(余)。在程序设计过程中，经常要去求一些大数对于某个数的余数，为了得到更快、计算范围更大的算法，产生了快速幂取模算法。
用递归
x^y可如下实现
unsigned
long
pow(int
x,
unsigned
y)
{
unsigned
long
tmp;
if(!y)
return
1;
tmp
=
pow(x,
y
/
2);
if(y
%
2
==
0)
return
(tmp
*
tmp);
else
return
(tmp
*
tmp
*
x);
}