公钥,私钥和数字签名这样最好理解

公钥,私钥和数字签名这样最好理解


转载地址:

公钥加密

  • 假设一下,我找了两个数字,一个是1,一个是2。我喜欢2这个数字,就保留起来,不告诉你们(私钥),然后我告诉大家,1是我的公钥。

  • 我有一个文件,不能让别人看,我就用1加密了。别人找到了这个文件,但是他不知道2就是解密的私钥啊,所以他解不开,只有我可以用 数字2,就是我的私钥,来解密。这样我就可以保护数据了。

  • 我的好朋友x用我的公钥1加密了字符a,加密后成了b,放在网上。别人偷到了这个文件,但是别人解不开,因为别人不知道2就是我的私钥, 只有我才能解密,解密后就得到a。这样,我们就可以传送加密的数据了。

私钥签名

  • 如果我用私钥加密一段数据(当然只有我可以用私钥加密,因为只有我知道2是我的私钥),结果所有的人都看到我的内容了,因为他们都知 道我的公钥是1,那么这种加密有什么用处呢?

  • 但是我的好朋友x说有人冒充我给他发信。怎么办呢?我把我要发的信,内容是c,用我的私钥2,加密,加密后的内容是d,发给x,再告诉他 解密看是不是c。他用我的公钥1解密,发现果然是c。 这个时候,他会想到,能够用我的公钥解密的数据,必然是用我的私钥加的密。只有我知道我得私钥,因此他就可以确认确实是我发的东西。 这样我们就能确认发送方身份了。这个过程叫做数字签名。当然具体的过程要稍微复杂一些。用私钥来加密数据,用途就是数字签名

  • 总结:公钥和私钥是成对的,它们互相解密。
    公钥加密,私钥解密。
    私钥数字签名,公钥验证。

  • 举例

    • 比如有两个用户Alice和Bob,Alice想把一段明文通过双钥加密的技术发送给Bob,Bob有一对公钥和私钥,那么加密解密的过程如下:

    • Bob将他的公开密钥传送给Alice。

    • Alice用Bob的公开密钥加密她的消息,然后传送给Bob。

    • Bob用他的私人密钥解密Alice的消息。

    • 上面的过程可以用下图表示,Alice使用Bob的公钥进行加密,Bob用自己的私钥进行解密。

      • 在这里插入图片描述

      • 例子和图出自《网络安全基础 应用与标准第二版》

