精华内容
下载资源
问答
  • RSA加密解密

    2019-04-23 11:21:29
    用Python3实现RSA加解密,可以对字母、数字、汉字等进行加解密
  • rsa 加解密

    2019-01-17 14:44:12
    完整的rsa加解密代码,可用,有示例,可用于512-2048位加密
  • RSA 加密解密

    千次阅读 2019-12-05 15:48:15
    RSA 加密解密实现代码如下: package com.cictec.network.bus.barcodecheck; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.serializer.SerializerFeature; import javax.crypto.Cipher; ...

    RSA 加密解密实现代码如下:

    package com.barcodecheck;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    
    import javax.crypto.Cipher;
    import java.security.*;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.Arrays;
    import java.util.Base64;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @author :zoboy
     * @Description:
     * @ Date: Created in 2019-12-05 09:28
     */
    public class RSADemo {
        static String publicKey = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAM/bj9+o9pQobuHKRCIuFm2fky8cAvmE1aiAsG/fGLm0zqVGt7M9DAHEVcLd3WVPPVSFLGvp9ysRm565vGrU4HkCAwEAAQ==";
        static String privateKey = "MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAz9uP36j2lChu4cpEIi4WbZ+TLxwC+YTVqICwb98YubTOpUa3sz0MAcRVwt3dZU89VIUsa+n3KxGbnrm8atTgeQIDAQABAkEAm62pw21sSSlDaw8wGp2EJNTYyvbi73ljARJpk1B311XPlsrfJJzDEGpHmqoenXnKTtrFK+OOLGWEEwPsJWY+gQIhAO6WrONtzxmc9CF3TgpD8c05XpKdQKHlvHNXcnCzn5bRAiEA3wbFJiQFFOXzeelDOVw+xwdKO4o4eyPx67AX4ElKaSkCIBdw+GWT+WAT2qybEzDRAiXeuBsBlkMR1lUix1ypWUmxAiEAonSSAxhVw0VFN1Zcq1mwONXskrY6Miiave2FVtDMLRECIDWX4aXKHKDpu7HwUYwsa7o/bbG7POMsCoeMkKhUxAN9";
    
        public static void main(String[] args) {
            initKey();
            Map map = new HashMap();
            map.put("requestId", "1231");
            map.put("companyCode", "10");
            map.put("busNum", "陕A07157D");
            map.put("svrReqTime", "1575422395");
            map.put("classesMD5Code", "");
            map.put("lineNum", "123569");
            String result11 = encrypt(map);
            decrypt(result11);
        }
        public static void rsaPrivateKeyInfo(RSAPrivateKey rsaPrivateKey){
            System.out.println("Private Key : " + privateKey);
            System.out.println("Private Key Mod: " + rsaPrivateKey.getModulus());
            System.out.println("Private Key Mod length: " + rsaPrivateKey.getModulus().bitLength());
            System.out.println("Private Key Exp: " + rsaPrivateKey.getPrivateExponent());
            System.out.println("Private format:" + rsaPrivateKey.getFormat());
            System.out.println("Private Key Algorithm: " +  rsaPrivateKey.getAlgorithm());
        }
        public static void rsaPublicKeyInfo(RSAPublicKey rsaPublicKey){
            System.out.println("Public Key : " + publicKey);
            System.out.println("Public Key Mod: " + rsaPublicKey.getModulus());
            System.out.println("Public Key Mod length: " + rsaPublicKey.getModulus().bitLength());
            System.out.println("Public Key Exp: " + rsaPublicKey.getPublicExponent());
            System.out.println("Public Key Algorithm: " +  rsaPublicKey.getAlgorithm());
            System.out.println("Public format:" + rsaPublicKey.getFormat());
        }
    
        public static void initKey() {
            // 1、初始化密钥
            KeyPairGenerator keyPairGenerator;
            try {
                keyPairGenerator = KeyPairGenerator.getInstance("RSA");
                keyPairGenerator.initialize(512);// 64的整倍数
                KeyPair keyPair = keyPairGenerator.generateKeyPair();
                RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
                RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
                publicKey = Base64.getEncoder().encodeToString(rsaPublicKey.getEncoded());
                privateKey = Base64.getEncoder().encodeToString(rsaPrivateKey.getEncoded());
                rsaPublicKeyInfo(rsaPublicKey);
                rsaPrivateKeyInfo(rsaPrivateKey);
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
        }
    
        public static String encrypt(Object obj) {
    
            //2 私钥加密,公钥解密   --加密
            try {
                String encryptStr = JSON.toJSONString(obj, SerializerFeature.DisableCircularReferenceDetect);
                byte[] result1 = encryptStr.getBytes("utf-8");
                byte[] buffer = Base64.getDecoder().decode(privateKey);
                PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
                KeyFactory instance = KeyFactory.getInstance("RSA");
                RSAPrivateKey key = (RSAPrivateKey) instance.generatePrivate(keySpec);
                rsaPrivateKeyInfo(key);
                Cipher cipher = Cipher.getInstance("RSA");
                cipher.init(Cipher.ENCRYPT_MODE, key);
                int inputLength = result1.length;
                System.out.println("加密字节数:" + inputLength);
    
                int MAX_ENCRYPT_BLOCK = key.getModulus().bitLength()/8-11;
                // 标识
                int offSet = 0;
                byte[] resultBytes = {};
                byte[] cache = {};
                while (inputLength - offSet > 0) {
                    if (inputLength - offSet > MAX_ENCRYPT_BLOCK) {
                        cache = cipher.doFinal(result1, offSet, MAX_ENCRYPT_BLOCK);
                        offSet += MAX_ENCRYPT_BLOCK;
                    } else {
                        cache = cipher.doFinal(result1, offSet, inputLength - offSet);
                        offSet = inputLength;
                    }
                    resultBytes = Arrays.copyOf(resultBytes, resultBytes.length + cache.length);
                    System.arraycopy(cache, 0, resultBytes, resultBytes.length - cache.length, cache.length);
                }
    
                String result11 = Base64.getEncoder().encodeToString(resultBytes);
                System.out.println("私钥加密,公钥解密   --加密: " + result11);
                return result11;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static void decrypt(String ss) {
            //3 私钥加密,公钥解密   --解密
            try {
                byte[] buffer = Base64.getDecoder().decode(publicKey);
                byte[] result1 = Base64.getDecoder().decode(ss);
                X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(buffer);
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                RSAPublicKey publicKey = (RSAPublicKey) keyFactory.generatePublic(x509EncodedKeySpec);
                rsaPublicKeyInfo(publicKey);
                Cipher cipher = Cipher.getInstance("RSA");
                cipher.init(Cipher.DECRYPT_MODE, publicKey);
                int inputLength = result1.length;
                int MAX_ENCRYPT_BLOCK =  publicKey.getModulus().bitLength()/8;
                // 标识
                int offSet = 0;
                byte[] resultBytes = {};
                byte[] cache = {};
                while (inputLength - offSet > 0) {
                    if (inputLength - offSet > MAX_ENCRYPT_BLOCK) {
                        cache = cipher.doFinal(result1, offSet, MAX_ENCRYPT_BLOCK);
                        offSet += MAX_ENCRYPT_BLOCK;
                    } else {
                        cache = cipher.doFinal(result1, offSet, inputLength - offSet);
                        offSet = inputLength;
                    }
                    resultBytes = Arrays.copyOf(resultBytes, resultBytes.length + cache.length);
                    System.arraycopy(cache, 0, resultBytes, resultBytes.length - cache.length, cache.length);
                }
    
                System.out.println("私钥加密,公钥解密   --解密: " + javax.xml.bind.DatatypeConverter.printHexBinary(resultBytes));
                System.out.println("私钥加密,公钥解密   --解密: " + new String(resultBytes, "utf-8"));
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    }
    

     

    展开全文
  • Rsa加解密

    2019-04-28 17:49:44
    近期公司项目需要用到Rsa加解密,特此编写了此demo // // RsaEncrypt.h // RsaEncrypt // // Created by ZhangNing on 2018/5/16. // Copyright © 2018年 gmrz. All rights reserved. // #import @...

    近期公司项目需要用到Rsa加解密,特此编写了此demo

    //

    // RsaEncrypt.h

    // RsaEncrypt

    //

    // Created by ZhangNing on 2018/5/16.

    // Copyright © 2018年 gmrz. All rights reserved.

    //

    #import

    @interfaceRsaEncrypt :NSObject

    typedefNS_ENUM(OSStatus,RSA_SATAUS){

    RSA_SUCCESS =0,
    
    RSA_FAILED =1<<1,
    
    RSA_GET_PUBLICKEY_FAILED =1<<2,
    
    RSA_GET_PRIVATEKEY_FAILED =1<<3
    

    };

    //类方法,初始化设置公私钥Tag

    • (instancetype)sharedInstancePrivateTag:(NSData*)privateTag publicTag:(NSData*)publicTag;

    //临时创建后临时更改公私钥tag

    • (void) setPrivateTag:(NSData*)privateTag publicTag:(NSData*)publicTag;

    //create Rsa generateKeys publicKey and privateKey

    • (RSA_SATAUS)createRSA_generate_keys;

    //encrypt someDataString use privateKey

    • (RSA_SATAUS)encryptBeforeEncryptDataIn:(NSData*)encryptDataIn EncryptDataOut:(NSData**)encryptDataOut;

    //decode SomeEncryptData use publicKey

    • (RSA_SATAUS)decodeBeforeEncryptDataIn:(NSData*)encryptDataIn DecodeRncryptDataOut:(NSData**)decodeEncryptDataOut;

    //del public and private keys Use KyesTag;

    • (RSA_SATAUS)deleteRsaKeys;

    @end

    此demo 对类进行封装,封装系统加解密方法,实现数据的加解密.

    下载地址

    展开全文
  • RSA算法原理——(3)RSA加解密过程及公式论证

    万次阅读 多人点赞 2018-07-04 00:16:32
    上期(RSA简介及基础数论知识)为大家介绍了:互质、欧拉函数、欧拉...三、RSA加解密过程及公式论证 二、RSA加解密过程及公式论证 今天的内容主要分为三个部分: rsa密钥生成过程: 讲解如何生成公钥和私钥 rs...

    上期(RSA简介及基础数论知识)为大家介绍了:互质欧拉函数欧拉定理模反元素 这四个数论的知识点,而这四个知识点是理解RSA加密算法的基石,忘了的同学可以快速的回顾一遍。

    一、目前常见加密算法简介
    二、RSA算法介绍及数论知识介绍
    三、RSA加解密过程及公式论证

    三、RSA加解密过程及公式论证

    今天的内容主要分为三个部分:

    • rsa密钥生成过程: 讲解如何生成公钥和私钥
    • rsa加解密演示: 演示加密解密的过程
    • rsa公式论证:解密公式的证明

    1、rsa密钥生成过程

    大家都知道rsa加密算法是一种非对称加密算法,也就意味着加密和解密是使用不同的密钥,而这不同的密钥是如何生成的呢?下面我们来模拟下小红是如何生成公钥和私钥的。
    这里写图片描述

    六步生成密钥:

    (1)随机选择两个不相等的质数p和q

    小红随机选择选择了6153。(实际应用中,这两个质数越大,就越难破解)

    (2)计算p和q的乘积n

    n = 61×53 = 3233

    n的长度就是密钥长度,3233写成二进制是110010100001,一共有12位,所以这个密钥就是12位。实际应用中,RSA密钥一般是1024位,重要场合则为2048位。

    (3)计算n的欧拉函数φ(n)

    这里利用我们上篇讲到的欧拉函数求解的第四种情况:

    如果n可以分解成两个互质的整数之积,即:n = p1 × p2,则φ(n) = φ(p1p2) = φ(p1)φ(p2),所以φ(3233) = φ(61x53) = φ(61)φ(53)

    又因为61和53都是质数,所以可以根据欧拉函数求解的第二种情况:

    如果n是质数,则 φ(n)=n-1,所以φ(3233) = φ(61x53) = φ(61)φ(53)=60x52=3120

    所以 φ(n)=3120

    (4)随机选择一个整数e,条件是1< e < φ(n),且e与φ(n) 互质

    小红就在1到3120之间,随机选择了17。(实际应用中,常常选择65537)

    (5)计算e对于φ(n)的模反元素d

    让我们来回顾一下什么是模反元素:
    所谓“模反元素”就是指有一个整数d,可以使得ed除以φ(n)的余数为1,公式表示:

    ed1(modφ(n))ed ≡ 1 (mod φ(n))

    这个公式等价于

    edkφ(n)=1ed – kφ(n) = 1

    将e=17、φ(n)=3120代入得:

    17d3120k=117d – 3120k = 1

    设x=d、y=-k,得

    17x+3120y=117x+3120y=1

    所以我们要求的模反元素d就是对上面的二元一次方程求解

    根据扩展欧几里得算法(辗转相除法)求解:
    这里写图片描述
    上图我们使用扩展欧几里得求得x=-367,所以d=x=-367,但通常我们习惯取正整数,这样方便计算,还记得我们上节讲过的模反元素的特性吗:

    3和11互质,那么3的模反元素就是4,因为 (3 × 4)-1 可以被11整除。显然,模反元素不止一个, 4加减11的整数倍都是3的模反元素 {…,-18,-7,4,15,26,…},即如果b是a的模反元素,则 b+kn 都是a的模反元素。

    所以我们取d=d+kφ(n)=-367+1x3120=2753,到这里所有的计算已经全部完毕!

    (6)将n和e封装成公钥,n和d封装成私钥

    让我们来回顾一下我们一共出现的6个数字:

    1. p=61; 随机数与q互质
    2. q=53;随机数与p互质
    3. n=pq=6153=3233
    4. φ(n)=φ(p*q)=φ(61x53) = φ(61)φ(53)=60x52=3120
    5. e=17; 随机数,条件是1< e < φ(n),且e与φ(n) 互质
    6. d=2753; e对于φ(n)的模反元素d

    在这个例子中n=3233,e=17,d=2753,所以公钥就是 (n,e)=(3233,17),私钥就是**(n,d)=(3233, 2753)**,这样小红就将公钥公布出去,自己保存好私钥就可以啦!

    至此我们公钥、私钥就生成完毕,是不是觉得并不是很难呢?是不是有点怀疑私钥会不会被人破解呢?下面我们来看看如何才能暴力破解私钥。

    (7)rsa算法可靠性

    回顾我们一共生成了六个数字:p q n φ(n) e d,这六个数字之中,公钥用到了两个(n和e),其余四个数字都是不公开的。其中最关键的是d,因为n和d组成了私钥,一旦d泄漏,就等于私钥泄漏。

    那么,有无可能在已知n和e的情况下,推导出d?

    1. ed≡1 (mod φ(n))。只有知道e和φ(n),才能算出d
    2. φ(n)=(p-1)(q-1)。只有知道p和q,才能算出φ(n)
    3. n=pq。只有将n因数分解,才能算出p和q

    结论:如果n可以被因数分解,d就可以算出,也就意味着私钥被破解。

    看到这里有同学可能会惊呼:原来破解RSA算法的方法这个简单???

    可是,大整数的因数分解,是一件非常困难的事情。也许你可以对3233进行因数分解(61×53),但是你没办法对下面的大整数分解:

    123018668453011775513049495838496272077285356959533479219732245215172640050726
    365751874520219978646938995647494277406384592519255732630345373154826850791702
    6122142913461670429214311602221240479274737794080665351419597459856902143413

    它等于两个质素的乘积:

    33478071698956898786044169
    84821269081770479498371376
    85689124313889828837938780
    02287614711652531743087737
    814467999489
    ×
    36746043666799590428244633
    79962795263227915816434308
    76426760322838157396665112
    79233373417143396810270092
    798736308917

    这也是目前维基百科记录的人类分解的最大整数(232个十进制位,768个二进制位),除了暴力破解,还没有发现别的有效方法。所以限制人类分解大整数的是计算机的计算能力,相信如果有一天真正的量子计算机问世后,又会引发一轮安全加密竞赛!

    • 1999年,RSA-155 (512 bits)被成功分解,花了五个月时间(约8000 MIPS年)和224 CPU hours在一台有3.2G中央内存的Cray C916计算机上完成。
    • 2009年12月12日,编号为RSA-768(768 bits, 232 digits)数也被成功分解[10]。这一事件威胁了现通行的1024-bit密钥的安全性,普遍认为用户应尽快升级到2048-bit或以上。

    2、rsa加解密演示

    小红有了公钥和私钥这样就可以进行加解密了,于是小红拉着小明一起来测试一下!

    (1)加密要用公钥 (n,e)

    假设小明先测试性的给小红发一个字母m=“A”,我们都知道在通信传输中只能传输0和1,所以我们先将“A”转ascii码为65,所以m=65,m必须是整数(字符串可以取ascii值或unicode值),且m必须小于n。

    所谓”加密”,就是使用下面的加密公式算出下式的密文c:

    mec(modn)m^e ≡ c (mod n)

    小明得到的公钥是(n,e)=(3233, 17),m=65,那么得到下面的等式:

    6517c(mod3233) 65^{17} ≡ c (mod 3233)

    小明通过计算器一算c=2790,所以他就把2790发给小红了。

    (2)解密要用私钥(n,d)

    小红拿到小明发过来的密文c=2790,就用下面的公式进行解密出明文m:

    cdm(modn) c^d ≡ m (mod n)

    而小红的私钥为:(n,d) = (3233,2753),所以得到下面的等式:

    27902753m(mod3233) 2790^{2753} ≡ m (mod 3233)

    小红通过计算器一算,得m=65,然后小红对照着ascii码表得出65对应得字母为A。

    至此,整个加解密过程就演示完了,我们来总结一下:

    1. 小明获取到小红的公钥(n,e)=(3233,17)
    2. 小明选取发送的消息m=A=65,注意m要小于n,如果消息大于n,则可以分段加密!
    3. 小明通过加密公式:m^e ≡ c (mod n) 算出密文c=2790
    4. 小红获取到小明的密文c=2790
    5. 小红使用解密公式:c^d ≡ m (mod n) 算法明文m=65=A

    我们可以看到,其实RSA加密算法最核心的就是用公式来加解密,那么我们会有个疑问?为什么解密公式一定可以得到明文m呢?也就是说这个公式是怎么推导出来的?公式一定成立吗?

    感兴趣的同学我们可以来一起证明一下解密公式,这也是整个RSA加密算法的最后最核心的一个知识点了。这里我会一步一步的推理,尽可能通俗易懂;

    3、rsa公式论证

    首先让我们再来回顾一下我们一共出现的8个数字

    1. p: 随机数与q互质
    2. q:随机数与p互质
    3. n=p*q
    4. φ(n)=φ(p*q)=φ§*φ(q)=(p-1)(q-1)
    5. e: 随机数,条件是1< e < φ(n),且e与φ(n) 互质
    6. d:e对于φ(n)的模反元素d:ed≡1 (mod φ(n))
    7. m:小明发送的明文
    8. c:小明用公钥加密后的密文

    验证rsa算法成立,主要就是验证解密公式成立:

    cdm(modn)解密公式: c^d ≡ m (mod n)

    根据加密公式:

    mec(modn)c=mekn加密公式:m^e ≡ c (mod n) → c = m^e – kn

    将c代入要我们要证明的那个解密公式:

    (mekn)dm(modn) (m^e – kn)^d ≡ m (mod n)

    上式等同于下面的公式,原因如下

    medm(modn)m^{ed} ≡ m (mod n)

    原因:我们都知道下面的二元一次方程分解,只有第一项不包含n,而所有包含n的项在对n 取余 的操作中都可以消掉。因此得出了上面那个结论

    (22n)2=48n+4n2 (2 – 2n)^2 = 4-8n+4n^2

    又因为生成密钥的第五步中我们取e并求了他对φ(n)的模反元素d:

    ed1(modφ(n))ed=hφ(n)+1 ed ≡ 1 (mod φ(n)) → ed = hφ(n)+1

    所以将ed代入上式得

    mhφ(n)+1m(modn) m^{hφ(n)+1} ≡ m (mod n)

    所以,我们只要证明这个公式成立,就证明解密公式的成立,也就证明了RSA算法的成立。

    下面我们分两种情况来验证上面的例子

    (1) m与n互质

    根据欧拉定理:如果两个正整数a和n互质,则n的欧拉函数 φ(n) 可以让下面的等式成立:

    aφ(n)1(modn)a^{φ(n)} ≡ 1 (mod n)

    证明:因为m与n互质,得

    mφ(n)1(modn)mφ(n)=1+kn(mφ(n))h=(1+kn)hm^{φ(n)} ≡ 1 (mod n) → m^{φ(n)} = 1 + kn → (m^{φ(n)})^h = (1 + kn)^h

    而(1 + kn)^h对n取模为1,因为对(1 + kn)^h拆分只有第一项1不含有n,所以有

    (mφ(n))h=(1+kn)h1(modn) (m^{φ(n)})^h = (1 + kn)^h ≡ 1 (mod n)

    同理

    (mφ(n))h1(modn)(mφ(n))h=1+kn(mφ(n))hm=(1+kn)m (m^{φ(n)})^h ≡ 1 (mod n) → (m^{φ(n)})^h = 1 + kn → (m^{φ(n)})^h*m = (1 + kn)*m

    而 (1 + kn)*m对n取模为m,因为前面说过0 < m < n,所以有

    (mφ(n))hm=(1+kn)mm(modn)mhφ(n)+1m(modn) (m^{φ(n)})^h*m = (1 + kn)*m ≡ m (mod n) → m^{hφ(n)+1} ≡ m (mod n)

    当m与n互质时,证明原式成功!!!

    (2) m与n不是互质关系

    此时m与n不互质,所以m与n必定有除1以外的公因子,而又因为n等于质数p质数q的乘积,所以m必然等于kpkq

    m = kp为例,考虑到这时m与质数q必然互质,则根据欧拉定理和欧拉函数(第二种:当q为质数,则φ(q)=q-1)使下面的式子成立:

    (kp)φ(q)1(modq)(kp)q11(modq)(kp)^{φ(q)} ≡ 1 (mod q) → (kp)^{q-1} ≡ 1 (mod q)

    同上(m与n互质中)证明原理可得:

    [(kp)q1]h(p1)×kpkp(modq)(kp)h(p1)(q1)+1kp(modq) [(kp)^{q-1}]^{h(p-1)} × kp ≡ kp (mod q) → (kp)^{h(p-1)(q-1)+1} ≡ kp (mod q)

    又因为

    ed1(modφ(n))ed=hφ(n)+1ed=h(p1)(q1)+1 ed≡1 (mod φ(n)) → ed = hφ(n) + 1 → ed = h(p-1)(q-1) + 1

    将ed代入上式

    (kp)edkp(modq)(kp)ed=tq+kp(kp)^{ed} ≡ kp (mod q) → (kp)^{ed} = tq + kp

    上式中,等式左边(kp)^ed对p取模为0,右边kp对p取模也为0,所以tq一定能整除p,但q是与p互质的,所以t必然能整除p,设t=rp,得

    (kp)ed=rpq+kp(kp)^{ed} = rpq + kp

    因为 m=kp,n=pq,所以

    med=rn+mmedm(modn) m^{ed} = rn + m → m^{ed} ≡ m (mod n)

    又因为生成密钥的第五步中我们取e并求了他对φ(n)的模反元素d:

    ed1(modφ(n))ed=hφ(n)+1 ed ≡ 1 (mod φ(n)) → ed = hφ(n)+1

    将ed代入上式得:

    mhφ(n)+1m(modn) m^{hφ(n)+1} ≡ m (mod n)

    当m与n不互质时,证明原式成功!!!

    附手稿:
    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述

    感兴趣的同学可以扫描下方二维码关注我的微信公众号:裸睡的猪
    这里写图片描述

    展开全文
  • RSA 加解密

    2014-12-05 11:27:00
    2014年12月05日 RSA 加解密 解决~~ 转载于:https://www.cnblogs.com/lee4519/p/4146266.html

    2014年12月05日

     

    RSA 加解密 解决~~

     

    转载于:https://www.cnblogs.com/lee4519/p/4146266.html

    展开全文
  • RSA加解密

    2020-07-11 12:01:08
    不支持分段加解密,明文长度超过117字节会报错 官网 github 扩展支持分段加解密 原博中分段加密输出是字节类型,为了实现前端加密,后端解密,改为base64输出 //十六进制转字节 function hexToBytes(hex) { for ...
  • 使用RSA非对称加密完成Java后端RSA加密和分段加解密,最近研究了RSA非对称加密,关于什么是RSA,网上各种文章一搜一大把,由于RSA的特性,一个1024位的密钥只能加密117位...下面就给出如何完成后端RSA加解密和分段加解密
  • rsa加解密
  • /usr/bin/env python#encoding=utf-8'''测试rsa加密解密'''from M2Crypto import RSAmsg = 'aaaa-aaaa'rsa_pub = RSA.load_pub_key('rsa_pub.pem')rsa_pri = RSA.load_key('rsa_pri.pem')print '*******************...
  • 易语言RSA加解密源码

    2020-07-21 08:34:36
    易语言RSA加解密源码,RSA加解密,DLL调用生成RSA秘钥对,读整数,libeay32dll内存清理,是否质数,libeay_rsa加密解密,十六转字节集,字节集_十六进制_优化,写整数,子程序1,子程序2,CoInitialize,CoUninitialize,RSA_free,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,967
精华内容 4,786
关键字:

rsa加解密