精华内容
下载资源
问答
  • RSA非对称加密原理

    2020-06-16 19:50:23
    RSA非对称加密原理 RSA介绍   RSA加密属于非对称加密,即加密和解密是使用密钥对中不同的秘钥进行的。自己保留的为私钥,公开的为公钥,两者都可以加密,但是只有使用另一者才能解密。   RSA加密的密钥对表示为...

    RSA非对称加密原理

    版权声明:本文为博主原创文章,未经博主允许不得转载。https://blog.csdn.net/zhangjingao/article/details/106761877

    RSA介绍

      RSA加密属于非对称加密,即加密和解密是使用密钥对中不同的秘钥进行的。自己保留的为私钥,公开的为公钥,两者都可以加密,但是只有使用另一者才能解密。
      RSA加密的密钥对表示为(E,D,N)。(E是单词加密Encryption的首字母,D是解密Decryption的首字母,N是单词数字Number的首字母)。
      RSA可以弥补对称加密中通信双方使用同一秘钥,在使用太多时,需要分配的秘钥数太多的问题,不过因为RSA需要的计算过程比较繁杂,加密速度就比对称加密慢。

    密钥对(E,D,N)解析

      E,D,N是加解密的关键,那么如何得到这些呢?
      有几个关键的数值,这里说明一下:

    关键数 含义
    (E,N) 加密密钥对
    (D,N) 解密密钥对
    E 加密次方
    D 解密次方
    N 加解密模数
    p,q,L 都是求解中间数

      第一二步为中间值,后面为核心数E,D,N。
      1、首先随机选择两个质数p,q,比如p=17,q=19。
      2、求L,L为两个质数-1的最小公倍数,即L=最小公倍((q-1),(p-1))= 144。
      3、N为两个质数之积,N=q*p=323。
      4、求E,E必须满足两个条件,非定值。
        条件1:1 < E < L
        条件1:最大公约数(E,L)= 1
        这里可以随意取,本文取E=5。
      5、求D,D也必须满足两个条件,非定值。
        条件1:1 < D < L
        条件2: D*E mod L = 1
        D需要根据E去取,本文取D=29

      很好,那么得到密钥对(5,29,323)。加密秘钥为(5,323),解密秘钥为(29,323)。

    RSA加解密过程,假设明文为1234

    加密

      密文=明文^E mod N
      即密文是由明文先取E次方,再对N取余得到的。
      以上面密钥对(5,29,323)为例:
      密文=245^5 mod 323 = 215

    解密

      明文=密文^D mod N
      即明文是由密文先取D次方,再对N取余得到的。
      以上面密钥对(5,29,323)为例:
      明文=215^29 mod 323 = 245

    展开全文
  • AES加密原理和AOE工程实践 在AI业务的开发的过程中,我们常常需要对模型文件进行加密。 我们从以下几个方面来说一说AES的加密原理以及AOE里的工程实践。 常见的加密算法 AOE对模型加密需求的思考 AES的加密原理 AOE...

    AES加密原理和AOE工程实践

    在AI业务的开发的过程中,我们常常需要对模型文件进行加密。
    我们从以下几个方面来说一说AES的加密原理以及AOE里的工程实践。

    • 常见的加密算法
    • AOE对模型加密需求的思考
    • AES的加密原理
    • AOE工程实践-AES和AOE的结合

    常见的加密算法

    常见的加密算法,主要分为两种:
    对称加密,采用单密钥的加密方法,同一个密钥可以同时用来加密和解密。常用的对称加密算法有DES,3DES,AES等。
    非对称加密,需要两个密钥来进行加密和解密,这两个密钥是公开密钥(public key,简称公钥)和私有密钥(private key,简称私钥)。常用的非对称加密算法有RSA,Elgamal,ECC等。

    用个比喻来理解一下这2种不同的加密方式:
    对称加密:假设有一个密码箱,A设置了一个密码锁好箱子,B知道这个密码以后,输入这个密码就可以打开箱子,这个密码就是秘钥,A和B使用相同的密码。
    非对称加密:有一把锁和一把唯一的钥匙,A用锁把箱子锁好,B只有用这把钥匙才能打开这个箱子。这把锁就可以理解为公钥,是公开的。这把钥匙可以理解为私钥,是不公开的,是不在网络里传输的,只有私钥的拥有者才能打开这个箱子。

    简单比较一下他们的差异:

    功能特性 对称加密 非对称加密
    密钥特征 加密方和解密方使用同一个密钥 加密方和解密方使用不同的密钥
    加密效率 效率高,速度快 速度慢
    密钥安全性 传输过程中容易泄漏 安全性高

    在实际的应用中,一般都是对称加密和非对称加密算法相结合,这样既可以保证加密的速度,也可以保证秘钥传输的安全性。以AES和RSA结合为例,有一种通用的做法,在向服务器发送一段数据信息的时候,先用AES算法对数据进行加密,再使用服务器的RSA公钥对AES的密钥进行加密后,最后数据和加密后的AES KEY上传到服务器。这样只有知道了服务器RSA私钥,才能解开得到正确的AES KEY,最终用AES KEY才能解开这段密文。

    对模型加密需求的思考

    深度学习中,模型训练是最关键和最有挑战性的。不仅需要有丰富的经验定义出合适的模型,还需要有大量的数据集,经常需要3-4天才能训练出一个模型。出于对知识产权的保护或者商业保护,我们常常需要对训练出来的模型文件进行加密。思考一下我们对模型加密的需求:速度要快,安全性要高,不依赖服务器的情况下本地也能加密解密。另外还需要有一个摘要算法来校验,保证模型的完整性。我们初步考虑使用AES算法,摘要算法使用MD5。下面我们来看看AES算法是如何工作的。

    AES的加密原理

    AES,Advanced Encryption Standard,是对称加解密算法的最经典算法之一,标准的AES加密位宽是每个块128bit,密钥分为128bit,192bit,256bit,这就是通常说的AES-128,AES-192,AES-256。我们从几个方面来具体了解一下AES加密。

    • AES加密过程
    • AES解密过程
    • AES加密模式和Padding
    • AOE加密组件为何选择AES加密算法

    AES加密过程

    AES算法主要有四种操作处理,分别是轮密钥加层(Add Round Key)、字节代换层(SubBytes)、行位移层(Shift Rows)、列混淆层(Mix Columns)。AES加密的过程,并不是明文和密钥简单运算一下。以AES128为例,它要执行10轮加密。实际的执行过程是这样的:

    • 第0轮,把原始数据和原始密钥进行异或;
    • 第1-9轮,执行SubBytes,ShiftRows,MixColumns,AddRoundKey的完整流程;
    • 第10轮,执行SubBytes,ShiftRows,不执行MixColumns;
    static void Cipher(state_t* state, const uint8_t* RoundKey)
    {
      uint8_t round = 0;
      // Add the First round key 
      AddRoundKey(0, state, RoundKey); 
    
      // There will be Nr rounds.
      for (round = 1; round < Nr; ++round)
      {
        SubBytes(state);
        ShiftRows(state);
        MixColumns(state);
        AddRoundKey(round, state, RoundKey);
      }
      
      // The last round is given below.
      SubBytes(state);
      ShiftRows(state);
      AddRoundKey(Nr, state, RoundKey);
    }
    

    SubBytes

    SubBytes,字节混淆。AES处理的最小单位是8位无符号整数,正好可以对应伽罗瓦域GF(28)上的一个元素,混淆的方法是先计算每一个字节在GF(28)的乘法逆元,目的是提供非线性变换。再对结果做一次仿射变换,目的是改变掉伽罗瓦域的结构。
    在这里插入图片描述

    因为GF(28)中的每一个元素,都可以用多项式来表示:a7x7 + a6x^6 + a5x^5 + … + a1x + a0,其中a7-a0,只能从GF(2)中取值。所以对某个字节计算逆元,可以转换成求多项式的逆元。以0xac为例,写成二进制是10101100,写成多项式就是x^7 + x^5 + x^3 + x^2,计算逆元就变成计算这个多项式的逆元。得到多项式逆元以后,我们可以把它转换成16进制的值。仿射变换简单理解,就是通过某个计算,得到一个新的值。具体的计算方法,我们就不多介绍了。实际中,可以用查表法来完成这一步骤。

    因为这些步骤得到的每个字节的值是固定对,所以我们可以计算出GF(2^8)中每个元素对应的值,最后我们可以得到了一张16*16的查找表,叫做Substitution-box,简称sbox或者s盒。对于每个输入的字节,例如输入字节的十六进制形式位0xAB,则在表格的纵坐标中定位A,再在纵坐标中定位B,最后使用s(a,b)的值来替换这个字节的值。通过这个步骤,我们的输入数据D1-D16,变成了S1-S16。
    在这里插入图片描述

    ShiftRows

    将16个S盒变换后的字节,从上往下、从左到右地写成了一个矩阵。第一行保持不动,第二行向左移动1格,第三行向左移动2格,第四行向左滑移动3格,如图所示:
    在这里插入图片描述

    MixColumns

    用下面这个矩阵和ShiftRows之后的结果相乘。列混淆操作混淆了输入矩阵的每一列,使输入的每个字节都会影响到4个输出字节。这部分包含了矩阵乘法,伽罗瓦域内加法和乘法的相关知识。总的来说,ShiftRows和MixColumns两步骤为这个密码系统提供了扩散性。
    在这里插入图片描述
    左边矩阵中的01,02,03对应的多项式分别是1,x,x+1。假设右边矩阵输入全部是0x11,对应的多项式是x4+1。使用GF(28)中的加法和乘法,计算过程如下:

    C(i) = (01 + 01 + 02 + 03) * 11
    =(1 + 1 + x + x + 1) * (x^4 + 1)
    = 1 * (x^4+1)
    = x^4 + 1
    

    乘法结果有两种情况:

    • 最高次幂没有超过x^7,这时的结果就是相乘之后的结果。
    • 如果超过了x^8,我们就要把这个多项式对P(x)取模,其中P(x) = x^8 + x^ 4 + x^3 + x + 1。

    AddRoundKey

    在上面的几个步骤中,我们是对输入对数据进行混淆。AddRoundKey每执行一次叫做一轮加密,这一步会执行多次。简单来说就是把密钥和混淆后的结果进行xor运算,但在每一轮使用的密钥都是根据上一轮的密钥变换而来的。
    轮密钥是如何生成的?以AES-128为例,密钥一共16个字节,我们把它们4字节分成一组,计作W0-W3。在每一轮中,通过函数g变换和固定的公式,可以得到这一轮的密钥。一共生成44个W(i),每4个为一组一共生成11个密钥k0-k10,其中k0是原始密钥。轮数依赖于密钥长度,16字节密钥对应10轮,24字节密钥对应12轮,32字节对应14轮。具体的计算过程我们就不再描述了,看起来简单,实际上背后有大量的数学知识和研究作为支撑。

    AES解密过程

    对于解密,就是把加密的过程反过来,如下面的参考代码,其中的InvShiftRows,InvSubBytes,InvMixColumns分别是对应算法的逆运算。

    static void InvCipher(state_t* state, const uint8_t* RoundKey)
    {
      uint8_t round = 0;
      // Add the First round key 
      AddRoundKey(Nr, state, RoundKey); 
    
      // There will be Nr rounds.
      for (round = (Nr - 1); round > 0; --round)
      {
        InvShiftRows(state);
        InvSubBytes(state);
        AddRoundKey(round, state, RoundKey);
        InvMixColumns(state);
      }
      
      // The last round is given below.
      InvShiftRows(state);
      InvSubBytes(state);
      AddRoundKey(0, state, RoundKey);
    }
    

    平常工作中,我们是不推荐自己手写这类成熟专业的加密算法的,很容易写出漏洞或者错误,最终造成严重的安全问题。

    加密模式和Padding

    AES只能对固定长度的数据进行加密,对于不定长的数据,我们需要把它切分成若干定长的数据,再进行加密解密,这就是我们常说的分组加密。分组加密有ECB,CBC,CFB,OFB这几种加密模式,我们介绍一下ECB模式和CBC模式,以及Padding的对加密解密的影响。

    ECB模式
    ECB模式又称电子密码本模式(Electronic codebook):ECB是最简单的块密码加密模式,加密前根据加密块大小(如AES为128位)分成若干块,之后将每块使用相同的密钥单独加密,解密同理。具体见下图:
    在这里插入图片描述
    (图片来自维基百科)

    ECB模式由于每块数据的加密是独立的,所以可以分块进行并行加密或者解密。它的缺点是相同的明文块会被加密成相同的密文块,所以这种方法在某些条件下安全性相对不是很高。

    CBC模式
    CBC模式又称密码分组链接(Cipher-block chaining):CBC模式对于每个待加密的密码块在加密前会先与前一个密码块的密文异或然后再用加密器加密,第一个明文块与一个叫初始化向量IV的数据块异或。具体见下图:
    在这里插入图片描述
    完成加密或解密后会更新初始化向量IV,CBC模式安全性更高,但由于对每个数据块的加密依赖前一个数据块的加密,所以加密是无法并行的。

    用一张图来比较看一下ECB和CBC加密的效果,可以发现使用CBC模式分散性和安全性更好。
    在这里插入图片描述
    Padding
    在AES加密与解密的过程中,如果需要加密的数据不是16的倍数的时候,需要对原来的数据做填充操作。填充的方式有pkcs7padding/zeropadding/NoPadding等。
    我们看看不同的填充方式是如何进行填充的,例设一开始的数据是FF FF FF FF FF FF FF FF FF
    PKCS7填充:FF FF FF FF FF FF FF FF FF 07 07 07 07 07 07 07
    Zeros填充:FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00
    NoPadding:不填充,需要自己保证数据是16的倍数。

    显然,不同的padding对加密与解密是有影响的,所以在加密和解密的时候需要保证padding的方式是一致的。

    AOE加密组件为何选择AES加密算法

    理论上大部分的算法都是可以破解的,只是有可能需要很长时间的计算才能破解。AES加密算法在目前的计算能力下,直接破解几乎是不可能的。从我们保护模型的目的来看,使用AES-128就可以满足我们的需求。另外,在AES算法被标准化后,很多硬件芯片和软件工具都实现了对AES的支持,使用AES算法来加密解密,性能也非常高。综合考虑了性能和安全性,我们使用了AES-128/CBC算法来做加密,并在这个基础上结合MD5摘要算法,对文件的完整性做校验。

    AOE工程实践-AES和AOE的结合

    我们从以下几个方面来看看AOE的加密组件是如何实现的:

    • AOE的加密文件结构
    • AOE的加密过程
    • AOE的解密过程
    • AOE加密组件的使用

    AOE的加密文件结构
    我们设计了一个新的文件结构,加密后的文件结构如下:

    1byte 4bytes 16bytes nbytes
    Version Code File Length File MD5 加密后的模型文件数据

    我们在加密后的模型数据前,增加了一个head,head一共21个byte:

    • Version Code, 1byte,表示模型的加密方法索引,从1开始依次递增。
      如果模型加密的版本号 > sdk能支持解密的版本号,则解密失败,需要更新sdk。
    • File Length,4bytes,表示模型文件的原始长度。
    • File MD5,16bytes,表示模型文件的原始MD5,解密出的模型文件MD5需要和这个MD5一致。
    • 加密后的模型文件数据,nbytes,根据不同的加密算法,得到的数据长度也是不一样的。

    AOE第一版的加密算法(Version Code为1),加密和解密都可以在本地完成,不需要和服务器进行交互,对应的加密解密过程如下:

    AOE的加密过程
    1,采用AES-128/CBC/No Padding对模型加密。
    2,给文件加上21字节的文件头,Version Code + File Length + File MD5。
    3,使用文件MD5和加密后的模型做简单的Swap操作,把MD5的16个byte,分别和模型加密后的前16k数据的第一个字节进行交换。

    使用AES方式加密,我们面临一个问题,密钥很容易泄漏。为了解决这个问题,首先我们选择了CBC模式,其次我们对加密后对文件做了一下混淆。这样即使别人知道了我们的AES KEY,如果不知道我们加密组件里的混淆方式,因为是CBC模式加密,所以他也是无法解开我们加密后的文件的。

    AOE的解密过程
    解密的过程和加密的过程是相反的,具体的算法如下:
    1,读取加密文件的前21个字节,得到Version Code,文件长度。
    2,读取加密数据的前16k数据的第一个字节,和head里的MD5字段进行swap,经过这一步以后,可以得到文件的MD5和原始的加密后的数据。
    3,采用AES-128/CBC/No Padding对模型解密,得到解密文件以后使用文件MD5来检验文件的完整性。

    AOE加密组件的使用
    AOE加密组件,提供了C版本和JNI封装,JAVA版本和Python版本,在端上我们更推荐使用C版本,在服务器后台我们推荐使用JAVA版本或者Python版本来做一些批量的工作。我们提供了解密到内存和文件两种方式,我们更推荐直接解密到内存里,这样不会生成临时文件,安全性更高。

    思考和总结

    密码学对大部分人来说是非常专业的,需要大量的数学知识,加密和破解也一直是矛和盾的关系。目前AOE SDK站在成熟算法的肩膀上,结合了AES算法对模型进行了加密,后续我们还会扩展一些新的加密算法,给大家参考和使用。欢迎大家来使用和提建议。

    https://github.com/didi/aoe
    (AoE (AI on Edge,终端智能,边缘计算) 是一个终端侧AI集成运行时环境 (IRE),帮助开发者提升效率)

    添加小助手微信进入AOE开源交流群
    在这里插入图片描述

    展开全文
  • RSA 非对称加密原理

    2020-01-18 11:43:21
    RSA 加密原理 步骤 说明 描述 备注 1 找出质数 P 、Q - 2 计算公共模数 N = P * Q - 3 欧拉函数 φ(N) = (P-1)(Q-1) - 4 计算公钥E 1 < E < φ(N) E的取值必须是整数E 和 φ(N) 必须是互质数 ...

    RSA 加密原理

    步骤 说明 描述 备注
    1 找出质数 P 、Q -
    2 计算公共模数 N = P * Q -
    3 欧拉函数 φ(N) = (P-1)(Q-1) -
    4 计算公钥E 1 < E < φ(N) E的取值必须是整数E 和 φ(N) 必须是互质数
    5 计算私钥D E * D % φ(N) = 1 -
    6 加密 C = M E mod N C:密文 M:明文
    7 解密 M =C D mod N C:密文 M:明文

    公钥=(E , N)
    私钥=(D, N)

    对外,我们只暴露公钥。

    示例

    1、找出质数 P 、Q

    P = 3  
    Q = 11
    

    2、计算公共模数

    N = P * Q = 3 * 11 = 33
    N = 33
    

    3、 欧拉函数

    φ(N) = (P-1)(Q-1) = 2 * 10 = 20
    φ(N) = 20
    

    4、计算公钥E

    1 < E < φ(N)
    1 <E < 20
    

    E 的取值范围 {3, 7, 9, 11, 13, 17, 19}
    E的取值必须是整数, E 和 φ(N) 必须是互质数
    为了测试,我们取最小的值 E =3
    3 和 φ(N) =20 互为质数,满足条件

    5、计算私钥D

    E * D % φ(N) = 1
    3 * D  % 20 = 1  
    

    根据上面可计算出 D = 7

    6、公钥加密

    我们这里为了演示,就加密一个比较小的数字 M = 2

    公式:C = ME mod N

    M = 2
    E = 3
    N = 33
    

    C = 23 % 33 = 8

    明文 “2” 经过 RSA 加密后变成了密文 “8”

    7、私钥解密

    M =CD mod N

    C = 8
    D = 7
    N = 33
    

    M = 87 % 33
    8 * 8 * 8 * 8 * 8 * 8 * 8=2097152
    8 * 8 * 8 * 8 * 8 * 8 * 8 % 33 = 2

    密文 “8” 经过 RSA 解密后变成了明文 2。

    JDK 自带的 RSA 算法

    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    
    import javax.crypto.Cipher;
    
    import org.apache.commons.codec.binary.Base64;
    
    /**
     * 非对称加密 唯一广泛接受并实现 数据加密&数字签名 公钥加密、私钥解密 私钥加密、公钥解密
     * 
     * @author jjs
     *
     */
    public class RSADemo {
    
        private static String src = "infcn";
    
        private static RSAPublicKey rsaPublicKey;
        private static RSAPrivateKey rsaPrivateKey;
    
        static {
            // 1、初始化密钥
            KeyPairGenerator keyPairGenerator;
            try {
                keyPairGenerator = KeyPairGenerator.getInstance("RSA");
                keyPairGenerator.initialize(512);// 64的整倍数
                KeyPair keyPair = keyPairGenerator.generateKeyPair();
                rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
                rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
                System.out.println("Public Key : " + Base64.encodeBase64String(rsaPublicKey.getEncoded()));
                System.out.println("Private Key : " + Base64.encodeBase64String(rsaPrivateKey.getEncoded()));
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 公钥加密,私钥解密
         * @author jijs
         */
        public static void pubEn2PriDe() {
            //公钥加密
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("公钥加密,私钥解密 --加密: " + Base64.encodeBase64String(result));
    
            //私钥解密
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            keyFactory = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            result = cipher.doFinal(result);
            System.out.println("公钥加密,私钥解密 --解密: " + new String(result));
        }
    
    
        /**
         * 私钥加密,公钥解密
         * @author jijs
         */
        public static void priEn2PubDe() {
    
            //私钥加密
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("私钥加密,公钥解密 --加密 : " + Base64.encodeBase64String(result));
    
            //公钥解密
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            result = cipher.doFinal(result);
            System.out.println("私钥加密,公钥解密   --解密: " + new String(result));
        }
    
        public static void main(String[] args) {
            pubEn2PriDe();  //公钥加密,私钥解密
            priEn2PubDe();  //私钥加密,公钥解密
        }
    }
    

    个人博客
    腾讯云社区
    掘金
    CSDN
    简书
    GitHub
    码云
    OSCHINA
    Segmentfault
    公众号:wx.jpg

    展开全文
  • RSA加密原理详解

    千次阅读 2019-02-18 09:57:31
    RSA加密的核心其实是欧拉定理,通过这个定理得到了这种非对称加密算法 一、算法介绍 找到两个素数p和q,并计算n=p*q 找到(d,φ(n))=1,即d与φ(n)互质,其中0&amp;lt;d&amp;lt;φ(b),φ(n)为欧拉函数,是指...

    RSA加密的核心其实是欧拉定理,通过这个定理得到了这种非对称加密算法

    一、算法介绍

    找到两个素数ppqq,并计算n=pqn=pq
    找到(d,φ(n))(d,\varphi(n)),即ddφ(n)\varphi(n)互质,其中0&lt;d&lt;φ(b)0&lt;d&lt;\varphi(b)φ(n)\varphi(n)为欧拉函数,是指&lt;n&lt;n且与nn互质的正整数的个数
    因为n=pqn=pq,所以φ(n)=(p1)(q1)\varphi(n)=(p-1)(q-1),也就是说dd(p1)(q1)(p-1)(q-1)互质
    再找到0&lt;e&lt;φ(n)0&lt;e&lt;\varphi(n)使得de1(mod φ(n))de\equiv1(mod\space\varphi(n)),即dede除以φ(n)\varphi(n)余数为1
    那么形成秘钥对(n,d)(n,d)(n,e)(n,e),分别是私钥和公钥
    使用秘钥对(n,x)(n,x)加密的方法为f(a,n,x)=ax(mod n)f(a,n,x)=a^x(mod\space n),解密为同一函数
    那么就可以用公钥加密私钥解密或用私钥加密公钥解密,即
    B=f(A,n,d)B=f(A,n,d)A=f(B,n,e)A=f(B,n,e)
    但细心的人会发现,知道nn就知道了φ(n)\varphi(n),结合dd就可以算出ee,这样知道公钥就知道私钥
    其实,RSA加密的核心就在于ppqq的选择,这两个质数一定要选择的很大,相乘容易,分解难
    所以破解往往长达数月(nn的长度为512和七百多的RSA已经被成功破解)
    所以现在nn的长度至少为1024,有很多是2048

    二、欧拉定理

    nnxx为正整数,(x,n)=1(x,n)=1,则有xφ(n)1(mod n)x^{\varphi(n)}\equiv1(mod\space n),这就是欧拉定理,下面简单的证明一下
    构造modnmod n的既约剩余系(不懂的同学们看第三块)
    设为a1,a2,...,aφ(n)a_1,a_2,...,a_{\varphi(n)},并找一个与nn互质的数xx,根据既约剩余系的积不变性(见第三块),有
    既约剩余系xa1,xa2,...,xaφ(n)xa_1,xa_2,...,xa_{\varphi(n)}的积与上述既约剩余系的积mod nmod\space n同余
    a1,a2,...,aφ(n)a_1,a_2,...,a_{\varphi(n)}的积为kk,那么第二个既约剩余系的乘积为kxφ(n)kx^{\varphi(n)}
    则有kkxφ(n)(mod n)k\equiv kx^{\varphi(n)}(mod\space n),而因为aia_inn互质,所以kknn互质,所以两边同时除去kk
    xφ(n)1(mod n)x^{\varphi(n)}\equiv 1(mod\space n),得证!

    三、既约剩余系

    设有正整数nn,找到rr的集合,其中1rn1\le r\le n(r,n)=1(r,n)=1
    设这个集合为r1,r2,...,rk{r_1,r_2,...,r_k},那么根据欧拉函数的定义,k=φ(n)k=\varphi(n)
    对于一个φ(n)φ(n)元正整数集合,如果对其每一个元素mod nmod\space n后得到的集合与上述集合相等
    那么称这个集合为mod nmod\space n的既约剩余系
    而根据上述定义,所有mod nmod\space n的既约剩余系mod nmod\space n的性质类似
    显然,任何两个mod nmod\space n的既约剩余系的和与积mod nmod\space n同余(因为每个元素对应mod nmod\space n同余)
    所以既约剩余系有和不变性积不变性

    四、总结

    RSA加密算法是通过欧拉定理得到的,该算法的安全性来源于大数分解质因数的困难,在选取ppqq的时候要尽可能的大一些
    RSA因为涉及到大数运算,甚至包括幂运算,所以速度比对称加密算法慢得多,一般用于加密对称加密的较短秘钥

    展开全文
  • RSA加密解密原理

    2020-12-08 18:07:34
    文章目录RSA算法简介:1、什么是非对称加密算法:2、RSA 加密原理:3、RSA加密算法过程详解:1、找出质数 :2、计算公共模数:3、计算欧拉函数 φ(n):4、计算公钥 e:5、计算私钥 d:6、加密生成密文:7、解密生成...
  • rsa公私钥加密原理

    2017-07-19 09:08:00
    假设爱丽丝的公钥是(3233, 17);加入发送65,公钥加密后的结果是2790 ...私钥(n,d) 总共有2个密钥的数据加密数据的过程,m的e次方,(m^e) mod 3233,那么结果就是2790,就是得出的结果 转载于...
  • shellcode 进行加密原理

    2013-08-01 22:28:00
    对shellcode 进行加密: #include "stdio.h" char popup_general[]= "\xFC\x68\x6A\x0A\x38\x1E\x68\x63\x89\xD1\x4F\x68\x32\x74\x91\x0C" "\x8B\xF4\x8D\x7E\xF4\x33\xDB\xB7\x04\x2B\xE3\x66\xBB\x33\x32\x5.....
  • RSA 加密原理 步骤 说明 描述 备注 1 找出质数 P 、Q - 2 计算公共模数 N = P * Q - 3 欧拉函数 φ(N) = (P-1)(Q-1) - 4 计算公钥E 1 < E < φ(N) ...
  • RSA加密原理 a b c 三个数 (a, b) (a,c) 两两互质关系 互质:a的因子集合 和 b的因子集合 交集只有1 因子:4 能整除2, 那2就是4的因子。集合(1,2) 所以: a,b,c 中a是已知数,b,c其中一个为已知,那么根据欧拉...
  • RSA 加密原理 公钥=(E , N) 私钥=(D, N) 注意: 加密算法是C = M^E modN 解密算法是M = C^D mod N 对外,我们只暴露公钥。 示例 1、找出质数 P 、Q P = 3 Q = 11 2、计算公共模数 N = P * Q = 3 ...
  • base64加密原理

    2010-08-05 09:54:34
    把每三个字符,共24位2进制的ASCII码,折分成连续4个6位的ASCII码,再在每个ASCII码前面补00变成8位,如果不够3位,则补8个0,一般情况...D 4->E 5->F 6->G 7->H 8->I 9->J 10->K 11->L 1...
  • 使用U盘、移动硬盘加密工具加密文件夹后,我用文件嗅探器工具也看不到加密后真实的文件,当用金山毒霸扫描发现,好像... 我们先在D盘新建个文件夹如lskr,即地址为D:/lskr,在里面随便放些文件,我放了大小分别为168KB
  • 加密通讯原理

    2014-06-28 15:15:20
    WSDL2h.exe -d -o ibox.h -d是为了使用DOM 需要I
  • RSA加密算法原理

    2014-04-10 16:02:44
    概念: 公钥:给需要加密方 私钥:解密者自己留 密钥生成过程: ...1:随机选择两个质数p、q,计算出 n=p x q ...4:计算出e x d mod f(n) = 1 时 d的值. 5:则(e,n)为公钥(d,n)为私钥 加密过程: 原文^e m
  • RSA 加密原理 步骤 说明 描述 备注 1 找出质数 P 、Q - 2 计算公共模数 N = P * Q - 3 欧拉函数 φ(N) = (P-1)(Q-1) - 4 计算公钥E 1 < E < φ(N) E的取值必须是整数 E 和 φ(N) 必须是互质数 5 计算私钥D E ...
  • 软件加密原理

    千次阅读 2009-05-14 22:18:00
    软件狗[Dongles]1、认识软件狗。[首先我对软件狗作一简单介绍,在后面我们将对各种软件狗的加密和解密做详细的讲解。]软件狗是插在微机并行口上的一个软件...常见的软件狗加密盒外形,如两个一公一母的D行25针连接器倒
  • 复习一手rsa加密,感觉已经有点记不清了 找出质数 找出质数 P Q 计算公共模数 计算公共模数 N = P*Q 计算欧拉函数 计算欧拉函数 φ(N)= (P-1)*(Q-1) 计算公钥 计算公钥E E的取值必须是整数,E和φ(N)...
  • Vigenere算法加密和解密原理及其实现

    千次阅读 2019-04-18 11:24:56
    一、加密解密原理 可以根据一个示例来解释原理 明文:TOBEHAPPY 秘钥:HELLO 进行加密解密的过程: 步骤1.给26个A-Z字母按顺序1-26编号 字母 A B C D ...
  • WebConfig 加密解密的原理是什么? 使用命令 加密数据连接串  加密:aspnet_regiis -pef connectionStrings d:/...(webconfig所在路径,不能含中文字符) 解密:aspnet_regiis -pdf connectiongStrings d:/......
  • RSA加密 工作原理记录

    2009-12-18 10:35:03
    RSA方法的工作原理如下: 1) 任意选取两个不同的大质数p和q,计算乘积r=p*q; 2) 任意选取一个大整数e,e与(p-1)*(q-1)互质,整数e用做加密密钥。注意:e的选取是很容易的,例如,所有大于p和q的质数都可用。 ...
  • MD5加密算法原理

    千次阅读 2008-01-27 15:16:00
    MD5加密算法原理的Java Bean实现MD5简介 http://haoguoying.blog.hexun.com/14081699_d.htmlMD5的全称是Message-Digest Algorithm 5,在90年代初由MIT的计算机科学实验室和RSA Data Security Inc发明,经MD2、MD3和...
  • 网络基本原理加密

    千次阅读 2016-03-01 14:45:45
    数据加密1. base64编码加密一种简单的加密方式,本质是将任意的二进制数据编码成字符串,在网络上传输.//终端命令 base64编码 base64 xx.png -o abc.txt 编码...base64 abc.txt -o xx.png -D 解码文件 echo -n "TWFu" |

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 527
精华内容 210
关键字:

d加密原理