rsa算法原理
RSA加密算法的安全性分析
RSA加密算法的安全性分析RSA加密算法是一种公钥加密算法，广泛应用于加密通信中。
它的安全性是众所周知的，但是随着计算机技术的发展，RSA加密算法也面临着越来越大的挑战。
本文将对RSA加密算法的安全性进行分析，并探讨其存在的漏洞。
一、RSA加密算法的原理RSA加密算法是一种非对称加密算法，它的安全性基于大质数分解问题的难度。
其原理非常简单，通过选择两个大的质数p和q，计算它们的乘积n=p*q，然后选择一个整数e，使得1<e<φ(n)且e与φ(n)互质，其中φ(n)=(p-1)*(q-1)。
然后计算出一个整数d，使得d*e≡1 mod φ(n)。
e和n组成公钥，d和n组成私钥。
对于给定的明文M，RSA加密算法的加密过程为：C=M^e mod n，其中^表示乘方运算。
对于给定的密文C，RSA加密算法的解密过程为：M=C^d mod n。
二、RSA加密算法的安全性基于大质数分解问题的难度，也就是说，要破解RSA加密算法，需要将公钥n分解成p和q的乘积。
但是，随着计算机技术的发展，大质数分解问题已经不再是一个不可逾越的难关了。
目前，在硬件和算法结合的优化下，可以破解大约100位的RSA密钥。
因此，为了确保RSA加密算法的安全性，密钥的长度必须足够长，至少要达到2048位。
另外，RSA加密算法还存在着一些已知的漏洞，例如：1. 选择恶意公钥攻击。
在这种攻击中，攻击者会伪造一个看似合法的公钥，并将其作为目标用户的公钥。
然后，攻击者就可以在不知情的情况下监视目标用户的通信，从而窃取敏感信息。
2. 计时攻击。
在这种攻击中，攻击者会通过测量加密和解密操作的时间来猜测密钥的值。
这种攻击可以在一段时间内重复进行，从而加速密钥的猜测。
3. 分组攻击。
在这种攻击中，攻击者会通过多次加密和解密相同的明文或密文来推断密钥的值。
通过比较不同的密文或明文块的加密结果，攻击者可以得出有关密钥的信息。
三、RSA加密算法的安全性提升为了提高RSA加密算法的安全性，可以采取以下措施：1. 增加密钥的长度。
c的rsa算法
RSA算法RSA算法是一种非对称加密算法，由三位数学家 Rivest、Shamir 和 Adleman 于1977 年提出。
RSA算法基于两个大素数的乘积难以分解的数学问题，其安全性依赖于大数分解的困难性。
算法原理RSA算法使用了两个密钥，一个是公钥（public key），用于加密数据，另一个是私钥（private key），用于解密数据。
公钥可以公开，而私钥必须保密。
算法的原理如下：1.选择两个不相等的质数p和q，计算它们的乘积n=p*q，n称为模数。
2.计算欧拉函数φ(n)=(p-1)*(q-1)。
3.选择一个整数e，1<e<φ(n)，且e与φ(n)互质。
4.计算e关于模φ(n)的乘法逆元d，即d ≡ e^(-1) (mod φ(n))。
5.公钥为(n, e)，私钥为(n, d)。
6.加密时，将明文m转化为整数，计算密文c ≡ m^e (mod n)。
7.解密时，将密文c计算为明文m ≡ c^d (mod n)。
加密过程1.选择两个大素数p和q。
例如，p=61，q=53。
2.计算模数n=p q。
例如，n=6153=3233。
3.计算欧拉函数φ(n)=(p-1)(q-1)。
例如，φ(n)=6052=3120。
4.选择加密指数e。
例如，e=17。
5.计算e关于模φ(n)的乘法逆元d。
例如，d=2753。
6.公钥为(n, e)，私钥为(n, d)。
7.将明文m转化为整数。
例如，m=65。
8.计算密文c ≡ m^e (mod n)。
例如，c ≡ 65^17 (mod 3233) = 2790。
9.密文c为2790。
解密过程1.使用私钥(n, d)。
2.计算明文m ≡ c^d (mod n)。
例如，m ≡ 2790^2753 (mod 3233) = 65。
3.明文m为65。
安全性RSA算法的安全性基于大数分解的困难性。
大数分解是指将一个大整数分解为两个质数的乘积的过程。
目前没有已知的有效算法可以在合理的时间内对大整数进行分解，因此RSA算法被认为是安全的。
rsa加密算法的原理
rsa加密算法的原理RSA加密算法是一种广泛应用于数据加密和数字签名等领域的非对称加密算法，它的安全性基于大数因数分解难题，是公认的一种安全性较高的加密算法。
RSA加密算法的原理基于两个大质数之间的乘积难以被分解成小质数的因子，因此在加密时，使用公钥对明文进行加密，而在解密时，需要使用相应的私钥进行解密。
具体而言，RSA加密算法包括以下几个步骤：1. 生成公钥和私钥首先，需要选取两个足够大的质数p和q，并计算它们的乘积n=p*q。
然后，根据欧拉函数φ(n)=(p-1)*(q-1)计算出一个小于φ(n)且与其互质的整数e，作为公钥的指数。
同时，根据一个满足d*e≡1(mod φ(n))的整数d，作为私钥的指数。
公钥由(n, e)组成，私钥由(n, d)组成。
保证公钥和私钥的安全性十分重要，一般会通过密钥交换协议等方式生成。
2. 加密加密过程实际上就是将明文m进行加密，生成密文c。
加密的操作是对明文m进行e次幂取模运算，即： c=m^e(mod n)。
其中，m是被加密的明文，e是公钥的指数，n是公钥中的乘积。
通过加密，原来的明文将变得支离破碎，并且无法根据密文推导出明文的内容。
3. 解密密文由私钥进行解密，完成回复原始数据的过程。
解密的操作是对密文c进行d次幂取模运算，即： m=c^d(mod n)。
其中，c是被解密的密文，d是私钥的指数，n是私钥中的乘积。
只有使用正确的私钥才能成功解密出明文。
这就是RSA加密算法的基本原理，其核心在于大数分解难题，即，通过欧拉函数极大程度地保证了分解乘积的难度，同时使用不同的公钥和私钥，使得加密过程具有一定的随机性，从而增加了破解的难度。
不过需要注意的是，RSA加密算法的安全性仍然需要谨慎对待，特别是在应用中要遵循密钥管理和安全通信的原则，以保证信息的完整性和保密性。
简述rsa加密算法原理
简述rsa加密算法原理RSA加密算法原理RSA加密算法是一种非对称加密算法，由三位数学家Rivest、Shamir 和Adleman于1977年提出。
它的安全性基于大数分解的困难性，可以用于数字签名、密钥交换等领域。
下面将从以下几个方面详细介绍RSA加密算法原理。
1. 公钥密码学公钥密码学是一种密码学技术，它采用两个不同但相关的密钥：一个公钥和一个私钥。
公钥可以自由地分发给任何人，而私钥则只能由其拥有者保管。
使用公钥加密的数据只能使用相应的私钥进行解密，反之亦然。
公钥密码学具有高度的安全性和灵活性，可以广泛应用于数据传输、数字签名等方面。
2. RSA算法生成密钥对RSA算法生成密钥对的过程如下：（1）选择两个大质数p和q，并计算它们的乘积n=pq。
（2）计算欧拉函数φ(n)=(p-1)(q-1)。
（3）选择一个整数e(1<e<φ(n))，使得e与φ(n)互质。
（4）计算d=d^-1(mod φ(n))，其中d满足de≡1(mod φ(n))。
（5）公钥为(n,e)，私钥为(n,d)。
其中，p和q是足够大的质数，n是它们的乘积，φ(n)是n的欧拉函数，e是一个与φ(n)互质的整数，d是e在模φ(n)意义下的逆元。
3. RSA算法加密过程RSA算法加密过程如下：（1）将明文转换成整数m(0<=m<n)。
（2）计算密文c≡m^e(mod n)，其中e为公钥中的指数。
（3）将密文c发送给接收者。
其中，m是明文，n和e是接收者的公钥，c是密文。
4. RSA算法解密过程RSA算法解密过程如下：（1）接收到密文c。
（2）计算明文m≡c^d(mod n)，其中d为私钥中的指数。
其中，c是密文，n和d是接收者的私钥，m是明文。
5. RSA算法安全性分析RSA算法安全性基于大数分解的困难性。
即如果能够快速地分解出p 和q，则可以轻松地计算出d，并从而破解RSA加密。
但目前尚未发现快速分解大整数的有效方法。
rsa算法基本原理
rsa算法基本原理RSA算法基本原理RSA是一种非对称加密算法，它的基本原理是利用大素数的因数分解困难性来实现加密和解密的过程。
RSA算法由三个步骤组成：密钥生成、加密和解密。
1. 密钥生成RSA算法中，首先需要生成一对密钥：公钥和私钥。
公钥用于加密数据，私钥用于解密数据。
密钥的生成过程如下：1.1 选择两个大素数p和q，并计算它们的乘积n=p*q。
n的长度决定了RSA算法的安全性。
1.2 计算n的欧拉函数φ(n)=(p-1)*(q-1)。
1.3 选择一个与φ(n)互质的整数e，1 < e < φ(n)。
1.4 计算e关于φ(n)的模反元素d，即满足e*d ≡ 1 (mod φ(n))的整数d，1 < d < φ(n)。
1.5 公钥为(n, e)，私钥为(n, d)。
2. 加密加密过程是指使用公钥对原始数据进行加密的过程。
加密过程如下：2.1 将原始数据转换为整数m，满足0 ≤ m < n。
2.2 计算密文c ≡ m^e (mod n)，即对m进行模n的指数操作。
2.3 密文c即为加密后的数据。
3. 解密解密过程是指使用私钥对密文进行解密的过程。
解密过程如下：3.1 计算明文m ≡ c^d (mod n)，即对密文c进行模n的指数操作。
3.2 明文m即为解密后的数据。
RSA算法的安全性基于大整数的因子分解问题的困难性，因为在当前计算能力下，对于非常大的整数进行因子分解是非常耗时的。
这使得RSA算法在现实应用中具有较高的安全性。
除了加密和解密外，RSA算法还可以用于数字签名和密钥协商等领域。
数字签名是指用私钥对数据进行签名，然后用公钥进行验证，以确保数据的完整性和来源可靠性。
密钥协商是指两个通信方通过交换公钥来协商出一个共享的对称密钥，以便进行后续的加密通信。
总结一下，RSA算法是一种基于大整数的非对称加密算法，利用大素数的因子分解困难性来实现数据的加密和解密。
它的安全性建立在大整数因子分解问题的困难性上，适用于保护数据的机密性、完整性和来源可靠性。
简述rsa加密算法
简述rsa加密算法一、引言RSA加密算法是公钥加密算法的代表，由Ron Rivest、Adi Shamir 和Leonard Adleman三位数学家于1977年发明。
RSA算法的安全性基于大数分解这一NP难题，被广泛应用于信息安全领域。
二、RSA加密算法原理1. 公钥和私钥的生成：RSA算法使用两个大素数p和q作为私钥，并根据p和q计算出n=p*q作为公钥。
同时，根据欧拉函数φ(n)=(p-1)*(q-1)，选择一个整数e与φ(n)互质作为公钥，再计算d=e^-1 mod φ(n)作为私钥。
2. 加密过程：发送方使用接收方的公钥对明文进行加密，加密后的密文只能由接收方使用其私钥进行解密。
具体地，将明文m转换成整数M，并计算C=M^e mod n得到密文。
3. 解密过程：接收方使用自己的私钥对密文进行解密，还原出原始明文。
具体地，将密文C计算出明文M=C^d mod n。
三、RSA加密算法实现1. 公钥和私钥的生成：选择两个大素数p和q，并计算n=p*q、φ(n)=(p-1)*(q-1)。
选择一个整数e与φ(n)互质，计算d=e^-1 mod φ(n)。
公钥为(n,e)，私钥为(n,d)。
2. 加密过程：将明文m转换成整数M，并计算C=M^e mod n得到密文。
3. 解密过程：将密文C计算出明文M=C^d mod n。
四、RSA加密算法的安全性RSA算法的安全性基于大数分解这一NP难题，即对于一个大整数n=p*q，要找到p和q是困难的。
目前最好的分解方法是基于数域筛法和多项式求解器的广义数域筛法，但其时间复杂度依然非常高。
RSA算法在实际应用中具有较高的安全性。
五、RSA加密算法的应用RSA算法被广泛应用于信息安全领域，如数字签名、数据加密、证书认证等。
其中，数字签名可以保证信息的完整性和真实性；数据加密可以保护敏感信息不被窃取；证书认证可以确定通信双方身份并建立可信任的通信渠道。
六、总结RSA加密算法是一种公钥加密算法，在信息安全领域得到了广泛应用。
rsa 公钥密码算法
RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，它使用一对密钥（��钥和私钥）来加密和解密数据。
公钥用于加密数据，私钥用于解密数据。
RSA算法的基本原理是基于大素数的乘法和取模运算。
下面是RSA算法的基本步骤：
1. 选择两个大素数p和q，并计算它们的乘积n=p*q。
2. 计算欧拉函数φ(n)=(p-1)*(q-1)。
3. 选择一个整数e，使得1<e<φ(n)，且e与φ(n)互质。
e称为公钥。
4. 计算整数d，使得d ≡e^(-1) (mod φ(n))。
d称为私钥。
5. 公钥是(n, e)，私钥是(n, d)。
6. 加密消息m：c ≡m^e (mod n)。
7. 解密密文c：m ≡c^d (mod n)。
RSA算法的安全性依赖于大素数分解的困难性，即从n=p*q中分解出p和q的困难性。
因此，RSA算法的安全性取决于选择足够大的素数p和q。
RSA算法被广泛应用于加密通信、数字签名、身份认证等领域，是目前最常用的公钥密码算法之一。
rsa算法的原理
rsa算法的原理RSA算法是一种公钥密码算法，它经常被用于信息安全领域中的加密和数字签名等方面，是目前最广泛使用的公钥加密算法之一。
本文将介绍RSA算法的原理，从密钥生成、加密和解密三个方面详细讲解。
一、密钥生成RSA算法是一种基于大素数因子分解的加密方法，其密钥包括公钥和私钥两部分。
公钥由两个参数n和e组成，其中n为两个大质数p和q 的乘积，e为整数且满足1<e<φ(n)且e与φ(n)互质。
私钥由两个参数n和d组成，其中n相同，d为整数，满足ed≡1(modφ(n))，φ(n)=(p-1)(q-1)是欧拉函数。
密钥生成的具体流程如下：1.选取两个不同的大质数p和q，并计算它们的积n=p*q。
2.计算φ(n)=(p-1)*(q-1)。
3.选取一个大于1且小于φ(n)的整数e，使得e与φ(n)互质。
4.使用扩展欧几里得算法计算出d。
具体地，我们需要求出方程ed=k*φ(n)+1的正整数解d。
5.将n和e组成公钥，n和d组成私钥。
二、加密RSA算法的加密过程如下：1.将明文M转化为整数m，确保0 <= m < n。
2.计算密文C = m^e mod n。
其中，C为密文。
三、解密RSA算法的解密过程如下：1.将密文C转化为整数c，确保0 <= c < n。
2.计算明文M = c^d mod n。
当然，在实际应用中还需要考虑信息安全领域常常面临的各种攻击手段，比如重放攻击、中间人攻击等等。
此外，RSA算法的安全性也与密钥长度有关。
通常情况下，我们需要保证密钥长度足够长，这样攻击者才会愈发显得无能为力。
综上所述，RSA算法是一种基于大素数不易分解原理的公钥密码算法。
密钥包括公钥和私钥两部分，其加密和解密过程都依赖于密钥的组成。
在使用时需要注意信息安全问题，并根据具体应用需求确定密钥长度。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
rsa算法原理CC. 大数的运算1. 大数的运算原理RSA算法依赖于大数的运算，目前主流RSA算法都建立在512位到1024位的大数运算之上，所以我们首先需要掌握大数（比如1024位）的运算原理。
大多数的编译器只能支持到32位（或64位）的整数运算，即我们在运算中所使用的整数必须小于等于32位，即0xFFFFFFFF，这远远达不到RSA的需要，于是需要专门建立大数运算库，来解决这一问题。
最简单的办法是将大数当作字符串进行处理，也就是将大数用10进制字符数组进行表示，然后模拟人们手工进行“竖式计算”的过程编写其加减乘除函数。
但是这样做效率很低。
当然其优点是算法符合人们的日常习惯，易于理解。
另一种思路是将大数当作一个二进制流进行处理，使用各种移位和逻辑操作来进行加减乘除运算，但是这样做代码设计非常复杂，可读性很低，难以理解也难以调试。
这里我们采用了一种介于两者之间的思路：将大数看作一个N进制数组，对于目前的32位系统而言，N可以取2的32次方，即0x100000000，假如将一个1024位的大数转化成0x10000000进制，它就变成了32位，而每一位的取值范围是0－0xFFFFFFFF。
我们正好可以用一个无符号长整数来表示这一数值。
所以1024位的大数就是一个有32个元素的unsigned long数组。
而且0x100000000进制的数组排列与2进制流对于计算机来说，实际上是一回事，但是我们完全可以针对unsigned long数组进行“竖式计算”，而循环规模被降低到了32次之内，并且算法很容易理解。
但考虑到乘法和除法，都要进行扩展才能进行快速的计算（如果把除法变减法而不扩展，速度将慢的无法忍受）。
所以我们将N取2的16次方的，即0xFFFF。
每一位用unsigned short来表示，当进行乘除运算时，将short扩展成long，这是编译器所支持的，所以运算起来，比较快。
2. 大数的各种运算这些运算都是常见的，同时也是常用的。
要实现RSA算法，就必须先实现大数的这些运算。
1) 大数的比较。
两个无符号或有符号的大数进行大小比较。
大数和一般整数进行比较。
大于，等于，小于，返回值各异，以区别比较结果。
2) 大数的赋值。
将一个大数的值，符号等，逐位赋给另一个大数。
将一般整数的值，符号等赋给一个大数。
3) 大数的加法。
两个大数从低位到高位逐位相加，要考虑到进位的问题。
或大数与一般整数的相加。
4) 大数的减法。
两个大数从低位到高位逐位相减，要考虑到借位的问题。
或大数与一般整数的相减。
5) 大数的乘法。
两个大数的乘法，从一个大数的低位到高位，逐位与另一个大数相乘，然后将结果低位对齐相加，要考虑进位，类似于普通的竖式乘法。
或大数与一般整数的乘法。
6) 大数的除法。
两个大数的除法，从一个大数的高位到低位，逐步与另一个大数相除，要考虑借位，类似于普通的竖式除法。
或大数与一般整数的乘法。
7) 大数的取余。
两个大数的取余，类似于大数的除法，只是当除到底时，返回的是余数而已，也存在借位的问题。
或大数于一般整数的取余。
8) 大数的欧氏算法。
它是已知大数A、B，求满足AX≡1 MOD B的X，是最大公约数算法的扩展，同样用辗转相除法。
再递归的过程中，两个参数都要用到，到要变化的。
具体算法请参考源代码。
9) 大数的蒙氏算法。
它是已知大数A、B和C，求X=A^B MOD C的值。
要对指数进行逐渐降阶，直到变成2次方，也就是转换成乘法和取余运算。
降阶的方法和算法的具体过程，请参考相关书籍和源代码。
10) 大数的最大公约数。
求两个大数的最大公约数，用辗转相除法。
RSA算法的实现A. 生成密钥函数gChar gGenerateKey(gBigInt *n,gBigInt *e,gBigInt *d);功能：该函数实现了产生密钥的功能。
先产生两个随机的大素数p和q，然后计算n＝p×q，随机产生（或固定）一个大数e，计算d，使得ed≡1 MOD (p-1)(q-1)。
参数：n：两个大数的乘积，和e或d联合构成加密密钥或解密密钥。
e：一个大数，作为加密密钥。
d：一个和e互异的大数，作为解密密钥。
返回值：1－成功，0－失败。
B. 数据加密函数char gEncRSA(unsigned char* indata, unsigned long inlen, gBigInt* e, gBigInt* n,\unsigned char *outdata, unsigned long* outlen, int flg);功能：把待加密的明文数据indata，用加密密钥e和n进行分段加密。
加密后的数据放到提前开辟好的内存outdata中，其长度outlen不得小于((inlen+k-12)/(k-11))*k，这里k为n的位数。
参数：indata：指向明文数据的指针。
Inlen：传入数据的长度，即明文数据的长度。
e和n：两个大数，作为加密密钥。
Outdata：存放加密后密文数据的指针。
Outlen：传入outdata的长度，传出数据的长度，即密文数据的长度。
Flg：公钥加密或私钥加密的标志，g_PUBLIC－公钥，g_PRIVATE－私钥。
返回值：1－成功，0－失败。
C. 数据解密函数char gDecRSA(unsigned char* indata, unsigned long inlen, gBigInt* d, gBigInt* n,\ unsigned char *outdata, unsigned long* outlen, int flg);功能：把待解密的密文数据indata，用解密密钥e和n进行分段解密。
解密后的数据放到提前开辟好的内存outdata中，其长度outlen不得小于(inlen)*k/(k-11)，这里k为n的位数。
参数：indata：指向密文数据的指针。
Inlen：传入数据的长度，即密文数据的长度。
d和n：两个大数，作为加密密钥。
Outdata：存放解密后明文数据的指针。
Outlen：传入outdata的长度，传出数据的长度，即明文数据的长度。
Flg：公钥加密或私钥加密的标志，g_PUBLIC－公钥，g_PRIVATE－私钥。
返回值：1－成功，0－失败。
D. 用小素数检测gChar gIsNotPrime(gBigInt *p);功能：检测随机大数p能否被小素数整除。
参数：p：待检测的随机大数。
返回值：0－可能是素数，其它－为能整除p的小素数或1。
E. Rabin-Miller检测gChar gRabinMillerTest(gBigInt *p,int tNum);功能：用Rabin-Miller算法，对大数p进行tNum次检测，判断p是否可能为素数。
参数：p：待检测的随机大数。
tNum：检测的次数，它可以决定该检测的可信度。
返回值：0－失败或通不过，1－成功并通过，说明p可能是素数。
F. 随机产生大素数gChar gGeneratePrime(gBigInt *p);功能：随机生成一个大素数。
参数：p：随机生成的大素数。
返回值：0－失败，1－成功。
G. 顺序搜索大素数gChar gGeneratePrimeEx(gBigInt *p, int flg);功能：根据标志flg，递增或递减地搜索p附近的大素数。
参数：p：搜索到的大素数。
Flg：方向标志，g_INCREASE－递增，g_DECREASE－递减。
返回值：0－失败，1－成功。
H. 字符串与大数的转换gChar gStr2BigInt(gBigInt *gbi,char *str,int flg);功能：根据标志flg，将表示成10进制或16进制形式的字符串str转换成大数gbi。
参数：gbi：转换成的大数。
Str：待转换的字符串。
Flg：标志，OCT_FLG－8进制，DEC_FLG－10进制，HEX_FLG－16进制。
返回值：0－失败，1－成功。
gChar gBigInt2Str(char *str,gBigInt *gbi,int flg);功能：根据标志flg，将大数gbi转换成10进制或16进制形式表示的字符串str。
参数：Str：转换成的字符串。
gbi：待转换的大数。
Flg：标志，OCT_FLG－8进制，DEC_FLG－10进制，HEX_FLG－16进制。
返回值：0－失败，1－成功。
I. 一般整数的乘除gUInt gIntMul(gUInt *a, gUInt b);功能：一般整数的乘法。
在函数内部，对整数a和b进行扩展，然后与b相乘，把结果放在a中返回，进位作为返回值。
参数：a：传入一个整数，传出相乘的结果。
b：传入一个整数，作乘数。
返回值：两个整数相乘的进位。
失败时，返回0。
gUInt gIntDiv(gUInt *ah, gUInt *al, gUInt b);功能：一般整数的除法。
在函数内部，将整数ah和al合并成一个扩展了的整数，然后除以整数b，把结果的高位放到ah中，低位放到al中返回，余数作为返回值。
参数：ah：传入一个整数，作为被除数的高位；传出相除后的结果的高位。
al：传入一个整数，作为被除数的低位；传出相除后的结果的低位。
b：传入一个整数，作除数。
返回值：相除的余数。
失败时，返回0。
J. 大数的比较gChar gCmp(gBigInt *a, gBigInt *b);功能：对大数a和大数b进行比较，不考虑它们的符号，只比较数值。
a：传入一个大数。
b：传入另一个大数。
返回值：-1－大数a小于大数b，0－大数a等于大数b，+1－大数a大于大数b。
gChar gCmpEx(gBigInt *a, gBigInt *b);功能：对大数a和大数b进行比较，考虑它们的符号，整数大于负数。
参数：a：传入一个大数。
b：传入另一个大数。
返回值：-1－大数a小于大数b，0－大数a等于大数b，+1－大数a大于大数b。
gChar gCmpInt(gBigInt *a, gUInt b);功能：大数与整数的比较。
对大数a和一般整数b进行比较，不考虑它们的符号。
参数：a：传入一个大数。
b：传入一个一般整数。
返回值：-1－大数a小于b，0－大数a等于b，+1－大数a大于b。
K. 大数的赋值gChar gMov(gBigInt *a, gBigInt *b);功能：将大数b的值，赋给大数a，考虑它们的符号。
a：传出赋值的结果。
b：传入另一个大数。
返回值：0－失败，１－成功。
gChar gMovInt(gBigInt *a, gUInt b);功能：将整数b的值，赋给大数a，考虑它们的符号。
参数：a：传出赋值的结果。
b：传入一个一般整数。
返回值：0－失败，１－成功。
L. 大数的加法gChar gAdd(gBigInt *a, gBigInt *b);//加功能：对大数a和大数b进行加法运算，考虑它们的符号。