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

    2015-09-22 12:00:00
    2019独角兽企业重金招聘Python工程师标准>>> 先留个空,抽时间写清楚过程。 转载于:https://my.oschina.net/sanping/blog/509547

    先留个空,抽时间写清楚过程。

    转载于:https://my.oschina.net/sanping/blog/509547

    展开全文
  • Python RSA加密解密

    千次阅读 2020-10-20 20:25:21
    Python RSA加密解密 RSA是一种非对称加密算法 非对称加密需要公钥(publickey)和私钥(privatekey) 消息传递前需要先生成公钥和私钥,发送方将待发送消息用公钥加密,发送给...RSA加密解密过程: import rsa # rs

    Python RSA加密解密

    RSA是一种非对称加密算法

    非对称加密需要公钥(publickey)和私钥(privatekey)

    消息传递前需要先生成公钥和私钥,发送方将待发送消息用公钥加密,发送给接收方。接收方收到消息后,用私钥解密。在这个过程中,公钥负责加密,私钥负责解密,消息在传输过程中即使被截获,攻击者由于没有私钥,无法破解截获的消息。

    非对称加密算法的加解密速度低于对称加密算法,但是安全性更高。

    非对称加密算法:RSA、DSA、ECC等算法

    RSA加密解密过程:

    import rsa
    
    
    # rsa加密
    def rsaEncrypt(str):
        # 生成公钥、私钥
        (pubkey, privkey) = rsa.newkeys(512)
        print("公钥:\n%s\n私钥:\n%s" % (pubkey, privkey))
        # 明文编码格式
        content = str.encode("utf-8")
        # 公钥加密
        crypto = rsa.encrypt(content, pubkey)
        return (crypto, privkey)
    
    
    # rsa解密
    def rsaDecrypt(str, pk):
        # 私钥解密
        content = rsa.decrypt(str, pk)
        con = content.decode("utf-8")
        return con
    
    
    if __name__ == "__main__":
        str, pk = rsaEncrypt("password")
        print("加密后密文:\n%s" % str)
    
        content = rsaDecrypt(str, pk)
        print("解密后明文:\n%s" % content)
    

    输出结果:

    公钥:
    PublicKey(9159426407102734998560294890451891757513071757088584253729648528501417390045783844324225057548342352223226493499499812727491257587964648637915558412428127, 65537)
    私钥:
    PrivateKey(9159426407102734998560294890451891757513071757088584253729648528501417390045783844324225057548342352223226493499499812727491257587964648637915558412428127, 65537, 7190772358695741617878842980433042141321773272715637707533822824357636537829981741351623829030718781697003727767252117623450712680213111880577214133630801, 6909139008438239969203597869903711106052468607857293363487996250670397485518005063, 1325697224490082438898074923574950933686195846386160566957092835626425129)
    加密后密文:
    b"V\xc5\x1a\xfd<\xa1\x84\xf7P\x19\xb9\xf8\x14\x8d\xc4\x9dt\x1c\xc8\xe6\xe4T\x8aJ\xe8\\\xc5\xc6\xa4\xd6\xaeH\x80\x1f('Z\xef%\x03\x05Z)\x8fvVX\xe2\xd5\xc9HtRx\xce,\x1el\xf4\xc0\x87\x95\xef;"
    解密后明文:
    password
    

    使用 Crypto.PublicKey.RSA 生成公钥、私钥:

    import Crypto.PublicKey.RSA
    import Crypto.Random
     
    x = Crypto.PublicKey.RSA.generate(2048)
    a = x.exportKey("PEM")  # 生成私钥
    b = x.publickey().exportKey()   # 生成公钥
    with open("a.pem", "wb") as x:
        x.write(a)
    with open("b.pem", "wb") as x:
        x.write(b)
     
    y = Crypto.PublicKey.RSA.generate(2048, Crypto.Random.new().read)   # 使用 Crypto.Random.new().read 伪随机数生成器
    c = y.exportKey()   # 生成私钥
    d = y.publickey().exportKey()   #生成公钥
    with open("c.pem", "wb") as x:
        x.write(c)
    with open("d.pem", "wb") as x:
        x.write(d)
    

    使用 Crypto.PublicKey.RSA.importKey(private_key) 生成公钥和证书:

    import Crypto.PublicKey.RSA
     
    with open("a.pem", "rb") as x:
        xx = Crypto.PublicKey.RSA.importKey(x.read())
     
    b = xx.publickey().exportKey()   # 生成公钥
    with open("b.pem", "wb") as x:
        x.write(b)
        
    a = xx.exportKey("DER")   # 生成 DER 格式的证书
    with open("a.der", "wb") as x:
        x.write(a)
    

    使用 RSA 生成公钥、私钥:

    import rsa
    
    f, e = rsa.newkeys(1024)  # 生成公钥、私钥
    
    e = e.save_pkcs1()  # 保存为 .pem 格式
    with open("private.pem", "wb") as x:  # 保存私钥
        x.write(e)
    f = f.save_pkcs1()  # 保存为 .pem 格式
    with open("public.pem", "wb") as x:  # 保存公钥
        x.write(f)
    

    RSA非对称加密:

    import rsa
    import base64
    
    password = 'password'
    print('password:%s' % password)
    
    y = base64.b64encode(password.encode())
    print('y:%s' % y)
    
    with open("public.pem", "rb") as x:
        f = x.read()
        f = rsa.PublicKey.load_pkcs1(f)  # load 公钥
    
    with open("private.pem", "rb") as x:
        e = x.read()
        e = rsa.PrivateKey.load_pkcs1(e)  # load 私钥
    
    cipher_text = rsa.encrypt(y, f)  # 使用公钥加密
    print('cipher_text:%s' % cipher_text)
    
    msg = base64.b64encode(cipher_text).decode()
    print('msg:%s' % msg)
    
    crypto = base64.b64decode(msg)
    print('crypto:%s' % crypto)
    
    text = rsa.decrypt(crypto, e).decode()  # 使用私钥解密
    print('text:%s' % text)
    
    password = base64.b64decode(text).decode()
    print('password:%s' % password)
    

    输出结果:

    password:password
    y:b'cGFzc3dvcmQ='
    cipher_text:b" w\xc3\x80\xb5V\xdb\x95\x1eJ{\x95`\xb1\xd8\xea\xb8G\x9a1\xc6N6\xcd\x9c\r\xfa\xa5;E\xfe\xb7\xe8\xef\x93\xbd\x94\xd4H\xbe\xd5\xcb\xaa\xfd\n\x08\x12\xdd\xc0\x93\xbb\x0e\xc2\xb7S\xd3\xd5\x95\x86+\xbeJ\xd8Yv\xa8\xac\r\xb6y\xd1\xae\xeb:.XH\xa6\xc6\xce\xb5y1\xbe\xc6q\x8c\xd6 \xae\xa9\xd0\xd3$\xb6[\xbab\x99:\xdbz\xb0\x80BkK\xbc%\x19e\x06\xfbP\xa6\xc9\x10\x19\xe3'\x1bd\\\xd1\xd5\xb4Aj"
    msg:IHfDgLVW25UeSnuVYLHY6rhHmjHGTjbNnA36pTtF/rfo75O9lNRIvtXLqv0KCBLdwJO7DsK3U9PVlYYrvkrYWXaorA22edGu6zouWEimxs61eTG+xnGM1iCuqdDTJLZbumKZOtt6sIBCa0u8JRllBvtQpskQGeMnG2Rc0dW0QWo=
    crypto:b" w\xc3\x80\xb5V\xdb\x95\x1eJ{\x95`\xb1\xd8\xea\xb8G\x9a1\xc6N6\xcd\x9c\r\xfa\xa5;E\xfe\xb7\xe8\xef\x93\xbd\x94\xd4H\xbe\xd5\xcb\xaa\xfd\n\x08\x12\xdd\xc0\x93\xbb\x0e\xc2\xb7S\xd3\xd5\x95\x86+\xbeJ\xd8Yv\xa8\xac\r\xb6y\xd1\xae\xeb:.XH\xa6\xc6\xce\xb5y1\xbe\xc6q\x8c\xd6 \xae\xa9\xd0\xd3$\xb6[\xbab\x99:\xdbz\xb0\x80BkK\xbc%\x19e\x06\xfbP\xa6\xc9\x10\x19\xe3'\x1bd\\\xd1\xd5\xb4Aj"
    text:cGFzc3dvcmQ=
    password:password
    

    在这里插入图片描述
    参考文章:
    python3 RSA加解密
    Python加密与解密
    python 使用 with open() as 读写文件

    展开全文
  • python rsa 加密解密

    2020-12-23 13:55:03
    仔细想了一下RSA加密解密过程,确定有二端,一端为:加密端,一端为解密端,一般不在同一台机器。在这里,我只模拟了保存在文件,然后再读出来;关于怎以通过网络传输,也是大同小异。 用RSA加密后的密文,是无法...
  • 本程序实现了rsa加密解密过程,演示了rsa算法的过程,用c实现的程序,对密码学实验很有帮助
  • RSA加密解密教程

    2014-12-25 15:39:45
    android开发的一rsa加解密的小例子,里面包含RSA加密解密教程demo及秘钥生成工具OpenSSL,详细讲解了rsa的加密解密的使用过程,对新手有一定的帮助,因为我就是新手,哇哈哈哈...
  • RSA加密解密

    2014-12-24 17:59:41
    RSA加密算法,利用mfc编写的界面,此程序能让我们更清楚的理解RSA加密过程
  • java RSA加密解密

    2019-10-01 22:20:24
    java RSA加密解密 该工具类中用到了BASE64,需要借助第三方类库:javabase64-1.3.1.jar注意:RSA加密明文最大长度117字节,解密要求密文最大长度为128字节,所以在加密和解密的过程中需要分块进行。RSA加密对明文...

    java RSA加密解密

     

    该工具类中用到了BASE64,需要借助第三方类库:javabase64-1.3.1.jar

    注意:
    RSA加密明文最大长度117字节,解密要求密文最大长度为128字节,所以在加密和解密的过程中需要分块进行。
    RSA加密对明文的长度是有限制的,如果加密数据过大会抛出如下
    异常:

    Exception in thread "main" javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes
        at com.sun.crypto.provider.RSACipher.a(DashoA13*..)
        at com.sun.crypto.provider.RSACipher.engineDoFinal(DashoA13*..)
        at javax.crypto.Cipher.doFinal(DashoA13*..)



    RSAUtils.java

    package security;

    import java.io.ByteArrayOutputStream;
    import java.security.Key;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.Signature;
    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;

    /**
     * <p>
     * RSA公钥/私钥/签名工具包
     * </p>
     * <p>
     * 罗纳德·李维斯特(Ron [R]ivest)、阿迪·萨莫尔(Adi [S]hamir)和伦纳德·阿德曼(Leonard [A]dleman)
     * </p>
     * <p>
     * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
     * 由于非对称加密速度极其缓慢,一般文件不使用它来加密而是使用对称加密,<br/>
     * 非对称加密算法可以用来对对称加密的密钥加密,这样保证密钥的安全也就保证了数据的安全
     * </p>
     * 
     * @author IceWee
     * @date 2012-4-26
     * @version 1.0
     */
    public class RSAUtils {

        /**
         * 加密算法RSA
         */
        public static final String KEY_ALGORITHM = "RSA";
        
        /**
         * 签名算法
         */
        public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

        /**
         * 获取公钥的key
         */
        private static final String PUBLIC_KEY = "RSAPublicKey";
        
        /**
         * 获取私钥的key
         */
        private static final String PRIVATE_KEY = "RSAPrivateKey";
        
        /**
         * RSA最大加密明文大小
         */
        private static final int MAX_ENCRYPT_BLOCK = 117;
        
        /**
         * RSA最大解密密文大小
         */
        private static final int MAX_DECRYPT_BLOCK = 128;

        /**
         * <p>
         * 生成密钥对(公钥和私钥)
         * </p>
         * 
         * @return
         * @throws Exception
         */
        public static Map<String, Object> genKeyPair() throws Exception {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            keyPairGen.initialize(1024);
            KeyPair keyPair = keyPairGen.generateKeyPair();
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            Map<String, Object> keyMap = new HashMap<String, Object>(2);
            keyMap.put(PUBLIC_KEY, publicKey);
            keyMap.put(PRIVATE_KEY, privateKey);
            return keyMap;
        }
        
        /**
         * <p>
         * 用私钥对信息生成数字签名
         * </p>
         * 
         * @param data 已加密数据
         * @param privateKey 私钥(BASE64编码)
         * 
         * @return
         * @throws Exception
         */
        public static String sign(byte[] data, String privateKey) throws Exception {
            byte[] keyBytes = Base64Utils.decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initSign(privateK);
            signature.update(data);
            return Base64Utils.encode(signature.sign());
        }

        /**
         * <p>
         * 校验数字签名
         * </p>
         * 
         * @param data 已加密数据
         * @param publicKey 公钥(BASE64编码)
         * @param sign 数字签名
         * 
         * @return
         * @throws Exception
         * 
         */
        public static boolean verify(byte[] data, String publicKey, String sign)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(publicKey);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PublicKey publicK = keyFactory.generatePublic(keySpec);
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initVerify(publicK);
            signature.update(data);
            return signature.verify(Base64Utils.decode(sign));
        }

        /**
         * <P>
         * 私钥解密
         * </p>
         * 
         * @param encryptedData 已加密数据
         * @param privateKey 私钥(BASE64编码)
         * @return
         * @throws Exception
         */
        public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateK);
            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                    cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return decryptedData;
        }

        /**
         * <p>
         * 公钥解密
         * </p>
         * 
         * @param encryptedData 已加密数据
         * @param publicKey 公钥(BASE64编码)
         * @return
         * @throws Exception
         */
        public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(publicKey);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key publicK = keyFactory.generatePublic(x509KeySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicK);
            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                    cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return decryptedData;
        }

        /**
         * <p>
         * 公钥加密
         * </p>
         * 
         * @param data 源数据
         * @param publicKey 公钥(BASE64编码)
         * @return
         * @throws Exception
         */
        public static byte[] encryptByPublicKey(byte[] data, String publicKey)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(publicKey);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key publicK = keyFactory.generatePublic(x509KeySpec);
            // 对数据加密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicK);
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] encryptedData = out.toByteArray();
            out.close();
            return encryptedData;
        }

        /**
         * <p>
         * 私钥加密
         * </p>
         * 
         * @param data 源数据
         * @param privateKey 私钥(BASE64编码)
         * @return
         * @throws Exception
         */
        public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateK);
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] encryptedData = out.toByteArray();
            out.close();
            return encryptedData;
        }

        /**
         * <p>
         * 获取私钥
         * </p>
         * 
         * @param keyMap 密钥对
         * @return
         * @throws Exception
         */
        public static String getPrivateKey(Map<String, Object> keyMap)
                throws Exception {
            Key key = (Key) keyMap.get(PRIVATE_KEY);
            return Base64Utils.encode(key.getEncoded());
        }

        /**
         * <p>
         * 获取公钥
         * </p>
         * 
         * @param keyMap 密钥对
         * @return
         * @throws Exception
         */
        public static String getPublicKey(Map<String, Object> keyMap)
                throws Exception {
            Key key = (Key) keyMap.get(PUBLIC_KEY);
            return Base64Utils.encode(key.getEncoded());
        }

    }



    Base64Utils.java

    package security;

    import 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;

    import it.sauronsoftware.base64.Base64;

    /**
     * <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.getBytes());
        }
        
        /**
         * <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();
        }
        
        
    }



    RSATester.java

    package security;

    import java.util.Map;

    public class RSATester {

        static String publicKey;
        static String privateKey;

        static {
            try {
                Map<String, Object> keyMap = RSAUtils.genKeyPair();
                publicKey = RSAUtils.getPublicKey(keyMap);
                privateKey = RSAUtils.getPrivateKey(keyMap);
                System.err.println("公钥: \n\r" + publicKey);
                System.err.println("私钥: \n\r" + privateKey);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        public static void main(String[] args) throws Exception {
            test();
            testSign();
        }

        static void test() throws Exception {
            System.err.println("公钥加密——私钥解密");
            String source = "这是一行没有任何意义的文字,你看完了等于没看,不是吗?";
            System.out.println("\r加密前文字:\r\n" + source);
            byte[] data = source.getBytes();
            byte[] encodedData = RSAUtils.encryptByPublicKey(data, publicKey);
            System.out.println("加密后文字:\r\n" + new String(encodedData));
            byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData, privateKey);
            String target = new String(decodedData);
            System.out.println("解密后文字: \r\n" + target);
        }

        static void testSign() throws Exception {
            System.err.println("私钥加密——公钥解密");
            String source = "这是一行测试RSA数字签名的无意义文字";
            System.out.println("原文字:\r\n" + source);
            byte[] data = source.getBytes();
            byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey);
            System.out.println("加密后:\r\n" + new String(encodedData));
            byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);
            String target = new String(decodedData);
            System.out.println("解密后: \r\n" + target);
            System.err.println("私钥签名——公钥验证签名");
            String sign = RSAUtils.sign(encodedData, privateKey);
            System.err.println("签名:\r" + sign);
            boolean status = RSAUtils.verify(encodedData, publicKey, sign);
            System.err.println("验证结果:\r" + status);
        }
        
    }

    转载于:https://www.cnblogs.com/HY198/p/5786382.html

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

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

    引言
            CTF密码学类题目中,RSA加密可谓是很重要且常见的加密类型,今天就总结下 RSA加密的原理及解密方法。


    RSA算法简介:

    • RSA加密算法是一种 非对称加密 算法,RSA算法相比别的算法思路非常清晰,但是想要破解的难度非常大。

    • RSA算法基于一个非常简单的数论事实:两个素数相乘得到一个大数很容易,但是由一个大数分解为两个素数相乘却非常难。

    1、什么是非对称加密算法:

    • 对称加密 算法使用同一个密钥进行加密解密的方式不同,非对称加密 算法是使用不同密钥进行加密和解密的算法,也称为公私钥加密。

    非对称加密算法实现机密信息交换的基本过程:

    • 甲方生成 一对密钥 并将其中的一把作为 公钥 向其它方公开,得到该公钥的乙方使用该密钥对机密信息进行加密后再发送给甲方,甲方再用自己保存的另一把 私钥 对加密后的信息进行解密。

    图解:
    在这里插入图片描述

    2、RSA 加密原理:

    了解了非对称加密算法的原理,我们再来说说 RSA 加密算法的基本流程。

    如图:在这里插入图片描述

    3、RSA加密算法过程详解:

    先来了解一下什么是 互质数:

    • 两个或多个整数的公因数只有1的非0自然数,则两个非0自然数叫做互质数。例如 2 和 3,公因数只有1,所以为互质数。
    1、找出质数 :

    随机找两个质数 p 和 q ,p 与 q 越大,越安全。

    2、计算公共模数:
     n = p * q 
    

    假设 p = 65 ,q = 71。计算他们的乘积 n = p * q = 4615 ,转化为二进制为 1001000000111,即该加密算法即为 13 位。位数越长,算法则越难被破解。实际应用中,RSA密钥一般是1024位,重要场合则为2048位。

    3、计算欧拉函数 φ(n):
    φ(n) = φ(p*q) = (p-1)(q-1)
    

    φ(n) 表示:在小于等于 n 的正整数之中,与 n 构成互质关系的数的个数。

    例:

    在 1 到 8 之中,与 8 形成互质关系的是1、3、5、7,所以 φ(n) = 4。

    计算公式(即欧拉函数)为

    前提:P 与 Q 均为质数

    φ(n) = φ(P*Q)= (P-1)(Q-1) 
    

    设:

    P = 65 ,Q = 71

    φ(n) = 64 * 70 = 4480 
    

    即有4480 个数与 n(4615)互质。

    4、计算公钥 e:
    1 < e < φ(n)
    

    要求:

    • e 的取值必须是整数
    • e 和 φ(n) 必须是互质数
    5、计算私钥 d:

    计算公式:

    e * d % m = 1  其中(φ(n) = m)
    

    即找一个整数 d,使得 (e * d ) % m = 1,等价于 e * d - 1 = y * m ( y 为整数)

    得到 d ,实质就是对下面二元一次方程求解:

    e * x - m * y = 1 e,m为已知量,求 x,y。

    这个方程可以用 扩展欧几里得算法 求解,此处就不详细介绍了,可以看这个了解下: 扩展欧几里得算法

    得到:

    • 公钥=(e,n)

    • 私钥=(d,n)

    对外,只暴露公钥。

    6、加密生成密文:

    C = MeM^e mod n

    C:密文 M:明文

    7、解密生成明文:

    M =CdC^d mod n

    C:密文 M:明文


    下面举一个完整的例子

    4、示例:

    1、找出质数 p 、q :

    p = 3  
    q = 11
    

    2、计算公共模数 n:

    n = p * q = 3 * 11 = 33
    n = 33
    

    3、计算欧拉函数 φ(n):

    φ(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 =3,3 和 φ(n) = 20 互为质数,满足条件。

    5、计算私钥 d:

    e * d % φ(n) = 1
    3 * d % 20 = 1   
    

    计算出 d = 7

    6、公钥加密:

    公式:C = MeM^e mod n

    随便拿一个数字,这里方便演示 取 M = 2

    C = 333^3 % 33 = 8

    " M = 3 " 经过RSA加密后变成了 " C = 8 "

    7、私钥解密:

    M =CdC^d mod n

    C = 8
    d = 7
    n = 33
    

    计算:

    M = 878^7 % 33

    解得: M = 2


    🆗,简单了解 RSA的基本原理之后,来看几个CTF中的RSA例题。

    5、例题:

    1、easy_RSA:

    在这里插入图片描述
    打开附件:
    在这里插入图片描述
    这题很简单,就是求参数d 的值,那么如何计算d 呢?也就是如何求 e * x - m * y =1 式子中的 x ?

    步骤:

    1、先计算欧拉函数:
    在这里插入图片描述
    得到 φ(n) = 2135733082216268400

    2、求 d:

    根据加密原理,解密的方法就是:把欧拉函数的值 +1,再除以17 * n(这里 n 先取1)
    在这里插入图片描述
    得到 d = 125631357777427553,尝试提交flag: cyberpeace{125631357777427553} 正确,看来 n 的值确实为 1 。( ̄▽ ̄)"

    提供一个求私钥脚本:

    #!/usr/bin/env python3
    # -*- coding:utf-8 -*-
    import gmpy2
    
    p = 473398607161
    q = 4511491
    e = 17
    
    m = (p-1)*(q-1)
    d = int(gmpy2.invert(e,m)) //invert: 求逆元,返回值是一个 mpz 对象
    print('私钥为:',d)
    

    运行结果(我的python出了点小问题):
    在这里插入图片描述
    得到 d = 125631357777427553

    2、i春秋 RSA :

    在这里插入图片描述
    打开附件:
    在这里插入图片描述
    可以看到题目给出了 n,e,c 三个值 ,求明文的值。

    首先先对 n 进行因式分解,使用在线网站:大数分解网站

    得到 p ,q :

    在这里插入图片描述

    p = 310935513029228809998830208036655366162721470228774287453148308675193510132489142448801010943658159980501154153084396100667001391643762749806500051502679498536716532334917842894939889468693960937309663256592497965458780801192062835123429808
    544757340971089756707788360038227894054989413747980167536893779923551227744017809301855984582408943622461942486239113822841696775958645014753081946441406022729616992302829930205076689399802050792392219242304302303180769915076199603301447453
    07022538024878444458717587446601559546292026245318907293584609320115374632235270795633933755350928537598242214216674496409625928797450473
    
    q = 310935513029228809998830208036655366162721470228774287453148308675193510132489142448801010943658159980501154153084396100667001391643762749806500051502679498536716532334917842894939889468693960937309663256592497965458780801192062835123429808
    544757340971089756707788360038227894054989413747980167536893779923551227744017809301855984582408943622461942486239113822841696775958645014753081946441406022729616992302829930205076689399802050792392219242304302303180769915076199603301447453
    07022538024878444458717587446601559546292026245318907293584609320115374632235270795633933755350928537598242214216674496409625928997877221
    

    2、相关参数都已得到,就可以编写脚本求明文信息了:

    #!/usr/bin/env python
    # coding:utf-8
    import gmpy2   
    
    p = gmpy2.mpz(31093551302922880999883020803665536616272147022877428745314830867519351013248914244880101094365815998050115415308439610066700139164376274980650005150267949853671653233491784289493988946869396093730966325659249796545878080119206283512342980854475734097108975670778836003822789405498941374798016753689377992355122774401780930185598458240894362246194248623911382284169677595864501475308194644140602272961699230282993020507668939980205079239221924230430230318076991507619960330144745307022538024878444458717587446601559546292026245318907293584609320115374632235270795633933755350928537598242214216674496409625928997877221)
    q = gmpy2.mpz(31093551302922880999883020803665536616272147022877428745314830867519351013248914244880101094365815998050115415308439610066700139164376274980650005150267949853671653233491784289493988946869396093730966325659249796545878080119206283512342980854475734097108975670778836003822789405498941374798016753689377992355122774401780930185598458240894362246194248623911382284169677595864501475308194644140602272961699230282993020507668939980205079239221924230430230318076991507619960330144745307022538024878444458717587446601559546292026245318907293584609320115374632235270795633933755350928537598242214216674496409625928797450473)
    e = gmpy2.mpz(65537)
    
    #计算私钥d
    m = (p - 1) * (q - 1)
    d = gmpy2.invert(e, m)
    print "private key:",d
    
    #求密文M
    c = gmpy2.mpz(168502910088858295634315070244377409556567637139736308082186369003227771936407321783557795624279162162305200436446903976385948677897665466290852769877562167487142385308027341639816401055081820497002018908896202860342391029082581621987305533097386652183849657065952062433988387640990383623264405525144003500286531262674315900537001845043225363148359766771033899680111076181672797077410584747509581932045540801777738548872747597899965366950827505529432483779821158152928899947837196391555666165486441878183288008753561108995715961920472927844877569855940505148843530998878113722830427807926679324241141182238903567682042410145345551889442158895157875798990903715105782682083886461661307063583447696168828687126956147955886493383805513557604179029050981678755054945607866353195793654108403939242723861651919152369923904002966873994811826391080318146260416978499377182540684409790357257490816203138499369634490897553227763563553981246891677613446390134477832143175248992161641698011195968792105201847976082322786623390242470226740685822218140263182024226228692159380557661591633072091945077334191987860262448385123599459647228562137369178069072804498049463136233856337817385977990145571042231795332995523988174895432819872832170029690848)
    print "明文:"
    M  =  pow(c,d,p*q)
    print '10进制: '+str(M)
    flag = str(hex(M))[2:]# 从第3位为往后截取
    print '16进制: '+flag
    print 'ASCII码: '+flag.decode('hex')
    

    注释:

    • gmpy2.mpz(x): 初始化一个大整数x
    • pow( x, y, z): 计算 xyx^y mod z

    得到 flag:
    在这里插入图片描述
    🆗,关与RSA的总结暂时就到这里了,以后发现好用的方法或解题技巧会接着更新。╰( ̄ω ̄o)

    展开全文
  • RSA 加密解密

    2019-12-18 16:24:02
    一、RSA加密简介  RSA加密是一种非对称加密。可以在不直接传递密钥的情况下,完成解密。这能够确保信息的安全性,避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密过程,分别称为公钥和私钥。...
  • 在项目中经常会使用到一些加密场合,恰好最近有用到RSA加密解密算法,以此篇文章记录一下。 RSA加密是一种非对称加密。可以在不直接传递密钥的情况下,完成解密。这能够确保信息的安全性,避免了直接传递密钥所造成...
  • 最近项目中对接口进行了rsa 加密。 写下过程以便复习公钥私钥一般是有后台给的,这里为了方便 自己生成一对秘钥生成公钥 私钥。终端中:生成原始 RSA私钥文件 private_key.pemopenssl genrsa -out private_key.pem ...
  • 原文:java RSA加密解密实现 该工具类中用到了BASE64,需要借助第三方类库:javabase64-1.3.1.jar 注意: RSA加密明文最大长度117字节(经过实际测试,最大长度为350),解密要求密文最大长度为128字节,所以在...
  • RSA加密解密方法

    2020-09-05 16:19:42
    一、RSA加密、签名区别  加密和签名都是为了安全性考虑,但略有不同。常有人问加密和签名是用私钥还是公钥?其实都是对加密和签名的作用有所混淆。简单的说,加密是为了防止信息被泄露,而签名是为了防止信息被...
  • golang实现RSA加密解密

    2019-06-24 20:03:42
    golang实现RSA加密解密 公钥加密过程 得到公钥 加密 //加密 func RsaEncryptData(filename string, src []byte)([]byte, error) { //获取公钥 pubKey, err := readRsaPubKey(filename) if err != nil { ...
  • java RSA 加密 解密

    2013-05-30 18:23:42
    java RSA加密解密 该工具类中用到了BASE64,需要借助第三方类库:javabase64-1.3.1.jar注意:RSA加密明文最大长度117字节,解密要求密文最大长度为128字节,所以在加密和解密的过程中需要分块进行。RSA加密对...
  • RSA算法原理——(3)RSA解密过程及公式论证

    万次阅读 多人点赞 2018-07-04 00:16:32
    上期(RSA简介及基础数论知识)为大家介绍了:互质、欧拉函数、欧拉定理、模反元素 这四个数论的知识点,而这四个知识点是理解RSA加密算法的基石,忘了的同学可以快速的过一遍。 一、目前常见加密算法简介 二、RSA...
  • Android RSA 加密解密Demo

    热门讨论 2013-08-27 14:23:27
    这个demo能帮助正在写RSA加密的朋友,一定能帮助你的 从生成密钥对到publicKey加密,privateKey解密得到数据,完整的过程
  • java RSA加密解密实现

    2019-07-11 17:23:11
    该工具类中用到了BASE64,需要借助第三方类库:...RSA加密明文最大长度117字节,解密要求密文最大长度为128字节,所以在加密和解密过程中需要分块进行。 RSA加密对明文的长度是有限制的,如果加密数据过大会抛出...
  • RSA加密解密算法

    千次阅读 2019-02-27 20:08:09
    1 引言 1.1 任务概要 本次课程设计即完成RSA算法签名验证。 1.1.1 任务要求 (1)产生两个奇数,判断是否是素数。...(5)给出辗转相除法求得解密用的参数d的演示过程,如图16演示。 (6)界面设计友...
  • 本文实例讲述了php的RSA加密解密算法原理与用法。分享给大家供大家参考,具体如下: 最近因为工作的需要,要倒腾支付宝支付相关的知识,因为支付宝应用了RSA加密机制,个人对此并不了解,所以在这里写下一篇总结。 1...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,237
精华内容 494
关键字:

rsa加密解密过程