RSA算法

  • RSA公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在(美国麻省理工学院)开发的。RSA取名来自开发他们三者的名字。RSA是目前最有影响力的公钥加密算法,它能够抵抗到目前为止已知的所有密码攻击,已被ISO推荐为公钥数据加密标准。RSA算法基于一个十分简单的数论事实:将两个大素数相乘十分容易,但那时想要对其乘积进行因式分解却极其困难,因此可以将乘积公开作为加密密钥。

  • 在这里插入图片描述

  • package com.jiuwei.base.client.suningPay;
    
    import com.sun.org.apache.xml.internal.security.utils.Base64;
    
    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.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;
    
    
    public class RSACoder {
        //非对称密钥算法
        public static final String KEY_ALGORITHM="RSA";
        /**
         * 密钥长度,DH算法的默认密钥长度是1024
         * 密钥长度必须是64的倍数,在512到65536位之间
         * */
        private static final int KEY_SIZE=512;
        //公钥
        private static final String PUBLIC_KEY="xiaoxiaorenzhe";
    
        //私钥
        private static final String PRIVATE_KEY="dadapangzi";
    
        /**
         * 初始化密钥对
         * @return Map 甲方密钥的Map
         * */
        public static Map<String,Object> initKey() throws Exception{
            //实例化密钥生成器
            KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance(KEY_ALGORITHM);
            //初始化密钥生成器
            keyPairGenerator.initialize(KEY_SIZE);
            //生成密钥对
            KeyPair keyPair=keyPairGenerator.generateKeyPair();
            //甲方公钥
            RSAPublicKey publicKey=(RSAPublicKey) keyPair.getPublic();
            System.out.println("系数:"+publicKey.getModulus()+"  加密指数:"+publicKey.getPublicExponent());
            //甲方私钥
            RSAPrivateKey privateKey=(RSAPrivateKey) keyPair.getPrivate();
            System.out.println("系数:"+privateKey.getModulus()+"解密指数:"+privateKey.getPrivateExponent());
            //将密钥存储在map中
            Map<String,Object> keyMap=new HashMap<String,Object>();
            keyMap.put(PUBLIC_KEY, publicKey);
            keyMap.put(PRIVATE_KEY, privateKey);
            return keyMap;
    
        }
    
        /**
         * 私钥加密
         * @param data 待加密数据
         * @param key 密钥
         * @return byte[] 加密数据
         * */
        public static byte[] encryptByPrivateKey(byte[] data,byte[] key) throws Exception{
    
            //取得私钥
            PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);
            KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
            //生成私钥
            PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);
            //数据加密
            Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            return cipher.doFinal(data);
        }
    
        /**
         * 公钥加密
         * @param data 待加密数据
         * @param key 密钥
         * @return byte[] 加密数据
         * */
        public static byte[] encryptByPublicKey(byte[] data,byte[] key) throws Exception{
    
            //实例化密钥工厂
            KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
            //初始化公钥
            //密钥材料转换
            X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);
            //产生公钥
            PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);
    
            //数据加密
            Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, pubKey);
            return cipher.doFinal(data);
        }
        /**
         * 私钥解密
         * @param data 待解密数据
         * @param key 密钥
         * @return byte[] 解密数据
         * */
        public static byte[] decryptByPrivateKey(byte[] data,byte[] key) throws Exception{
            //取得私钥
            PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);
            KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
            //生成私钥
            PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);
            //数据解密
            Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return cipher.doFinal(data);
        }
    
        /**
         * 公钥解密
         * @param data 待解密数据
         * @param key 密钥
         * @return byte[] 解密数据
         * */
        public static byte[] decryptByPublicKey(byte[] data,byte[] key) throws Exception{
    
            //实例化密钥工厂
            KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
            //初始化公钥
            //密钥材料转换
            X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);
            //产生公钥
            PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);
            //数据解密
            Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, pubKey);
            return cipher.doFinal(data);
        }
    
        /**
         * 取得私钥
         * @param keyMap 密钥map
         * @return byte[] 私钥
         * */
        public static byte[] getPrivateKey(Map<String,Object> keyMap){
            Key key=(Key)keyMap.get(PRIVATE_KEY);
            return key.getEncoded();
        }
        /**
         * 取得公钥
         * @param keyMap 密钥map
         * @return byte[] 公钥
         * */
        public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception{
            Key key=(Key) keyMap.get(PUBLIC_KEY);
            return key.getEncoded();
        }
        /**
         * @param args
         * @throws Exception
         */
        public static void main(String[] args) throws Exception {
            //初始化密钥
            //生成密钥对
            Map<String,Object> keyMap=RSACoder.initKey();
            //公钥
            byte[] publicKey=RSACoder.getPublicKey(keyMap);
            //byte[] publicKey = b;
            //私钥
            byte[] privateKey=RSACoder.getPrivateKey(keyMap);
            System.out.println("公钥:"+Base64.encode(publicKey));
            System.out.println("私钥:"+Base64.encode(privateKey));
    
            System.out.println("================密钥对构造完毕,甲方将公钥公布给乙方,开始进行加密数据的传输=============");
            String str="aattaggcctegthththfef/aat.mp4";
            System.out.println("===========甲方向乙方发送加密数据==============");
            System.out.println("原文:"+str);
            //甲方进行数据的加密
            byte[] code1=RSACoder.encryptByPublicKey(str.getBytes(), publicKey);
            System.out.println("甲方 使用乙方公钥加密后的数据:"+Base64.encode(code1));
            System.out.println("===========乙方使用甲方提供的公钥对数据进行解密==============");
            //乙方进行数据的解密
            //byte[] decode1=RSACoder.decryptByPublicKey(code1, publicKey);
            byte[] decode1=RSACoder.decryptByPrivateKey(code1, privateKey);
            System.out.println("乙方解密后的数据:"+new String(decode1)+"");
    
            System.out.println("===========反向进行操作,乙方向甲方发送数据==============");
    
            str="乙方向甲方发送数据RSA算法";
    
            System.out.println("原文:"+str);
    
            //乙方使用公钥对数据进行加密
            byte[] code2=RSACoder.encryptByPublicKey(str.getBytes(), publicKey);
            System.out.println("===========乙方使用公钥对数据进行加密==============");
            System.out.println("加密后的数据:"+Base64.encode(code2));
    
            System.out.println("=============乙方将数据传送给甲方======================");
            System.out.println("===========甲方使用私钥对数据进行解密==============");
    
            //甲方使用私钥对数据进行解密
            byte[] decode2=RSACoder.decryptByPrivateKey(code2, privateKey);
    
            System.out.println("甲方解密后的数据:"+new String(decode2));
    
    
        }  
    }
    
    
    
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值