精华内容
下载资源
问答
  • RSA算法实现

    2018-05-03 20:15:56
    利用MFC实现RSA算法,其中包括: 用MFC实现的简洁界面; 大素数生成算法生成大素数;
  • rsa算法实现

    2013-12-13 15:31:17
    rsa算法 openssl实现 C语言 gcc -o HelloPlus HelloPlus.c -lcrypto
  • PythonRSA Python 3 RSA算法实现 用法 生成ssh公钥和私钥在./keys/key.pub和./keys/key文件中生成2048位密钥的./keys/key.pub python3 rsa.py generate-key -l 2048 -o ./keys/key
  • AES和RSA算法实现

    2012-01-17 03:43:03
    AES和RSA算法实现 一种基于AES和RSA算法的数据加密方案及实现
  • 随机密码 模拟没有加密的简单RSA算法实现随机密码
  • 信息安全RSA算法实现 C语言 可以运行
  • rsa算法实现系统

    2019-01-06 00:37:13
    里面包括十几个系统,实现rsa的加解密和数字签名,文件和消息都可以加解密,有些系统实现了socket传输,模拟客户端和服务端的模式,可以实现聊天的信息加解密,还有一些rsa系统的论文
  • RSA算法实现代码有界面,亲自调试过,无错误
  • Java加密算法笔记--RSA算法实现 import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.N...
        

    Java加密算法笔记--RSA算法实现

    import java.security.Key;
    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.Signature;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.Base64;
    import java.util.HashMap;
    import java.util.Map;
    
    import javax.crypto.Cipher;
    
    /**
     * 1、公钥加密,私钥解密用于信息加密
     * 2、私钥加密,公钥解密用于数字签名
     */
    public class RSA {
        /**
         * 测试方法
         */
        public static void main(String[] args) {
    //        Map<String, Object> map = new HashMap<String, Object>();
    //        map = RSA.init();
    //        System.out.println("公钥:"+RSA.getPublicKey(map));
    //        System.out.println("私钥:"+RSA.getPrivateKey(map));
            //由前四行代码获得公、私密钥
            String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCLNbmKl9/gLn7Bef/xtUkshC1WyrLZLRpXCcFYR1gQi0isWsZBTicC4efBOkkNG3r+1ue0gvtuU/tjREFGf4Y7HaKHGb5tNCOlMNeNjM5YLRwLFqrUSsQyD4rj4eua1ltearr24R0HilnTvnQm6Z/UY0s21vdOUFQBPY0GNAa+0wIDAQAB";
            String privateKey = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIs1uYqX3+AufsF5//G1SSyELVbKstktGlcJwVhHWBCLSKxaxkFOJwLh58E6SQ0bev7W57SC+25T+2NEQUZ/hjsdoocZvm00I6Uw142MzlgtHAsWqtRKxDIPiuPh65rWW15quvbhHQeKWdO+dCbpn9RjSzbW905QVAE9jQY0Br7TAgMBAAECgYBcYhbzpr5no/Nyqmf0G/6nkEAWbQYrogbs5AhvcUk8EXL1DnirNhYlj42hafC4xhflrvCtlo8NNKaLxewbwN1uuzG8A2jd+ROEXlx5HDh2ZluhtHzL/SmNcJXo684xAl2pCNVBjDcW48PcIBijke/sTVHTDsDCukLKDPUOM/mKIQJBAL96k4+jBscazsJiuZ6C3RFDVtRRDpf1dMgLgxcx63bAXkA2Arau0J49IAYmSVJoDXqDoJKWdXJVh9vHSkhN/48CQQC6Hk1/G0Y0nOylf6NOp0oMgc0A+etnwxHKqwtctPKjEYcJx2fzALzTtCoySLYXX7gLnPIQXpQBTUysG5skBKp9AkEAiSQm6fqu0Q4fRlRlc+VwpnufhgPkOuw/z0OHiaZkajJPjxfgC63bl2paNG1ZmJ8UAEqkSDlhNxmRa9UqG+1ZewJASaQxz6gwCCNLM1SkfjuM/hPh1JAOh9jUUleJQF5MXx9RSho/VBQnorB3vbutaOQzw0yPLtDtSPKX8sVdhkveVQJAIDsJP5X8Tey6zXTUISor7PF0TSiKdE4k0IwKoy9y8HmQ+AU8+xyr/iOt5lvaGxKlBK8N/7yCw5H4qHnJaHT+Bg==";
            
            String str = "你好goldlone, RSA!";
            // 公钥加密,私钥解密
            String enStr1 = RSA.encryptByPublic(str, publicKey);
            System.out.println("公钥加密后:"+enStr1);
            String deStr1 = RSA.decryptByPrivate(enStr1, privateKey);
            System.out.println("私钥解密后:"+deStr1);
            // 私钥加密,公钥解密
            String enStr2 = RSA.encryptByPrivate(str, privateKey);
            System.out.println("私钥加密后:"+enStr2);
            String deStr2 = RSA.decryptByPublic(enStr2, publicKey);
            System.out.println("公钥解密后:"+deStr2);
            // 产生签名  
            String sign = sign(enStr2, privateKey);
            System.out.println("签名:"+sign);
            // 验证签名 
            boolean status = verify(enStr2, publicKey, sign);
            System.out.println("状态:"+status);
            
        }
        
        //定义加密方式
        public static final String KEY_RSA = "RSA";
        //定义公钥关键词
        public static final String KEY_RSA_PUBLICKEY = "RSAPublicKey";
        //定义私钥关键词
        public static final String KEY_RSA_PRIVATEKEY = "RSAPrivateKey";
        //定义签名算法
        private final static String KEY_RSA_SIGNATURE = "MD5withRSA";
        
        /**
         * 生成公私密钥对
         */
        public static Map<String, Object> init() {  
            Map<String, Object> map = null;
            try {
                KeyPairGenerator generator = KeyPairGenerator.getInstance(KEY_RSA);
                //设置密钥对的bit数,越大越安全,但速度减慢,一般使用512或1024
                generator.initialize(1024);
                KeyPair keyPair = generator.generateKeyPair();
                // 获取公钥  
                RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
                // 获取私钥  
                RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
                // 将密钥对封装为Map
                map = new HashMap<String, Object>();
                map.put(KEY_RSA_PUBLICKEY, publicKey);
                map.put(KEY_RSA_PRIVATEKEY, privateKey);
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            
            return map;
        }
        
         /** 
         * 获取Base64编码的公钥字符串
         */
        public static String getPublicKey(Map<String, Object> map) {
            String str = "";
            Key key = (Key) map.get(KEY_RSA_PUBLICKEY);
            str = encryptBase64(key.getEncoded());
            return str;  
        }
      
        /** 
         * 获取Base64编码的私钥字符串 
         */
        public static String getPrivateKey(Map<String, Object> map) {
            String str = "";
            Key key = (Key) map.get(KEY_RSA_PRIVATEKEY);
            str = encryptBase64(key.getEncoded());
            return str;
        }
      
        /** 
         * BASE64 解码 
         * @param key 需要Base64解码的字符串 
         * @return 字节数组 
         */  
        public static byte[] decryptBase64(String key) {
            return Base64.getDecoder().decode(key);
        }
      
        /** 
         * BASE64 编码 
         * @param key 需要Base64编码的字节数组 
         * @return 字符串 
         */  
        public static String encryptBase64(byte[] key) {
            return new String(Base64.getEncoder().encode(key));
        }
        
        /**
         * 公钥加密
         * @param encryptingStr
         * @param publicKey
         * @return
         */
        public static String encryptByPublic(String encryptingStr, String publicKeyStr){
            try {
                // 将公钥由字符串转为UTF-8格式的字节数组
                byte[] publicKeyBytes = decryptBase64(publicKeyStr);
                // 获得公钥  
                X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
                // 取得待加密数据
                byte[] data = encryptingStr.getBytes("UTF-8");
                KeyFactory factory;
                factory = KeyFactory.getInstance(KEY_RSA);
                PublicKey publicKey = factory.generatePublic(keySpec);
                // 对数据加密  
                Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                // 返回加密后由Base64编码的加密信息
                return encryptBase64(cipher.doFinal(data));
            } catch (Exception e) {
                e.printStackTrace();
            }
            
            return null;
        }
        
        /**
         * 私钥解密
         * @param encryptedStr
         * @param privateKey
         * @return
         */
        public static String decryptByPrivate(String encryptedStr, String privateKeyStr){
            try {
                // 对私钥解密  
                byte[] privateKeyBytes = decryptBase64(privateKeyStr);
                // 获得私钥 
                PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
                // 获得待解密数据
                byte[] data = decryptBase64(encryptedStr);
                KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
                PrivateKey privateKey = factory.generatePrivate(keySpec);
                // 对数据解密
                Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                // 返回UTF-8编码的解密信息
                return new String(cipher.doFinal(data), "UTF-8");
            } catch (Exception e) {
                e.printStackTrace();
            }
            
            return null;
        }
    
        /**
         * 私钥加密
         * @param encryptingStr
         * @param privateKey
         * @return
         */
        public static String encryptByPrivate(String encryptingStr, String privateKeyStr){
            try {
                byte[] privateKeyBytes = decryptBase64(privateKeyStr);
                // 获得私钥  
                PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes); 
                // 取得待加密数据
                byte[] data = encryptingStr.getBytes("UTF-8");
                KeyFactory factory = KeyFactory.getInstance(KEY_RSA);  
                PrivateKey privateKey = factory.generatePrivate(keySpec); 
                // 对数据加密 
                Cipher cipher = Cipher.getInstance(factory.getAlgorithm());  
                cipher.init(Cipher.ENCRYPT_MODE, privateKey);
                // 返回加密后由Base64编码的加密信息
                return encryptBase64(cipher.doFinal(data));  
            } catch (Exception e) {
                e.printStackTrace();  
            }
            
            return null;
        }
        
        /**
         * 公钥解密
         * @param encryptedStr
         * @param privateKey
         * @return
         */
        public static String decryptByPublic(String encryptedStr, String publicKeyStr){
            try {
                // 对公钥解密  
                byte[] publicKeyBytes = decryptBase64(publicKeyStr);
                // 取得公钥  
                X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
                // 取得待加密数据
                byte[] data = decryptBase64(encryptedStr);
                KeyFactory factory = KeyFactory.getInstance(KEY_RSA);  
                PublicKey publicKey = factory.generatePublic(keySpec);
                // 对数据解密  
                Cipher cipher = Cipher.getInstance(factory.getAlgorithm());  
                cipher.init(Cipher.DECRYPT_MODE, publicKey);
                // 返回UTF-8编码的解密信息
                return new String(cipher.doFinal(data), "UTF-8");  
            } catch (Exception e) {  
                e.printStackTrace();  
            }
            
            return null;
        }
        
        /**
         * 用私钥对加密数据进行签名
         * @param encryptedStr
         * @param privateKey
         * @return
         */
        public static String sign(String encryptedStr, String privateKey) {
            String str = "";  
            try {
                //将私钥加密数据字符串转换为字节数组
                byte[] data = encryptedStr.getBytes();
                // 解密由base64编码的私钥  
                byte[] bytes = decryptBase64(privateKey);  
                // 构造PKCS8EncodedKeySpec对象  
                PKCS8EncodedKeySpec pkcs = new PKCS8EncodedKeySpec(bytes);  
                // 指定的加密算法  
                KeyFactory factory = KeyFactory.getInstance(KEY_RSA);  
                // 取私钥对象  
                PrivateKey key = factory.generatePrivate(pkcs);  
                // 用私钥对信息生成数字签名  
                Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);  
                signature.initSign(key);  
                signature.update(data);  
                str = encryptBase64(signature.sign());  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            return str;  
        }
        
        /**
         * 校验数字签名 
         * @param encryptedStr
         * @param publicKey
         * @param sign
         * @return 校验成功返回true,失败返回false
         */
        public static boolean verify(String encryptedStr, String publicKey, String sign) {  
            boolean flag = false;
            try {
                //将私钥加密数据字符串转换为字节数组
                byte[] data = encryptedStr.getBytes();
                // 解密由base64编码的公钥  
                byte[] bytes = decryptBase64(publicKey);  
                // 构造X509EncodedKeySpec对象  
                X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);  
                // 指定的加密算法  
                KeyFactory factory = KeyFactory.getInstance(KEY_RSA);  
                // 取公钥对象  
                PublicKey key = factory.generatePublic(keySpec);  
                // 用公钥验证数字签名  
                Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);  
                signature.initVerify(key);  
                signature.update(data);  
                flag = signature.verify(decryptBase64(sign));
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            return flag;  
        }
    }

    运行结果:
    公钥加密后:TWWRIh4NIqslqWtT/1R4HbIrpXQRUU5Q4oJxa60+k11TINsxZVr9ox+aPZkjtlKRa5oaUqIsZysOwn4kxiDe6ielxUjQENz/lWc8pp5YpVR5INR3qP33aVXFHiqYHvkkXbhaDUlb4J0jYZDKLPgCUe3aG5vQN+DfdFcYnW2K9+8=
    私钥解密后:你好goldlone, RSA!
    私钥加密后:iND60pcTmbQqx0BcmfXtw+HY8XkCUFS9ifhRqL9IZpeimdRMlB3hPRK6m5ojmG+c836eX6+j1OYsmtp6ZfGbEoYCsiD1II+Xsx9vOfv42uf8yN3jlXXs4L5ybN65oB/LsuSsIvg1df72HU59mbPEQAqP5AHfnHImtRqN9DtE/Dg=
    公钥解密后:你好goldlone, RSA!
    签名:MGZDwjkFGs94MXrwcnhtcq97dnh5g0rGVcL0PuMgsOQfDYSpK129BlpoKCaHrqgXieg9ZfLaCFXaiQi74emAtGIPxODHl4DDiz7UEDABGZ5P+kQwHk0QTOVg5cBpwKkkdz3qka99ECaz1+ufAPX32wc4jcj1XcQPEj2gbnYsyPo=
    状态:true

    展开全文
  • javascript RSA 算法实现

    2010-09-17 15:24:39
    javascript 实现RSA 算法实现利用javascript进行简单的客户端数字签名
  • RSA算法实现(JAVA)

    2015-08-20 16:23:47
    RSA算法实现,eclipse环境下运行,包含测试用例
  • 简单的基于数字加解密的RSA算法实现。对于私钥的生成,加、解密的算法还有待改进。
  • rsa算法实现C++

    2013-05-19 15:37:15
    用C++编写的rsa算法,unsigned __int64 RandNumber::Random(unsigned __int64 n) { randSeed=multiplier * randSeed + adder; return randSeed % n; }static RandNumber g_Rnd;/* 模乘运算,返回值 x=a*b mod n */...
  • 这是一个基于RSA算法的课程设计,实现论文,还有软件成果
  • Node.js与PHP之间通过RSA算法实现签名验证做过web开发的同学都知道我们经常在接口间交互的时候为了防止数据伪造并 且保证安全性我们会采用签名的方式进行验证, 签名的算法我们一般选择RSA非对称加密算法。...

    Node.js与PHP之间通过RSA算法实现签名验证

    做过web开发的同学都知道我们经常在接口间交互的时候为了防止数据伪造并 且保证安全性我们会采用签名的方式进行验证, 签名的算法我们一般选择RSA非对称加密算法。想了解更多签名与RSA算法知识可以去查阅PKCS#1、PKCS#7相关资料。

    笔者在做利用Node.js做单点登录的时候涉及到了Node.js项目中产生的签名,然后需要到PHP项目中去验签,具体实现如下。

    首先准备RSA公钥和私钥,格式均为PEM

    openssl产生pem格式私钥

    openssl genrsa -out private_key.pem 1024
    

    openssl产生pem格式公钥

    openssl rsa -in private_key.pem -pubout -out public_key.pem
    

    Node.js中实现签名和验证

    默认签名后转换成hex格式

     var crypto = require('crypto');
     function  rsaSign(key, data,encode){
            var sign = crypto.createSign('RSA-SHA256');
            sign.update(data);
            var sig = sign.sign(key, encode||'hex');
            return sig;
        }
       function rsaVerify(pubKey, sig, data,encode){
            var verify = crypto.createVerify('RSA-SHA256');
            verify.update(data);
            return verify.verify(pubKey, sig, encode||'hex');
        }

    PHP中实现签名和验证

    对应的hex转码的验签

    function verifySign($pubKey,$data,$sign){
        $beginIndex=0;
        $signHexStr='';
        for(;;){
            if ($beginIndex>=strlen($sign)){
                break;
            }
            $charCode=substr($sign,$beginIndex,2);
            $signHexStr.=chr(hexdec($charCode));
            $beginIndex+=2;
        }
        return openssl_verify($data,$signHexStr,$pubKey,'sha256WithRSAEncryption');
    }

    Node.js中使用

    let signature=rsaSign(config.key.private,'plantext')
    console.log(signature)
    let r=rsaVerify(config.key.public,signature,'plantext')
    console.log(r)

    PHP中使用

    verifySign($key,'plantext',$sign); 

    关于如何在Node.js和PHP之前通过RSA算法实现签名验证就介绍到这里,还是比较简单的。

    展开全文
  • RSA算法实现(续)

    2017-04-30 18:31:05
    RSA算法C语言实现

    源代码

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <math.h>
    #define N 100000
    
    /*
     *该函数筛选出1000~100000内的素数并存储在数组num内
     *传入参数为整形数组,存储筛选出的素数
     *返回值为筛选出的素数个数
     */
    
    int prime_num(int num[N])
    {
        int len=0;
        int j,k,flag;
        for(j=1001;j<=99999;j+=2)
        {
            flag = 0;
            for(k=2;k<=(sqrt(j));k++)
            {
                if(j % k == 0)
                {
                     flag = 1;
                     break;
                }
                else
                    continue;
            }
            if(flag == 0)
                num[len++]=j;
            else
                continue;
        }
        return len;
    }
    
    /*
     *该函数随机在num数组内选取一个素数并返回
     *传入参数为筛选出的素数数组及数组长度
     */
    
    int random_num(int num[N],int len)
    {
        int x;
        x = rand()%len;
        return num[x];
    }
    
    /*
     *该函数为扩展欧几里得算法,传入四个参数分别对应:
     *数a,模f及两个临时变量
     *返回值为a的模反元素即在模f下a的乘法逆元
     */
    
    long long int gcd(long long int a,long long int b,long long int* x,long long int* y){
        if (b==0){
            *x=1;
            *y=0;
            return a;
        }
        long long int q = gcd(b,a%b,x,y);
        long long int t = *x;
        *x = *y;
        *y = t - (a/b)* *y;
        return q;
    }
    
    /*
     *该函数实现快速幂取模算法,主要用于加密和解密的实现
     *三个参数分别为底数、幂、模值
     *返回值为幂取模的结果
     */
    
    long long int Mod(long long int a,long long int b,long long int n)
    {
        long long int res=1;
        while(b>0)
        {
            if(b&1)
                res=res*a%n;
            b=b>>1;
            a=a*a%n;
        }
        return res;
    }
    
    int main()
    {
        long long int p,q,e;
        long long int f,n;
        long long int i=0,j=0;
        int k;
        char code[26] = "abcdefghijklmnopqrstuvwxyz";
        long long int code_en[26];
        //需要查看样例定值测试输出结果时,删去下方注释符号即可
        /*
        p = 54013;
        q = 47129;
        f =(p-1)*(q-1);
        n =p*q;
        e = 11743;
        */
        //需要查看样例定值测试输出结果时,从这里开始注释
        int len;
        int num[N];
        srand(time(0));
        len = prime_num(num);
        p = random_num(num,len);
        do{
            q = random_num(num,len);
        }while(p == q);
        f =(p-1)*(q-1);
        n =p*q;
        do{
            e = random_num(num,len);
        }while(p == e || q == e || e >= f);
        //需要查看样例定值测试输出结果时,到这里结束注释
        gcd(e,f,&i,&j);
        if (i < 0) i+=f;
        printf("p=%lld\nq=%lld\nf=(p-1)(q-1)=%lld\n",p,q,f);
        printf("n=p*q=%lld\ne=%lld\nd=%lld\n",n,e,i);
        printf("Source:\n");
        for(k=0;k<=25;k++)
        {
            printf("%c",code[k]);
        }
        printf("\nEncode:\n");
        for(k=0;k<=25;k++)
        {
            printf("%x ",Mod(code[k],e,n));
            code_en[k]=Mod(code[k],e,n);
        }
        printf("\nDecode:\n");
        for(k=0;k<=25;k++)
        {
            printf("%x ",Mod(code_en[k],i,n));
        }
        printf("\n\nDecryption:\n");
        for(k=0;k<=25;k++)
        {
            printf("%c",(char)Mod(code_en[k],i,n));
        }
        return 0;
    }
    

    输出示例
    代码中定值输出
    这里写图片描述

    总结

    • 实验中选取1000~100000内的素数作为参数,因为涉及素数的筛选,直接运行基本无明显时间延迟;而如果将范围扩大,如将素数范围扩大到六位数,即上限为1000000,此时直接运行程序,将会明显看到有近十秒的延迟之后,才会打印出相应参数等;若修改上限至更高,则运行时间会更长。
    • 实验中采用long long int变量声明,最大支持19位数,故理论上选取的素数最大支持9位数,方可保证相关数据不溢出;而实际的测试及输出过程中发现,若两素数都特别大的情况下,在快速幂取模的运算中,因算法设计问题,会出现数据溢出现象导致解码等错误,尝试使用C语言math库函数运算,仍出现该问题;可缩小数据范围保证不出错或参考下条。
    • 针对上述问题,查阅知若采用相关外部库进行大数运算,如openssl、GMP、Miracl等,则可以进行更多数位的运算。在实际的工业应用中,使用2048位进行加密,这些则需要采用库函数来实现。
    展开全文
  • 基于JDK的RSA算法实现数字签名

    千次阅读 2015-03-08 19:36:22
    数字签名借助RSA算法实现,由于RSA算法的特点是非对称类算法,同时将破解的风险转移到数学难题(分解公因数)上,使其难以破解。由于算法有公钥和私钥,私钥就是私有的,仅自己能够知道,公钥就是公开给别人的。那...

    数字签名借助RSA算法实现,由于RSA算法的特点是非对称类算法,同时将破解的风险转移到数学难题(分解公因数)上,使其难以破解。由于算法有公钥和私钥,私钥就是私有的,仅自己能够知道,公钥就是公开给别人的。那如果我用我的私钥加密然后你用我的公钥解密,这就能唯一确定这个东西我是发给你的。

            这是基于jdk的数字签名,  代码如下:

    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.Signature;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.InvalidKeySpecException;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;


    public class jdkRSA {
    private static String src="我爱你";
    public static void main(String[] args)
    {

       rsa();

    }
    public static void rsa(){
    try {
    /*
    * 初始化签名
    */
    KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("RSA");
    keyPairGenerator.initialize(512);
    KeyPair keyPair=keyPairGenerator.generateKeyPair();
    RSAPublicKey rsaPublicKey=(RSAPublicKey) keyPair.getPublic();
    RSAPrivateKey rsaPrivateKey=(RSAPrivateKey) keyPair.getPrivate();
    /*
    * 执行签名
    */
    PKCS8EncodedKeySpec pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
    KeyFactory keyFactory=KeyFactory.getInstance("RSA");
    PrivateKey privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);
    Signature signature=Signature.getInstance("MD5withRSA");
    signature.initSign(privateKey);
    signature.update(src.getBytes());
    byte[] result=signature.sign();
    System.out.println("jdk rsa sign:" + result.toString() );
    /*
    * 验证签名
    */
    X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded());
    keyFactory=KeyFactory.getInstance("RSA");
    PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
    signature=Signature.getInstance("MD5withRSA");
    signature.initVerify(publicKey);
    signature.update(src.getBytes());
    boolean bool=signature.verify(result);
    System.out.println("jdk rsa verify"+"  "+bool);
           } catch (Exception e) {

    e.printStackTrace();
    }
    }
    }

    结果如下:

    jdk rsa sign:[B@75786e64
    jdk rsa verify  true

    展开全文
  • RSA算法实现与蒙哥马利算法(转)

    千次阅读 2013-12-01 12:34:49
    RSA算法实现与蒙哥马利算法(转) 原理介绍 RSA 原理: 选取两个不同的大素数p、q,并计算N=p*q,选取小素数d,并计算e,使d*e % (p-1)(q-1)=1, 对于任意A 若B=A**d % N 则A=B**e % N 可见d、e形成...
  • 密码学中的RSA 算法的java代码实现,其中有模的重复平方计算法和中国剩余定理

空空如也

空空如也

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

rsa算法实现