ch04(1)-非对称密码RSA
非对称加密RSA加密解密详解
非对称算法之RSA的签名剖析前言数字签名，就是只有信息的发送者才能产生的别人无法伪造的一段数字串，这段数字串同时也是对信息的发送者发送信息真实性的一个有效证明。
不清楚的请自行科普数字签名。
本篇主要来讲签名值具体是怎么计算出来的~一、动手解密签名值1、测试密钥2、编写代码解密众所周知：RSA加密解密：私钥解密，公钥加密。
RSA数字签名-俗称加签验签：私钥加签，公钥验签。
其实：也是有私钥加密，公钥解密的。
只是因为公钥是公开的，私钥加密后所有人都可以解密，没有意义，所以常用签名，而不是加密。
私钥加签的本质也是私钥加密数据的Hash值。
这里有个小技巧：我们用公钥对签名值解密，使用RSA_NO_PADDING，这样就能得到签名时私钥加密的数据。
鉴于篇幅长度，代码只贴出关键部分。
代码之PHP：其他语言代码整理ing…本次测试java、js、C#、PHP。
结果均一致，如下：简单分析1. 字符串”hello world”进行sha256运算得到hash：b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde 92. 在Hash结果前数据填充：3031300d0609608648016503040201050004203. PKCS1 在上一步结果前填充：二、结合资料分析RSA的补位1、签名时，对Hash值的数据填充方式对hash算法id和hash值进行ASN.1的DER编码。
如下：为方便理解，我们使用ASN1dump对示例中的数据做解析：直接上图：可以看到sha256的算法id，2.16.840.1.101.3.4.2.1：数据也在其中，另附上部分算法id：另因为各个hash算法id是固定的，计算的结果也是固定的。
所以不同的hash算法的填充也是固定的。
如下：2、pkcs1padding V1.5的填充模式参考rfc2312以下描述均以十六进制字符串来描述。
rsa非对称加密原理
rsa非对称加密原理
RSA非对称加密原理是基于两个不同的密钥，一个是公钥(public key)，一个是私钥(private key)。
公钥用于加密数据，私钥用于解密数据。
具体步骤如下：
1. 首先，生成一对密钥：公钥和私钥。
这对密钥是在密钥生成器中生成的，其中包含两个大素数。
2. 选择两个不同的质数p和q，并计算它们的乘积n=pq。
n将
作为我们之后生成的公私钥对的一部分。
3. 计算欧拉函数ϕ(n)=(p-1)(q-1)。
4. 选择一个与ϕ(n)互质的整数e，e的取值范围在1和ϕ(n)之间。
e将作为公钥的一部分，用户将使用该公钥进行加密。
5. 计算e的模反元素d，即满足ed ≡ 1 (mod ϕ(n))的整数d。
d
将作为私钥的一部分，用户将使用私钥对加密后的数据进行解密。
6. 将公钥(public key)定义为(n,e)，私钥(private key)定义为(n,d)。
7. 加密数据：将明文m转换为整数M，并使用公钥(n,e)进行
加密操作，得到加密后的密文C = M^e mod n。
8. 解密数据：使用私钥(n,d)对密文C进行解密操作，得到明
文m' = C^d mod n。
9. 最后，将m'转换为原始明文m。
非对称密码系统ras的加密原理及其应用
非对称密码系统RSA的加密原理及其应用1. 引言在信息安全领域，密码学是一项重要的技术，用于保护数据的机密性和完整性。
非对称密码系统是密码学中的一种重要的加密算法，RSA算法是非对称密码系统中最常用的算法之一。
本文将介绍RSA算法的加密原理以及其在实际应用中的案例。
2. RSA算法的加密原理RSA算法是一种基于大数质因数分解难题的非对称密码算法。
其加密原理如下：1.选择两个大素数p和q，计算它们的乘积n，即n = p * q。
2.计算n的欧拉函数φ(n)，即φ(n) = (p-1) * (q-1)，φ(n)表示小于n且与n互质的正整数的个数。
3.选择一个整数e，满足1 < e < φ(n)，且e与φ(n)互质。
4.计算e的模反元素d，满足d * e ≡ 1 (mod φ(n))。
5.公钥为(n, e)，私钥为(n, d)。
RSA算法的加密和解密操作分别为：•加密：将明文M转化为整数m，使得0 ≤ m < n，然后计算密文C，C ≡ m^e (mod n)。
•解密：将密文C转化为整数c，然后计算明文M，M ≡ c^d (mod n)。
3. RSA算法的应用RSA算法广泛应用于信息安全领域，以下是几个典型的应用案例：3.1 加密通信RSA算法可以用于保护通信过程中的数据机密性。
通信双方可以使用对方的公钥进行加密，只有拥有对应私钥的一方才能解密得到明文。
这种方式可以有效防止第三方窃取通信内容。
3.2 数字签名RSA算法可以用于生成和验证数字签名，确保数据的完整性和真实性。
发送方使用私钥对数据进行签名，接收方使用对应公钥对签名进行验证。
通过公钥加密和私钥解密的方式，可以确保数字签名的唯一性，防止篡改和伪造。
3.3 身份认证RSA算法可以用于身份认证的加密协议。
通常情况下，服务提供方将其公钥存储在服务器上，用户使用该公钥对其身份认证信息进行加密，并发送给服务器。
服务器使用私钥解密得到用户的身份认证信息，若解密成功，则认证通过。
非对称密码算法RSA原理
非对称密钥加密算法-RSA一．非对称密钥加密概述前面讲述了对称密钥加密体制。
使用对称密钥加密体制进行保密通信时，任意不同的两个用户之间都应该使用互不相同的密钥。
这样，如果一个网络中有n个用户，他们之间彼此可能需要进行秘密通信，这时网络中将共需要n(n-1)/2个密钥（其中，每个用户都需要保存n-1个密钥），这样巨大的密钥量给密钥分配和管理带来了极大的困难。
另外，随着计算机网络，特别是因特网的发展，网络上互不相识的用户可能需要进行保密的会话（例如，如果用户在进行电子商务活动时，需要保密的连接，这时的客户对象可能根本不是固定的对象）。
最后，对称密钥加密机制难以解决签名验证问题。
非对称密钥加密也称为公开密钥加密，或者叫做公钥加密算法。
使用公开密钥密码的每一个用户都分别拥有两个密钥：加密密钥和解密密钥，它们两者并不相同，并且由加密密钥得到解密密钥在计算机上是不可行的。
每一个用户的加密密钥都是公开的（因此，加密密钥也称为公开密钥）。
所有用户的公开密钥都将记录在作用类似于电话号码薄的密钥本上，而它可以被所有用户访问，这样每一个用户都可以得到其他所有用户的公开密钥。
同时，每一个用户的解密密钥将由用户保存并严格保密（因此，解密密钥也称为私有密钥）。
非对称密码算法解决了对称密码体制中密钥管理的难题，并提供了对信息发送人的身份进行验证的手段，是现代密码学最重要的发明。
公钥加密算法一般是将对密钥的求解转化为对数学上的困难问题的求解，例如RSA算法的安全性是建立在“大数分解和素性检测”这个数论难题的基础上，已知两个大素数a、b，求出a*b是容易计算的，而已知a*b，想知道其是哪两个大素数的乘积目前还没有好的计算方法，另外也有一些非对称加密算法（如ELGamal算法）的安全性是基于求“离散对数”这个数学难题上的。
在公钥密码系统中每个实体都有自己的公钥和相应的私钥。
公钥密码系统的加密变换和解密变换分别用E和D表示。
任何实体B要向实体A发送信息m的步骤如下：实体B首先获得实体A的真实公钥的拷贝（eA），实体B使用eA计算密文 c=E（m）并发送给实体A ，实体A使用自己的私钥dA，计算m=D（c）解密密文，恢复出明文m。
非对称加密运算
非对称加密运算全文共四篇示例，供读者参考第一篇示例：非对称加密算法（Asymmetric encryption）是一种运用公私密钥对进行加密和解密的加密技术。
与对称加密算法不同的是，非对称加密算法需要一对密钥，即公钥和私钥。
公钥用于加密数据，私钥用于解密数据。
公钥可以公开，私钥则保密，这就是为何称其为“非对称”加密。
非对称加密算法的最大优势在于其安全性。
由于加密和解密使用的是不同的密钥，攻击者无法通过截获公钥来获取私钥。
即使公钥被泄露，私钥仍然是安全的。
这种双密钥的组合使得非对称加密算法成为网络安全领域的重要技术之一。
常见的非对称加密算法有RSA、DSA、ECC等。
RSA是第一个广泛应用的非对称加密算法之一，它利用了大素数分解的数学难题。
DSA是一种数字签名算法，常用于身份验证和消息完整性校验。
ECC是椭圆曲线加密算法，相对于RSA来说，它在相同的安全级别下，密钥长度更短，计算速度更快，适合在资源受限的环境中应用。
非对称加密算法在信息安全领域有着广泛的应用。
非对称加密算法可以用于数据传输的加密保护。
在网络通信中，数据需要经过公网传输，如果使用对称加密算法来加密数据，需要将加密密钥传输给对方，存在被窃取的风险。
而非对称加密算法则可以避免这个问题，加密过程中只需要公钥，私钥不需要传输，因此更加安全。
非对称加密算法还常用于数字签名和身份认证。
数字签名是将消息用发送者的私钥进行签名，接收者用发送者的公钥进行验证，确保消息的完整性和真实性。
身份认证则是通过验证数字签名来确认发送者的身份是否有效，防止假冒等安全问题。
非对称加密算法还可以应用于安全证书认证、密钥协商、安全通信通讯、加密存储等场景。
在各种通信和交互场合中，非对称加密算法都发挥着重要作用，保障了信息安全和数据保密性。
但非对称加密算法也存在一些不足之处。
由于非对称加密算法的算法复杂度相对较高，计算速度较慢，数据加密解密的效率不如对称加密算法高。
密钥管理也是一个挑战，需要保证私钥的安全性，避免泄露。
RSA非对称加密算法
RSA⾮对称加密算法基本定义:RSA公开密钥密码体制。
所谓的公开密钥密码体制就是使⽤不同的加密密钥与解密密钥，是⼀种“由已知加密密钥推导出解密密钥在计算上是不可⾏的”密码体制。
在公开密钥密码体制中，加密密钥（即公开密钥）PK是公开信息，⽽解密密钥（即秘密密钥）SK是需要保密的。
加密算法E和解密算法D也都是公开的。
虽然解密密钥SK是由公开密钥PK决定的，但却不能根据PK计算出SK。
数据加解密过程:数据发送⽅使⽤数据接收⽅发放的公钥对发送数据进⾏RSA加密,⽣成的密⽂发送给数据接收⽅;数据接收⽅使⽤公钥对应的私钥对密⽂进⾏RSA解密,得到明⽂信息.数据是以密⽂形式传输的,即使密⽂被截获,想要破解得到对应的明⽂是⼏乎不可能的(这涉及到数论的相关理论,不予延伸).破解难度主要体现在两点:1.破解密⽂需要对应的私钥,⽽私钥的长度有1024、2048、3072等,因此暴⼒破解是不可⾏的;2.虽然解密的私钥是由加密公钥解决的(公钥,私钥组成⼀个密钥对),但是却不能通过公钥推导计算出对应的私钥.3.RSA使⽤公钥加密数据,得到的密⽂都是不同的,因此⽆法像破解MD5⼀样穷举出对应的明⽂内容.C#代码实现的加解密:/// <summary>/// RSA 加密/// </summary>/// <param name="source">需加密的数据</param>/// <param name="publicKey">公钥</param>/// <returns></returns>public static string EncryptRsa(string source, string publicKey){using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider()){rsa.FromXmlString(publicKey);var cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(source), true);return Convert.ToBase64String(cipherbytes);}}/// <summary>/// RSA解密/// </summary>/// <param name="source">需解密的数据</param>/// <param name="privateKey">私钥</param>/// <returns></returns>public static string DecryptRsa(string source, string privateKey){using(RSACryptoServiceProvider rsa = new RSACryptoServiceProvider()){rsa.FromXmlString(privateKey);var cipherbytes = rsa.Decrypt(Convert.FromBase64String(source), true);return Encoding.UTF8.GetString(cipherbytes);}}。
非对称加密解密算法RSA的C实现
非对称加密解密算法RSA的C实现RSA加密算法是一种非对称加密算法，常用于数据加密和数字签名。
其安全性基于大数分解的困难性，即质因数分解。
RSA加密算法的全称为Rivest-Shamir-Adleman加密算法，是由Ron Rivest、Adi Shamir和Leonard Adleman于1977年共同提出的。
RSA算法的加密过程如下：1.选择两个不同的质数p和q，计算它们的乘积n=p*q。
2.选择一个整数e，满足1<e<φ(n)，且e和φ(n)互质，其中φ(n)=(p-1)*(q-1)。
3. 计算e关于φ(n)的模反元素d，即满足(e*d)mod φ(n) = 14.公钥为(n,e)，私钥为(n,d)。
5. 对于要加密的明文m，使用公钥(n, e)进行加密，得到密文c，公式为c = (m^e)mod n。
6. 对于要解密的密文c，使用私钥(n, d)进行解密，得到明文m，公式为m = (c^d)mod n。
以下是使用C语言实现RSA加密和解密的代码：```c#include <stdio.h>#include <stdlib.h>#include <math.h>//求最大公约数int gcd(int a, int b)if (b == 0)return a;return gcd(b, a % b);//求模反元素int mod_inverse(int e, int phi) int d;for (d = 1; d <= phi; d++)if ((e * d) % phi == 1)return d;}return -1; // 模反元素不存在//加密函数int encrypt(int m, int e, int n) int c = fmod(pow(m, e), n); return c;//解密函数int decrypt(int c, int d, int n)int m = fmod(pow(c, d), n);return m;//主函数int maiint p, q, n, phi, e, d, m, c;printf("请输入两个质数p和q: ");scanf("%d%d", &p, &q);n=p*q;phi = (p - 1) * (q - 1);printf("请输入一个整数e(1 < e < %d且与%d互质): ", phi, phi);scanf("%d", &e);// 检查e和phi是否互质if (gcd(e, phi) != 1)printf("输入的e不符合要求，请重新输入！\n");return 0;}d = mod_inverse(e, phi);if (d == -1)printf("模反元素不存在，解密失败！\n");return 0;}printf("请输入要加密的明文m: ");scanf("%d", &m);c = encrypt(m, e, n);printf("加密后的密文c为: %d\n", c);m = decrypt(c, d, n);printf("解密后的明文m为: %d\n", m);return 0;```以上代码中，首先通过输入两个质数p和q，计算得到公共模数n和欧拉函数φ(n)，然后要求输入一个符合条件的整数e，通过计算求得模反元素d。
非对称加密算法范文
非对称加密算法范文非对称加密算法（Asymmetric encryption algorithm），也被称为公钥加密算法，是一种加密方法，使用了一对密钥（公钥和私钥）来进行加密和解密操作。
与对称加密算法相比，非对称加密算法具有更高的安全性。
非对称加密算法的基本原理是，产生一对密钥，其中一个是公钥（public key），可自由公开，用于加密数据；另一个是私钥（private key），需要保密，用于解密已加密的数据。
公钥和私钥是一对相关联的密钥，它们能够互相解密对方加密的数据。
1.RSA算法：RSA算法是一种最早应用并广泛使用的非对称加密算法，也是当前最常见的非对称加密算法。
RSA算法基于两个大质数的乘积难以分解的数学问题，通过大数分解困难实现了强大的安全性。
2. 椭圆曲线加密算法（Elliptic Curve Cryptography，ECC）：ECC算法利用椭圆曲线上的离散对数难题来实现加密操作。
相较于RSA算法，ECC算法在相同的安全性下使用更短的密钥，计算量更小，适用于资源有限的环境。
3. Elgamal算法：Elgamal算法主要用于密钥交换过程中的加密操作，利用离散对数的困难性实现加密和解密。
它具有一定的安全性和较高的计算复杂度，但由于其速度相对较慢，一般常用于密钥交换的初期过程。
4.DSA算法：DSA算法是一种数字签名算法，主要用于身份验证和数据完整性校验。
DSA算法结合了哈希函数和离散对数问题，通过数字签名的方式保证信息的可靠性。
1.更高的安全性：非对称加密算法通过使用不同的密钥进行加密和解密，避免了对称加密算法中密钥容易被窃取的问题。
即使公钥被泄露，私钥仍然可以保证数据的安全。
2.密钥交换方便：使用非对称加密算法，可以在不安全的通道上进行密钥交换，确保通信过程中的密钥安全。
3.数字签名：非对称加密算法可以用于生成和验证数字签名，以验证消息的完整性和认证通信方的身份。
然而，非对称加密算法也存在一些限制和挑战：1.计算复杂度高：非对称加密算法的计算复杂度较高，相比对称加密算法而言，执行加密和解密操作会消耗更多的计算资源。
可选用的非对称密码算法
可选用的非对称密码算法随着信息技术的快速发展，网络安全问题日益突出。
为了保护数据的安全性，密码算法成为了一种重要的手段。
非对称密码算法是一种常用的密码算法，它采用了公钥和私钥的方式进行加密和解密，具有较高的安全性和可靠性。
下面将介绍几种可选用的非对称密码算法。
首先是RSA算法。
RSA算法是目前应用最广泛的非对称密码算法之一。
它是由三位数学家Rivest、Shamir和Adleman于1977年提出的。
RSA算法的安全性基于大数分解的困难性，即将一个大数分解成两个质数的乘积。
RSA算法的加密过程是将明文通过公钥进行加密，解密过程是通过私钥进行解密。
RSA算法具有较高的安全性和较快的加密速度，因此被广泛应用于数字签名、数据加密等领域。
其次是椭圆曲线密码算法（ECC算法）。
ECC算法是一种基于椭圆曲线数学问题的非对称密码算法。
与RSA算法相比，ECC算法在相同的安全性下，使用的密钥长度更短，加密速度更快。
ECC算法的安全性基于椭圆曲线离散对数问题的困难性，即在椭圆曲线上求解离散对数的难度。
ECC算法在物联网、移动通信等领域有着广泛的应用。
再次是ElGamal算法。
ElGamal算法是一种基于离散对数问题的非对称密码算法。
它由ElGamal于1985年提出，是一种具有较高安全性的加密算法。
ElGamal算法的加密过程是将明文通过公钥进行加密，解密过程是通过私钥进行解密。
ElGamal算法的安全性基于离散对数问题的困难性，即在有限域上求解离散对数的难度。
ElGamal算法在数字签名、密钥交换等领域有着广泛的应用。
最后是Diffie-Hellman密钥交换算法。
Diffie-Hellman算法是一种用于密钥交换的非对称密码算法。
它由Diffie和Hellman于1976年提出，是一种具有较高安全性的密钥交换算法。
Diffie-Hellman算法的安全性基于离散对数问题的困难性，即在有限域上求解离散对数的难度。
详解非对称rsa算法
详解非对称rsa算法非对称RSA算法是一种广泛应用于加密和数字签名的公钥密码算法。
它由三位数学家Rivest、Shamir和Adleman于1977年提出，是目前最常用的非对称加密算法之一。
本文将详细介绍RSA算法的原理和应用。
RSA算法的核心思想是利用两个大素数的乘积作为公钥，而这两个素数的乘积的因数则作为私钥。
具体来说，RSA算法包括以下几个步骤：1. 选择两个大素数p和q，计算它们的乘积n=p*q。
n被称为模数，p和q被称为因子。
2. 计算欧拉函数φ(n)=(p-1)*(q-1)。
欧拉函数表示小于n且与n互质的正整数的个数。
3. 选择一个整数e，使得1<e<φ(n)，且e与φ(n)互质。
e被称为公钥指数。
4. 计算e关于φ(n)的模反元素d，即满足e*d≡1(mod φ(n))的整数d。
d被称为私钥指数。
5. 公钥为(n, e)，私钥为(n, d)。
加密过程如下：1. 将明文M转化为整数m，满足0≤m<n。
2. 计算密文C，C≡m^e(mod n)。
解密过程如下：1. 将密文C转化为整数c，满足0≤c<n。
2. 计算明文M，M≡c^d(mod n)。
RSA算法的安全性基于两个数学难题：大整数的质因数分解和模指数运算的困难性。
质因数分解是指将一个大整数分解为两个素数的乘积，这个问题在目前的计算能力下是非常困难的。
模指数运算是指计算一个数的指数幂对另一个数取模的结果，这个问题在目前的计算能力下也是非常困难的。
RSA算法的应用非常广泛。
首先，它可以用于加密通信。
发送方使用接收方的公钥对消息进行加密，只有接收方才能使用私钥解密。
这样可以确保消息在传输过程中的机密性。
其次，RSA算法可以用于数字签名。
发送方使用自己的私钥对消息进行签名，接收方可以使用发送方的公钥验证签名的真实性。
这样可以确保消息在传输过程中的完整性和真实性。
然而，RSA算法也存在一些问题。
首先，它的加密和解密速度相对较慢，特别是对于大整数的运算。
非对称加密算法原理
非对称加密算法原理在密码学的世界中，非对称加密算法是最重要的保密技术之一。
在传统的对称加密技术中，加密和解密都使用相同的密钥，这就意味着它是不安全的，当一个恶意的用户知道了该密码，他/她就可以随意访问敏感信息了。
而非对称加密技术却正好相反，它是一种安全的加密技术，它使用不同的密钥来加密和解密信息。
和对称加密技术不同，非对称加密技术采用了一对匹配的密钥，分别是私钥和公钥。
私钥是保密的，只有拥有者才能掌握；而公钥是公开的，它可以被任何人所获取。
私钥会被用来加密信息，公钥用来解密信息。
这样只要拥有者有他/她的私钥，就可以保证发送或接收到信息无论如何都不会被泄漏。
非对称加密也称为公钥加密，它是一种全新的加密技术，由一位来自英国的科学家Diffie和Hellman提出。
他们提出了一种保护数据安全的新方法，也就是我们今天所熟知的非对称加密技术。
它利用一对关联的、不同的密钥，来加密任何的数据传输，这就保证了数据的通讯安全。
在发送者和接收者之间，数据传输的过程是由私钥加密，而在接收者的机子上，由公钥进行解密的。
由于两个密钥E（私钥）和D（公钥）是映射关系，当用E 加密的时候，用D解密就能够得到原先的文本，而反之也是成立的。
在互联网上，非对称加密技术应用得比较广泛。
它能够保障在网络上收发的信息安全，也应用在数字签名和数据加密两个方面。
数字签名就是用公钥加密，用于证明信息的发送者和接收者的身份；数据加密则是用私钥加密，保障数据在传输过程中的安全。
此外，非对称加密也被广泛应用在文件传输协议（FTP）、SSL/SSH等，来保证数据的安全性。
总的来说，非对称加密技术一方面可以保护信息在传输过程中不被窃取；另一方面也可以作为数字签名用于验证发送者和接收者的身份。
虽然其加密时间较慢，但它仍然是互联网的最重要的保密技术之一。
非对称原理运用的具体实例
非对称原理运用的具体实例1. RSA加密算法：RSA是一种非对称加密算法，它利用了非对称原理中的公钥和私钥的特性。
在RSA算法中，发送方使用接收方的公钥对消息进行加密，而接收方使用自己的私钥进行解密。
通过使用不同的密钥进行加密和解密，确保了信息的安全性。
2. 数字签名：数字签名是一种利用非对称原理实现的验证身份和保护信息完整性的方法。
发送方使用私钥对消息的散列值进行加密生成数字签名，然后将签名和原始消息一起发送给接收方。
接收方使用发送方的公钥对签名进行解密，并对原始消息进行加密。
通过比较解密后的签名和加密后的消息，可以验证消息的完整性和发送方的身份。
3. TLS协议：传输层安全协议（Transport Layer Security，TLS）是一种常用的加密通信协议，它使用非对称原理来建立安全通信。
在建立TLS连接时，客户端和服务器通过交换公钥进行身份验证，并使用对称加密算法来加密通信过程中的数据。
通过利用非对称原理，TLS协议可确保通信过程中的数据机密性和完整性。
4. SSH协议：安全Shell（Secure Shell，SSH）是一种通过网络进行加密通信的协议。
在使用SSH登录时，客户端和服务器通过交换公钥进行身份验证，并使用非对称加密算法来加密通信过程中的数据。
通过利用非对称原理，SSH协议可确保通信过程中的数据机密性和完整性。
5. 数字货币系统：数字货币系统，如比特币，使用非对称加密算法来加密交易信息和保护用户的隐私。
在进行交易时，发送方使用自己的私钥对交易进行签名，并将签名和交易信息一起广播给网络中的节点。
其他节点使用发送方的公钥来验证交易的有效性。
通过使用非对称原理，确保了比特币交易的安全性和可靠性。
非对称密钥RSA加密算法及其密
非对称密钥RSA加密算法及其密
一、RSA算法是第一个能同时用于加密和数字签名的算法，也易于理解和操作。
RSA是被研究得最广泛的公钥算法，从提出到现在已近二十年，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一。
RSA的安全性依赖于大数的因子分解，但并没有从理论上证明破译RSA的难度与大数分解难度等价。
即RSA的重大缺陷是无法从理论上把握它的保密性能如何，而且密码学界多数人士倾向于因子分解不是NPC问题。
RSA的缺点主要有：A)产生密钥很麻烦，受到素数产生技术的限制，因而难以做到一次一密。
B)分组长度太大，为保证安全性，n 至少也要600 bits以上，使运算代价很高，尤其是速度较慢，较对称密码算法慢几个数量级；且随着大数分解技术的发展，这个长度还在增加，不利于数据格式的标准化。
目前,SET(Secure Electronic TransacTIon)协议中要求CA采用2048比特长的密钥，其他实体使用1024比特的密钥。
其中公钥e和私钥d的求解过程分两步：。
非对称加密RSA加密文件
⾮对称加密RSA加密⽂件RSA加密⽂件 关于RSA⾮对称加密很多地⽅都有讲解。
下⾯是AES AES 类import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.InputStream;import java.io.OutputStream;import java.security.Key;import java.security.SecureRandom;import javax.crypto.Cipher;import javax.crypto.CipherInputStream;import javax.crypto.CipherOutputStream;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;/*** <p>* AES加密解密⼯具包* </p>** @author IceWee* @date 2012-5-18* @version 1.0*/public class AESUtils {private static final String ALGORITHM = "AES";private static final int KEY_SIZE = 256;private static final int CACHE_SIZE = 1024;/*** <p>* ⽣成随机密钥* </p>** @return* @throws Exception*/public static String getSecretKey() throws Exception {return getSecretKey(null);//return "X9qY3q630+wI/kLuKo1cBA==";}/*** <p>* ⽣成密钥* </p>** @param seed 密钥种⼦* @return* @throws Exception*/public static String getSecretKey(String seed) throws Exception {KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);SecureRandom secureRandom;if (seed != null && !"".equals(seed)) {secureRandom = new SecureRandom(seed.getBytes());} else {secureRandom = new SecureRandom();}keyGenerator.init(KEY_SIZE, secureRandom);SecretKey secretKey = keyGenerator.generateKey();System.out.println("密钥种⼦:"+Base64Utils.encode(secretKey.getEncoded()));return Base64Utils.encode(secretKey.getEncoded());}/*** <p>* 加密* </p>** @param data* @param key* @return* @throws Exception*/public static byte[] encrypt(byte[] data, String key) throws Exception {Key k = toKey(Base64Utils.decode(key));byte[] raw = k.getEncoded();SecretKeySpec secretKeySpec = new SecretKeySpec(raw, ALGORITHM);Cipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);return cipher.doFinal(data);/*** <p>* ⽂件加密* </p>** @param key* @param sourceFilePath* @param destFilePath* @throws Exception*/public static void encryptFile(String key, String sourceFilePath, String destFilePath) throws Exception { File sourceFile = new File(sourceFilePath);File destFile = new File(destFilePath);if (sourceFile.exists() && sourceFile.isFile()) {if (!destFile.getParentFile().exists()) {destFile.getParentFile().mkdirs();}destFile.createNewFile();InputStream in = new FileInputStream(sourceFile);OutputStream out = new FileOutputStream(destFile);Key k = toKey(Base64Utils.decode(key));byte[] raw = k.getEncoded();SecretKeySpec secretKeySpec = new SecretKeySpec(raw, ALGORITHM);Cipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);CipherInputStream cin = new CipherInputStream(in, cipher);byte[] cache = new byte[CACHE_SIZE];int nRead = 0;while ((nRead = cin.read(cache)) != -1) {out.write(cache, 0, nRead);out.flush();}out.close();cin.close();in.close();}}/*** <p>* 解密* </p>** @param data* @param key* @return* @throws Exception*/public static byte[] decrypt(byte[] data, String key) throws Exception {Key k = toKey(Base64Utils.decode(key));byte[] raw = k.getEncoded();SecretKeySpec secretKeySpec = new SecretKeySpec(raw, ALGORITHM);Cipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);return cipher.doFinal(data);}/*** <p>* ⽂件解密* </p>** @param key* @param sourceFilePath* @param destFilePath* @throws Exception*/public static void decryptFile(String key, String sourceFilePath, String destFilePath) throws Exception { File sourceFile = new File(sourceFilePath);File destFile = new File(destFilePath);if (sourceFile.exists() && sourceFile.isFile()) {if (!destFile.getParentFile().exists()) {destFile.getParentFile().mkdirs();}destFile.createNewFile();FileInputStream in = new FileInputStream(sourceFile);FileOutputStream out = new FileOutputStream(destFile);Key k = toKey(Base64Utils.decode(key));byte[] raw = k.getEncoded();SecretKeySpec secretKeySpec = new SecretKeySpec(raw, ALGORITHM);Cipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);CipherOutputStream cout = new CipherOutputStream(out, cipher);byte[] cache = new byte[CACHE_SIZE];int nRead = 0;while ((nRead = in.read(cache)) != -1) {cout.write(cache, 0, nRead);cout.flush();}cout.close();out.close();in.close();}}* <p>* 转换密钥* </p>** @param key* @return* @throws Exception*/private static Key toKey(byte[] key) throws Exception {SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);return secretKey;}}Base64Utils.javaimport java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.InputStream;import java.io.OutputStream;/*** <p>* BASE64编码解码⼯具包* </p>* <p>* 依赖javabase64-1.3.1.jar* </p>** @author IceWee* @date 2012-5-19* @version 1.0*/public class Base64Utils {/*** ⽂件读取缓冲区⼤⼩*/private static final int CACHE_SIZE = 1024;/*** <p>* BASE64字符串解码为⼆进制数据* </p>** @param base64* @return* @throws Exception*/public static byte[] decode(String base64) throws Exception {return Base64.decode(base64);}/*** <p>* ⼆进制数据编码为BASE64字符串* </p>** @param bytes* @return* @throws Exception*/public static String encode(byte[] bytes) throws Exception {return new String(Base64.encode(bytes));}/*** <p>* 将⽂件编码为BASE64字符串* </p>* <p>* ⼤⽂件慎⽤，可能会导致内存溢出* </p>** @param filePath ⽂件绝对路径* @return* @throws Exception*/public static String encodeFile(String filePath) throws Exception {byte[] bytes = fileToByte(filePath);return encode(bytes);}/*** <p>* BASE64字符串转回⽂件* </p>* @param filePath ⽂件绝对路径* @param base64 编码字符串* @throws Exception*/public static void decodeToFile(String filePath, String base64) throws Exception { byte[] bytes = decode(base64);byteArrayToFile(bytes, filePath);}/*** <p>* ⽂件转换为⼆进制数组* </p>** @param filePath ⽂件路径* @return* @throws Exception*/public static byte[] fileToByte(String filePath) throws Exception {byte[] data = new byte[0];File file = new File(filePath);if (file.exists()) {FileInputStream in = new FileInputStream(file);ByteArrayOutputStream out = new ByteArrayOutputStream(2048);byte[] cache = new byte[CACHE_SIZE];int nRead = 0;while ((nRead = in.read(cache)) != -1) {out.write(cache, 0, nRead);out.flush();}out.close();in.close();data = out.toByteArray();}return data;}/*** <p>* ⼆进制数据写⽂件* </p>** @param bytes ⼆进制数据* @param filePath ⽂件⽣成⽬录*/public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception { InputStream in = new ByteArrayInputStream(bytes);File destFile = new File(filePath);if (!destFile.getParentFile().exists()) {destFile.getParentFile().mkdirs();}destFile.createNewFile();OutputStream out = new FileOutputStream(destFile);byte[] cache = new byte[CACHE_SIZE];int nRead = 0;while ((nRead = in.read(cache)) != -1) {out.write(cache, 0, nRead);out.flush();}out.close();in.close();}}下⾯是RSAimport java.util.Collection;import java.util.Map;public abstract class Assert {public Assert() {}public static void isTrue(boolean expression, String message) {if (!expression) {throw new IllegalArgumentException(message);}}public static void isNull(Object object, String message) {if (object != null) {throw new IllegalArgumentException(message);}}public static void notNull(Object object, String message) {if (object == null) {throw new IllegalArgumentException(message);}}public static void hasLength(String text, String message) {if (!hasLength(text)) {throw new IllegalArgumentException(message);}public static void hasText(String text, String message) {if (!hasText(text)) {throw new IllegalArgumentException(message);}}public static void doesNotContain(String textToSearch, String substring, String message) {if (hasLength(textToSearch) && hasLength(substring) && textToSearch.contains(substring)) {throw new IllegalArgumentException(message);}}public static void notEmpty(Object[] array, String message) {if (array == null || array.length == 0) {throw new IllegalArgumentException(message);}}public static void noNullElements(Object[] array, String message) {if (array != null) {Object[] var2 = array;int var3 = array.length;for (int var4 = 0; var4 < var3; ++var4) {Object element = var2[var4];if (element == null) {throw new IllegalArgumentException(message);}}}}public static void notEmpty(Collection<?> collection, String message) {if (isEmpty(collection)) {throw new IllegalArgumentException(message);}}public static void notEmpty(Map<?, ?> map, String message) {if (isEmpty(map)) {throw new IllegalArgumentException(message);}}public static void isInstanceOf(Class<?> type, Object obj, String message) {notNull(type, "Type to check against must not be null");if (!type.isInstance(obj)) {throw new IllegalArgumentException((hasLength(message) ? message + " " : "") + "Object of class [" + (obj != null ? obj.getClass().getName() : "null") + "] must be an instance of " + type); }}public static void isAssignable(Class<?> superType, Class<?> subType, String message) {notNull(superType, "Type to check against must not be null");if (subType == null || !superType.isAssignableFrom(subType)) {throw new IllegalArgumentException(message + subType + " is not assignable to " + superType);}}private static boolean hasLength(CharSequence str) {return str != null && str.length() > 0;}private static boolean hasText(CharSequence str) {if (!hasLength(str)) {return false;} else {int strLen = str.length();for (int i = 0; i < strLen; ++i) {if (!Character.isWhitespace(str.charAt(i))) {return true;}}return false;}}private static boolean isEmpty(Collection<?> collection) {return collection == null || collection.isEmpty();}public static boolean isEmpty(Map<?, ?> map) {return map == null || map.isEmpty();}}import java.nio.charset.Charset;import mons.codec.binary.Base64;public abstract class Base64Code {private static final int CACHE_SIZE = 1024;private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");private static final Base64Delegate delegate = new CommonsCodecBase64Delegate();public Base64Code() {}private static void assertSupported() {Assert.isTrue(delegate != null, "Apache Commons Codec not found - Base64 encoding not supported````````"); }public static byte[] encode(byte[] src) {assertSupported();return delegate.encode(src);}public static String encodeToString(byte[] src) {assertSupported();if (src == null) {return null;} else {return src.length == 0 ? "" : new String(delegate.encode(src), DEFAULT_CHARSET);}}public static byte[] decode(byte[] src) {assertSupported();return delegate.decode(src);}public static byte[] decodeFromString(String src) {assertSupported();if (src == null) {return null;} else {return src.length() == 0 ? new byte[0] : delegate.decode(src.getBytes(DEFAULT_CHARSET));}}private static class CommonsCodecBase64Delegate implements Base64Delegate {private final Base64 base64;private CommonsCodecBase64Delegate() {this.base64 = new Base64();}public byte[] encode(byte[] src) {return this.base64.encode(src);}public byte[] decode(byte[] src) {return this.base64.decode(src);}}private interface Base64Delegate {byte[] encode(byte[] var1);byte[] decode(byte[] var1);}}import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.security.Key;import java.security.KeyFactory;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.NoSuchAlgorithmException;import java.security.interfaces.RSAPrivateKey;import java.security.interfaces.RSAPublicKey;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.HashMap;import java.util.Map;import javax.crypto.Cipher;import javax.crypto.CipherInputStream;import javax.crypto.CipherOutputStream;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;/*** RSA加解密⽅法。
RSA非对称密码算法
RSA非对称密码算法1、RSA非对称密码算法简介非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。
公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。
因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。
非对称加密算法实现机密信息交换的基本过程是：甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开；得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方；甲方再用自己保存的另一把专用密钥对加密后的信息进行解密。
另一方面，甲方可以使用乙方的公钥对机密信息进行签名后再发送给乙方；乙方再用自己的私匙对数据进行验签。
甲方只能用其专用密钥解密由其公用密钥加密后的任何信息。
非对称加密算法的保密性比较好，它消除了最终用户交换密钥的需要。
非对称密码体制的特点：算法强度复杂、安全性依赖于算法与密钥但是由于其算法复杂，而使得加密解密速度没有对称加密解密的速度快。
对称密码体制中只有一种密钥，并且是非公开的，如果要解密就得让对方知道密钥。
所以保证其安全性就是保证密钥的安全，而非对称密钥体制有两种密钥，其中一个是公开的，这样就可以不需要像对称密码那样传输对方的密钥了。
这样安全性就大了很多。
2、工作原理1.A要向B发送信息，A和B都要产生一对用于加密和解密的公钥和私钥。
2.A的私钥保密，A的公钥告诉B；B的私钥保密，B的公钥告诉A。
3.A要给B发送信息时，A用B的公钥加密信息，因为A知道B的公钥。
4.A将这个消息发给B（已经用B的公钥加密消息）。
5.B收到这个消息后，B用自己的私钥解密A的消息。
其他所有收到这个报文的人都无法解密，因为只有B才有B的私钥。
3、主要功能非对称加密体系不要求通信双方事先传递密钥或有任何约定就能完成保密通信，并且密钥管理方便，可实现防止假冒和抵赖，因此，更适合网络通信中的保密通信要求。
非对称加密过程详解（基于RSA非对称加密算法实现）
⾮对称加密过程详解（基于RSA⾮对称加密算法实现）1、⾮对称加密过程：假如现实世界中存在A和B进⾏通讯，为了实现在⾮安全的通讯通道上实现信息的保密性、完整性、可⽤性（即信息安全的三个性质），A和B约定使⽤⾮对称加密通道进⾏通讯，具体过程如下：说明：国内⽬前使⽤双证书体系，即⽤户同时拥有签名证书、加密证书两张证书。
签名证书是⽤户的⾝份认证，是和CA协商的结果，可⽤于对⽤户A的⾝份验证；加密证书是⽤来对信息进⾏加密，是⽤户和秘钥管理系统⽣成。
我们在这⾥假设都适合CA进⾏交互。
①：此过程是⽣成公钥私钥的过程，我们这⾥基于RSA算法实现，RSA算法的详细说明在后⾯讲解。
②：此过程是CA对⽤户的⾝份进⾏签名，⽬的验证A的⾝份。
这样在A与B通讯的过程中，A可以把⾃⼰的数字签名发给B，B得到此数字签名后就可以通过CA的公钥对其进⾏解密并进⾏⾝份验证，具体过程在后⾯讲解。
③④同理。
⑤：A对要传输的信息进⾏加密并传输，B接受到以后进⾏解密的过程。
2、RSA算法：RSA原理：RSA算法基于⼀个⼗分简单的数论事实：将两个⼤素数相乘⼗分容易，但是想要对其乘积进⾏因式分解却极其困难，因此可以将乘积公开作为加密密钥。
算法：(1)选择两个不同的⼤素数p和q；(2)计算乘积n=pq和Φ(n)=(p-1)(q-1)；(3)选择⼤于1⼩于Φ(n)的随机整数e，使得gcd(e,Φ(n))=1；注：gcd即最⼤公约数。
(4)计算d使得d*e=1mod Φ(n)；注：即d*e mod Φ(n) =1。
(5)对每⼀个密钥k=(n,p,q,d,e)，定义加密变换为Ek(x)=xe mod n，解密变换为Dk(x)=yd modn，这⾥x,y∈Zn；(6)p,q销毁，以{e,n}为公开密钥，{d,n}为私有密钥。
实例：1. 假设p = 3、q = 11（p，q都是素数即可。
），则N = pq = 33；2. r =Φ(n)= (p-1)(q-1) = (3-1)(11-1) = 20；3. 根据gcd(e,Φ(n))=1，即gcd(e,20)=1，令e=3，则，d = 7。
RSA不对称加密解密技术及实现原理
5、RSA的应用流程
（1）信息发送方构建出密钥对（包括有公钥和私钥），并将公钥 公布给信息的接收方，但将私钥保留给自己使用。 （2）信息发送方使用私钥加密相关的数据，然后再用私钥对加密 后的数据结果进行数字签名，并将数字签名和加密后的数据结果 都发送给信息的接收方；信息的接收方则使用公钥解密出数字签 名的结果，并验证待解密的数据是否是有效的——没有被修改。 如果所接收到的加密结果信息是有效的，则最后将使用公钥对所 接收的加密结果数据进行解密。 （3）信息的接收方可以 使用公钥加密待返回给 信息发送方的处理结果 数据，并发送给信息的 发送方；信息发送方获 得加密的处理结果数据 后，可以通过只有自己 拥有的私钥解密处理的 结果信息。
3、非对称加密算法和对称加密算法的差别
（1）主要的差别 1）非对称密码是一种加密算法，它使用不同的密钥进行加 密和解密操作。它与对称密钥密码形成对比，对称密钥密码使 用相同的密钥进行加密和解密操作； 2）非对称密码中，一个密钥用于加密，但该密钥对于解密 是完全无用的。同样，仅仅有一个密钥可用于解密并且该密钥 对于加密也是无用的。
RSA不对称加密解密技术及实现原理
1、RSA不对称加密解密技术
RSA不对称加密解密算法是在1977年由罗纳德·李维斯特 （Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿 德曼（Leonard Adleman）一起提出的。 RSA是他们三人姓氏开头字母拼在一起组成的。
2、非对称加密解密算法产生的理论基础
1976年，两位 美国计算机学家 Whitfield Diffie 和 Martin Hellman， 提出了一种崭新 构思，可以在不 直接传递密钥的 情况下，完成对 信息的解密过程。 上面的构思被称为“Diffie-Hellman密钥交换算法”—— 加密和解密可以使用不同的规则，只要这两种规则之间存在某 种对应关系即可，从而可以避免对称加密解密算法中需要传递 和管理密钥的问题。
非对称加密技术
非对称加密技术-RSA算法数学原理分析非对称加密技术，在现在网络中，有非常广泛应用。
加密技术更是数字货币的基础。
所谓非对称，就是指该算法需要一对密钥，使用其中一个（公钥）加密，则需要用另一个（私钥）才能解密。
但是对于其原理大部分同学应该都是一知半解，今天就来分析下经典的非对称加密算法-RSA算法。
通过本文的分析，可以更好的理解非对称加密原理,可以让我们更好的使用非对称加密技术。
RSA算法原理RSA算法的基于这样的数学事实：两个大质数相乘得到的大数难以被因式分解。
如：有很大质数p跟q，很容易算出N，使得N=p*q，但给出N,比较难找pq(没有很好的方式，只有不停的尝试）这其实也是单向函数的概念下面来看看数学演算过程：1.选取两个大质数p，q，计算N=pq 及φ（N)=φ（p)φ（q)=(p-1)*(q-1)2.三个数学概念：质数(primenumbe):又称素数，为在大于1的自然数中，除了1和它本身以外不再有其他因数。
互质关系：如果两个正整数，除了1以外，没有其他公因子，我们就称这两个数是互质关系（coprime)。
φ（N):叫做欧拉函数，是指任意给定正整数N，在小于等于N 的正整数之中，有多少个与N构成互质关系，如果n是质数，则φ（n)=n-1。
如果n可以分解成两个互质的整数之积，φ（n)=φ（p1p2)=φ（p1)φ（p2)。
即积的欧拉函数等于各个因子的欧拉函数之积。
3.选择一个大于1小于中(N)的数e,使得e和中(N)互质4.e其实是1和φ（N)之前的一个质数5.计算d,使得de=1modφ(N)等价于方程式ed-1=kφ(N)求一组解。
6.d称为e的模反元素，e和φ（N)互质就肯定存在d。
7．模反元素是指如果两个正整数a和n互质，那么一定可以找到整数b,使得ab被n除的余数是1，则b称为a的模反元素。
可根据欧拉定理证明模反元素存在，欧拉定理是指若n,a互质，则：a^φ（n)三1(mod n)及a^φ（n)=a*a^(φ（n)-1)，可得a的φ（n)-1次方，就是a的模反元素。
rsa算法的描述
rsa算法的描述RSA算法是一种非对称加密算法，其名称来自于三位发明者Rivest、Shamir和Adleman的姓氏的首字母。
RSA算法的原理是基于数论中的大整数分解问题和欧拉函数的性质，具有安全性高、可靠性强的特点，在信息安全领域得到广泛应用。
RSA算法的核心思想是使用两个大质数的乘积作为公钥的一部分，而私钥是这两个大质数的积的逆元。
这意味着，只有知道这两个大质数才能破解RSA算法，而大质数的分解是一个极其困难的问题，目前还没有找到有效的算法可以在多项式时间内解决。
因此，RSA 算法的安全性依赖于大质数分解的困难性。
RSA算法的加密过程是通过对明文进行数学运算来实现的。
具体而言，加密者使用公钥对明文进行加密，得到密文；而解密者则使用私钥对密文进行解密，还原为原始的明文。
这种加密和解密的过程是互逆的，即加密和解密操作可以通过互相逆运算来实现。
在RSA算法中，加密者首先将明文转换为一个整数，然后使用公钥中的指数和模数对其进行加密。
解密者则使用私钥中的指数和模数对密文进行解密，还原为原始的明文。
在加密和解密的过程中，指数和模数的选择是关键。
通常情况下，指数选取较小的素数，而模数选择两个较大的质数的乘积。
RSA算法还具有数字签名的功能。
数字签名是一种用于验证数据完整性和身份认证的技术。
在数字签名过程中，私钥持有者可以使用自己的私钥对数据进行签名，而任何人都可以使用公钥对签名进行验证。
通过数字签名，接收者可以确保数据的来源和完整性。
总结起来，RSA算法是一种非对称加密算法，通过利用大质数分解的困难性来保证数据的安全性。
它具有安全性高、可靠性强的特点，并且可以实现加密和解密、数字签名等多种功能。
在信息安全领域，RSA算法被广泛应用于加密通信、数字签名、身份认证等方面，为保障数据的安全提供了重要的保障。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
-10-
第4章
密码与隐藏技术
作业 1
sk=k
-11-
第4章
密码与隐藏技术
-12-
第4章
密码与隐藏技术
-13-
第4章
密码与隐藏技术
i<0
作业:2.P115 4.1题 -14-
第4章
＃i nclude <stdio.h> int pfcheng(int m,int a,int r) { int b[100],length=0; int c=1; do { b[length++]=a%2; a=a/2; } while(a!=0); while(length>=0) { c=(c*c)%r; if(b[length]==1) { c=(c*m)%r; } length--; } return c; }-19-源自第4章密码与隐藏技术
（4）用对称算法传送信息时，通信双方在开 始通信之前必须约定使用同一密钥，这就带来密 钥在传递过程中的安全问题，所以必须建立受保 护的通道来传递密钥。 （5）对称算法不能提供法律证据，不具备数 字签名功能。 （6）对称算法加密速度快，这也是对称算法 唯一的重要优点，通常用对称算法加密大量的明 文。
-6-
第4章
密码与隐藏技术
欧几里德算法, 又名辗转相除法（Euclidean algorithm）乃求两个 正整数之最大公因子的算法。它是已知最古老的算法, 其可追溯至前 300年。它首次出现于欧几里德的《几何原本》（第VII卷，命题i和ii） 中，而在中国则可以追溯至东汉出现的《九章算术》。它并不需要把 二数作质因子分解。 1. b ÷ c，令r为所得余数（0≤r＜b） 若 r = 0，算法结束；c即为答案。 2. 互换：置b=c，c=r，并返回第一步。
q=13， pk=103，对明文3 进行加密。求sk 及密文。 -23-
密码与隐藏技术
void main() { int m,a,r; printf("\nPlease input three numbers,seperate them with \",\":\n"); scanf("%d,%d,%d",&m,&a,&r); printf("\nThe value of power(%d,%d) mod %d is %d",m,a,r,pfcheng(m,a,r));
是依赖于某个数学问题很难解决的基础上。
-2-
第4章
密码与隐藏技术
2.6 RSA算法
2.6.1 RSA算法数学基础 定义1：对一个自然数P，如果P只能被1和自 身除尽时，则称P为素数（或质数），否则为合 数。 定义2：如果整数a与整数b的最大公约数是1， 则称a与b是互为质数。 例如：2和3，7和11等都是互为质数。 定义3：欧拉函数定义为： φ= r（1－1/ P）（1－1/ P）·（1－1/ P） · · P 、P·P是r的质因子，即公约数。 · ·
-21-
第4章
密码与隐藏技术
（4）需要一个有效的计算方法求解一对密钥 pk、sk ，以确保不能从pk、 sk中相互推导。 （5）用公开密钥算法传送信息时，无需在通 信双方传递密钥。也就不需要建立受保护的信息 通道。这是公开密钥算法最大的优势，使得数字 签名和数字认证成为可能。公开密钥算法有着更 广阔的应用范围。 （6）就目前来看，公开密钥算法加密的速度 要比对称算法慢的多。一般只用公开密钥算法加 密安全要求高，信息量不大的场合。
-20-
第4章
密码与隐藏技术
2．公开密钥算法 （1）在公开密钥体制中，每个成员都有一对 密钥（pk、sk）。如果有N个成员，只需要2N个 密钥，需要的密钥少，密钥的分配和安全管理相 对要容易一些。 （2）知道加密过程不能推导出解密过程，不 能从 pk推导出sk，或从sk推导出pk。或者说如果 能推导出来也是很难的，要花很长的时间和代 价。 （3）容易用数学语言描述，算法的安全性建 立在已知数学问题求解困难的假设上。
第4章
密码与隐藏技术
2.5 公开密钥体制
公开密钥算法的典型特点是： 1．在公开密钥算法中，有一对密钥（pk， sk），其中pk（public-key）是公开的，即公开密 钥，简称公钥。另一个密钥sk（private key）是 保密的，这个保密密钥称为私人密钥，简称私 钥。 2．在公开密钥算法中，进行加密和解密 时，使用不同的加密密钥和解密密钥。而且不能 从加密密钥或解密密钥相互推导出来，或者很难 推导出来。
-5-
第4章
密码与隐藏技术
（3）n被所有小于等于 的素数整除 （4）若不存在被整除的数，则n为素数 2．求最大公约数算法 设b、c为整数，b > 0 ，c > 0，b > c （使用这 个条件不影响算法，但可避免符号问题），b、c 的最大公约数记为gcd（b、c）。我们可以利用 欧几里德算法，即重复使用带余数除法求最大公 约数。
}
-15-
第4章
密码与隐藏技术
=
=
61-1
-16-
第4章
密码与隐藏技术
-17-
第4章
密码与隐藏技术
2.6.4 RSA算法安全性
RSA算法的安全性取决于p、q的保密性，以及分解
大数的难度，即：已知r = p· q，分解出p、q的困难性，所 以在计算出r后要立即彻底删除p、q值。
为了提高分解大数难度，在选p、q时，还要注意如下
-7-
第4章
密码与隐藏技术
3．求乘逆算法 设 a.b=1(mod r) 已知a，求b，称求a对于模r的 乘逆b，并称a与b对r 互为乘逆。也可以写成: b = a-1 mod r 求乘逆时也可以利用欧几里德算法，即重复使 用带余数除法。但与求最大公约数不同，即每次 的余数为除数，除上次除数，直到余数为1时为 止。
-1-
第4章
密码与隐藏技术
3．在公开密钥算法中，公开密钥和私人密 钥必须配对使用。也就是说如果使用公开密钥加
密时，就必须使用相应的私人密钥解密；如果使
用私人密钥加密时，也必须使用相应的公开密钥 解密。 4．一般来说，公开密钥算法都是建立在严格 的数学基础上，公开密钥和私人密钥的产生也是
通过数学方法来产生的。公开密钥算法的安全性
-22-
第4章
密码与隐藏技术
思考题： 1. 写出RSA算法步骤 2. 影响RSA算法安全性的因素有哪些? 作业：
1. 教材p115的 4.1题目，在一个使用RSA的公开密钥系统
中,如果攻击者截获了密文C=10，公开密钥PK=5，公开模 数r=35，明文是什么?
2. 教材p115的4.2题目，利用RSA 算法运算，如果p=11，
-8-
第4章
密码与隐藏技术
(1)r1=r a1=a j=1 (2) qj=int(rj/aj) (3) rj+1=aj aj+1=mod(rj/aj)
否则返回第（２）步
-9-
第4章
密码与隐藏技术
欧几里德算法计算乘逆之C源代码 ， int chengni(int a,int r) { int q; int b1=0,b2=1,b3; void main() int r1; { do{ int a,r; if(a==0) int result; return 0; a=3,r=14; q=r/a; r1=r%a; result=chengni(a,r); b3=b1-b2*q; if(result==0) r=a; printf("\n\nNO!"); a=r1; else b1=b2; printf("\n\n%d",result); b2=b3; } }while(r1!=1); return b3;
几点： 1．要使p、q是强素数； 2．p与q的值必须相差很大，有人建议至少要在10倍 左右； 3．p-1与q-1的最大公因子应很小。 密钥越长,安全性越好 -18-
第4章
密码与隐藏技术
2.8 对称加密体制与公开密钥体制比较 1．对称算法 （1）在对称算法体制中，如果有N个成员， 就需要N（N-1）/2个密钥，这巨大的密钥量给密 钥的分配和安全管理带来了困难。 （2）在对称算法体制中，知道了加密过程可 以很容易推导出解密过程，知道了加密密钥就等 于知道了解密密钥，可以用简单的方法随机产生 密钥。 （3）多数对称算法不是建立在严格意义的数 学问题上，而是基于多种“规则”和可“选择” 假设上。
-4-
第4章
密码与隐藏技术
2.6.2 RSA算法基础
1．产生素数 产生素数的方法很多，这里介绍的方法是： （1）凡素数n必不能被2～ （实际上一个数 的最大公约数小于或等于）之间的所有素数整 除。 （2）除2以外所有素数为奇数，由素数的定 义决定算法。 判断1～N个数中的n是否为素数时具体算法 是： (1)令n从3开始（3是素数）； (2)每次增加2， n = n + 2 （排除了偶数）；
-3-
第4章
密码与隐藏技术
欧拉函数是用来计算1、2、3、·、r 中有多 · · 个数与r互为质数的。 例如：当r = 20时，由于r = 2 × 2 × 5 ，即20 的公约数是2和5 所以： = 20 ×（1-1/2）×（1-1/5）=8 即在1～20个整数中有8个与20互质的数，它 们是1，3，7，9，11，13，17，19。 定义4：两个整数a、b分别被m除，如果所得 余数相同，则称a与b对模m是同余的，记作： a ≡ b（mod m）