精华内容
下载资源
问答
  • 公钥私钥
    2022-05-17 11:42:47

    很好的一篇文章,形象的解释了公钥私钥的交互

    【韭菜币读】用Emoji科普公钥与私钥的基本原理

    更多相关内容
  • 用java代码生成公钥私钥密钥对,公钥加密私钥解密,私钥加密公钥解密。直接导入idea,可直接运行。小编正在看区块链的多重加密,看到这儿了就写了一个demo,用于理解加解密。
  • 数据库密码的为了安全最后加密存放,这是一个RSA加密工具类。包含钥匙的生成和检测公钥私钥,具体看类说明,做Java或者Android可以直接拿来使用 非常方便!
  • JWT公钥私钥操作工具类
  • Java实现,公钥私钥通过计算生产,没有调用API,可以更直观的理解RSA公钥私钥的生成 资源中包含源码、jar包。不管是不想造轮子还是想要学习的同学都适用 也可以根据需要改造代码
  • 本文记录使用java生成公钥私钥,将公钥私钥转换成字符串,验证公钥私钥是否匹配。 验证公钥私钥是否匹配的思想:使用公钥对字符串进行加密,再使用私钥进行解密,若解密生成的字符串与原字符串一致,则说明公钥私钥...

    本文记录使用java生成公钥私钥,将公钥私钥转换成字符串,验证公钥私钥是否匹配。

    验证公钥私钥是否匹配的思想:使用公钥对字符串进行加密,再使用私钥进行解密,若解密生成的字符串与原字符串一致,则说明公钥私钥匹配。

    引入第三方依赖bouncycastle:

            <dependency>
                <groupId>org.bouncycastle</groupId>
                <artifactId>bcprov-jdk15on</artifactId>
                <version>1.68</version>
            </dependency>
    

    实现代码:

    import java.security.InvalidKeyException;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    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;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    
    import org.bouncycastle.jce.provider.BouncyCastleProvider;
    
    import java.util.Base64;
    import java.util.Random;
    
    /**
     * 该类用于生成公钥私钥,并且验证公钥私钥是否匹配
     * 使用方法:
     * 1.生成公钥私钥: 使用new RSAEncrypt()创建对象,之后调用get方法即可获取生成的公钥私钥(字符串)
     * 2.验证公钥私钥是否匹配: 调用静态方法verifyPublicAndPrivateKey(),传入公钥私钥字符串,返回boolean判断是否匹配
     */
    public class RSAEncrypt {
    
        private RSAPrivateKey privateKey;
        private RSAPublicKey publicKey;
    
        public RSAEncrypt() {
            genKeyPair();
        }
    
        /**
         * 获取私钥字符串
         *
         * @return 当前的私钥字符串
         */
        public String getPrivateKeyStr() {
            KeyFactory keyFactory = null;
            String privateKeyStr = null;
            try {
            	//将私钥对象转换为字符串
                keyFactory = KeyFactory.getInstance("RSA");
                PKCS8EncodedKeySpec keySpec = keyFactory.getKeySpec(privateKey, PKCS8EncodedKeySpec.class);
                byte[] buffer = keySpec.getEncoded();
                privateKeyStr = Base64.getEncoder().encodeToString(buffer);
            } catch (NoSuchAlgorithmException e) {
                System.err.println("无此算法");
            } catch (InvalidKeySpecException e) {
                System.err.println("私钥非法");
            }
            return privateKeyStr;
        }
    
        /**
         * 获取公钥字符串
         *
         * @return 当前的公钥字符串
         */
        public String getPublicKeyStr() {
            KeyFactory keyFactory = null;
            String publicKeyStr = null;
            try {
            	//将公钥对象转换为字符串
                keyFactory = KeyFactory.getInstance("RSA");
                X509EncodedKeySpec keySpec = keyFactory.getKeySpec(publicKey, X509EncodedKeySpec.class);
                byte[] buffer = keySpec.getEncoded();
                publicKeyStr = Base64.getEncoder().encodeToString(buffer);
            } catch (NoSuchAlgorithmException e) {
                System.err.println("无此算法");
            } catch (InvalidKeySpecException e) {
                System.err.println("公钥非法");
            }
            return publicKeyStr;
        }
    
        /**
         * 随机生成公钥-私钥
         */
        private void genKeyPair() {
            KeyPairGenerator keyPairGen = null;
            try {
                keyPairGen = KeyPairGenerator.getInstance("RSA");
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            keyPairGen.initialize(1024, new SecureRandom());
            KeyPair keyPair = keyPairGen.generateKeyPair();
            this.privateKey = (RSAPrivateKey) keyPair.getPrivate();
            this.publicKey = (RSAPublicKey) keyPair.getPublic();
        }
    
        /**
         * @param publicKeyStr  公钥
         * @param privateKeyStr 私钥
         * @return boolean值判断是否匹配
         */
        public static boolean verifyPublicAndPrivateKey(String publicKeyStr, String privateKeyStr) {
            RSAPublicKey publicKeyToVerify = null;
            RSAPrivateKey privateKeyToVerify = null;
            try {
                publicKeyToVerify = loadPublicKey(publicKeyStr);
            } catch (Exception e) {
                System.err.println("加载公钥失败-公钥非法");
                return false;
            }
            try {
                privateKeyToVerify = loadPrivateKey(privateKeyStr);
            } catch (Exception e) {
                System.err.println("加载私钥失败-私钥非法");
                return false;
            }
            if (publicKeyToVerify == null || privateKeyToVerify == null) {
                return false;
            }
            //生成随机数字符串用于验证公钥私钥是否匹配
            Random seed = new Random();
            int randomNum = seed.nextInt(1000) + 1;
            String randomStr = String.valueOf(randomNum);
    
            byte[] cipher = null;
            byte[] plainText = null;
            try {
                cipher = encrypt(publicKeyToVerify, randomStr.getBytes());
                plainText = decrypt(privateKeyToVerify, cipher);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
    
            String plainStr = new String(plainText);
            return plainStr.equals(randomStr);
        }
    
    
        /**
         * 从字符串中加载公钥
         *
         * @param publicKeyStr 公钥数据字符串
         * @throws Exception 加载公钥时产生的异常
         */
        private static RSAPublicKey loadPublicKey(String publicKeyStr) throws Exception {
            RSAPublicKey loadedPublicKey = null;
            try {
                byte[] buffer = Base64.getDecoder().decode(publicKeyStr);
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
                loadedPublicKey = (RSAPublicKey) keyFactory.generatePublic(keySpec);
            } catch (NoSuchAlgorithmException e) {
                throw new Exception(e);
            } catch (InvalidKeySpecException e) {
                throw new Exception(e);
            } catch (NullPointerException e) {
                throw new Exception(e);
            }
            return loadedPublicKey;
        }
    
        /**
         * 从字符串中加载私钥
         *
         * @param privateKeyStr 私钥数据字符串
         * @throws Exception 加载私钥时产生的异常
         */
        private static RSAPrivateKey loadPrivateKey(String privateKeyStr) throws Exception {
            RSAPrivateKey loadedPrivateKey = null;
            try {
                byte[] buffer = Base64.getDecoder().decode(privateKeyStr);
                PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                loadedPrivateKey = (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此算法");
            } catch (InvalidKeySpecException e) {
                throw new Exception("私钥非法");
            } catch (NullPointerException e) {
                throw new Exception("私钥数据为空");
            }
            return loadedPrivateKey;
        }
    
        /**
         * 加密过程
         *
         * @param publicKey     公钥
         * @param plainTextData 明文数据
         * @return 加密后的数据
         * @throws Exception 加密过程中的异常信息
         */
        private static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData) throws Exception {
            if (publicKey == null) {
                throw new Exception("加密公钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                cipher = Cipher.getInstance("RSA", new BouncyCastleProvider());
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                byte[] output = cipher.doFinal(plainTextData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此加密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("加密公钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("明文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("明文数据已损坏");
            }
        }
    
        /**
         * 解密过程
         *
         * @param privateKey 私钥
         * @param cipherData 密文数据
         * @return 明文
         * @throws Exception 解密过程中的异常信息
         */
        private static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData) throws Exception {
            if (privateKey == null) {
                throw new Exception("解密私钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                cipher = Cipher.getInstance("RSA", new BouncyCastleProvider());
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                byte[] output = cipher.doFinal(cipherData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此解密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("解密私钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("密文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("密文数据已损坏");
            }
        }
    
    
        public static void main(String[] args) {
            RSAEncrypt rsaEncrypt = new RSAEncrypt();
            System.out.println("公钥:" + rsaEncrypt.getPublicKeyStr());
            System.out.println("私钥:" + rsaEncrypt.getPrivateKeyStr());
            boolean res = RSAEncrypt.verifyPublicAndPrivateKey(rsaEncrypt.getPublicKeyStr(), rsaEncrypt.getPrivateKeyStr());
            System.out.println("是否匹配:" + res);
        }
    }
    

    运行结果:
    在这里插入图片描述
    参考文章:Java中使用OpenSSL生成的RSA公私钥进行数据加解密

    展开全文
  • 公钥私钥

    2020-05-18 14:01:34
    在【加密】这种场景下,公钥用来加密,私钥用来解密。 公钥的英文是public key,所以可以被别人知道,Bob用Alice的公钥对消息进行加密,并把加密之后的消息传回给Alice;私钥的英文是private key,Alice应该保存好...

    在【加密】这种场景下,公钥用来加密,私钥用来解密


    公钥的英文是public key,所以可以被别人知道,Bob用Alice的公钥对消息进行加密,并把加密之后的消息传回给Alice;私钥的英文是private key,Alice应该保存好与这个公钥相对应的私钥,不能被别人知道,当Alice收到Bob发来的加密过的消息后,通过手里的私钥对其进行解密。

    只有私钥可以解密,而公钥不可以,所以即使公钥被窃听者Eve知道也没有关系。

    公钥和私钥之间有非常严谨的数学关系,大概就是基于大质数不太好分解balabala,然后也有个非常严谨的公式可以加密解密balabala,好吧其实是我也不太懂,反正就是这个意思感受一下就好。


    好的,在理解了上述过程之后,我们来说说【签名】这个场景。

    签名是对上述过程的反向应用,即在此场景下,用私钥进行“加密”,而公钥进行“解密”,这种说法是使题主头晕的原因,所以更清晰的说法是:在此场景下,用私钥进行“签名”,用公钥进行“认证”

    因为私钥只有Alice自己知道,所以用私钥对消息进行签名后,只有与之对应的公钥才能对这个签过名的消息进行认证,而公钥又是任何人都可以获取的,所以通过这个过程可以知道该消息确实是属于Alice的。

    -------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    机构颁发的数字证书内容主要有两个:数字签名和服务器公钥

    这里的服务器公钥是什么呢,比如我注册了一个www.abc.com 这个域名,我想别人用https也能访问,就得去找个机构给我做一个签名证书,我需要自己用服务器生成一个公密钥,然后给这个机构做证书,这里的服务器公钥就是我们自己用服务器生成的

    证书签名机构如何生成证书

    在https请求中,我们会先请求目标服务器给我们他们的证书让我们验证一下,这个验证过程是怎么样的呢

    这样就能保证这个证书是我们所信任的权威机构颁发的

    --------------------------------------------------------------------------------------------------------------------------------------

    数字签名和数字证书原理

    1. 鲍勃有两把钥匙,一把是公钥,另一把是私钥。

    数字签名和数字证书使用原理

     

    2. 鲍勃把公钥送给他的朋友们----帕蒂、道格、苏珊----每人一把。

    数字签名和数字证书使用原理

     

    3. 苏珊要给鲍勃写一封保密的信。她写完后用鲍勃的公钥加密,就可以达到保密的效果。

    数字签名和数字证书使用原理

     

    4. 鲍勃收信后,用私钥解密,就看到了信件内容。这里要强调的是,只要鲍勃的私钥不泄露,这封信就是安全的,即使落在别人手里,也无法解密。

    数字签名和数字证书使用原理

     

    5. 鲍勃给苏珊回信,决定采用“数字签名”。他写完后先用Hash函数,生成信件的摘要(digest)。

    数字签名和数字证书使用原理

     

    6. 然后,鲍勃使用私钥,对这个摘要加密,生成“数字签名”(signature)。

    数字签名和数字证书使用原理

     

    7. 鲍勃将这个签名,附在信件下面,一起发给苏珊。

    数字签名和数字证书使用原理

     

    8. 苏珊收信后,取下数字签名,用鲍勃的公钥解密,得到信件的摘要。由此证明,这封信确实是鲍勃发出的。

    数字签名和数字证书使用原理

     

    9. 苏珊再对信件本身使用Hash函数,将得到的结果,与上一步得到的摘要进行对比。如果两者一致,就证明这封信未被修改过。

    数字签名和数字证书使用原理

     

    10. 复杂的情况出现了。道格想欺骗苏珊,他偷偷使用了苏珊的电脑,用自己的公钥换走了鲍勃的公钥。此时,苏珊实际拥有的是道格的公钥,但是还以为这是鲍勃的公钥。因此,道格就可以冒充鲍勃,用自己的私钥做成“数字签名”,写信给苏珊,让苏珊用假的鲍勃公钥进行解密。

    数字签名和数字证书使用原理

     

    11. 后来,苏珊感觉不对劲,发现自己无法确定公钥是否真的属于鲍勃。她想到了一个办法,要求鲍勃去找“证书中心”(certificate authority,简称CA),为公钥做认证。证书中心用自己的私钥,对鲍勃的公钥和一些相关信息一起加密,生成“数字证书”(Digital Certificate)。

    数字签名和数字证书使用原理

     

    12. 鲍勃拿到数字证书以后,就可以放心了。以后再给苏珊写信,只要在签名的同时,再附上数字证书就行了。

    数字签名和数字证书使用原理

     

    13. 苏珊收信后,用CA的公钥解开数字证书,就可以拿到鲍勃真实的公钥了,然后就能证明“数字签名”是否真的是鲍勃签的。

    数字签名和数字证书使用原理

    应用

    下面,我们看一个应用"数字证书"的实例:https协议。这个协议主要用于网页加密。

     

    1. 首先,客户端向服务器发出加密请求。

    数字签名和数字证书使用原理

     

    2. 服务器用自己的私钥加密网页以后,连同本身的数字证书,一起发送给客户端。

    数字签名和数字证书使用原理

     

    3. 客户端(浏览器)的“证书管理器”,有“受信任的根证书颁发机构”列表。客户端会根据这张列表,查看解开数字证书的公钥是否在列表之内。

    数字签名和数字证书使用原理

     

    4. 如果数字证书记载的网址,与你正在浏览的网址不一致,就说明这张证书可能被冒用,浏览器会发出警告。

    数字签名和数字证书使用原理

     

    5. 如果这张数字证书不是由受信任的机构颁发的,浏览器会发出另一种警告。

    数字签名和数字证书使用原理

     

    6. 如果数字证书是可靠的,客户端就可以使用证书中的服务器公钥,对信息进行加密,然后与服务器交换加密信息。

    数字签名和数字证书使用原理

    数字签名和数字证书使用原理

    展开全文
  • 数字证书原理,公钥私钥加密原理基础概念和原理,数字证书的管理与使用
  • 公钥 私钥 的理解

    千次阅读 2022-02-11 15:17:22
    公钥私钥是成对出现。 私钥可以生成公钥公钥无法生成私钥 私钥加密的内容,可以被公钥解密。 公钥加密的内容,可以被私钥解密。 举个例子 A 持有自己的私钥,A的私钥生成的公钥被其他人持有。 其他人用A的公钥...

    公钥和私钥是成对出现。

    私钥可以生成公钥,公钥无法生成私钥

    私钥加密的内容,可以被公钥解密。
    公钥加密的内容,可以被私钥解密。

    举个例子

    A 持有自己的私钥,A的私钥生成的公钥被其他人持有。
    其他人用A的公钥加密的内容,只有用A的私钥才可以解密。且A的私钥只有A自己知道。

    A用自己私钥加密的内容,别人持有A的公钥,可以解密出来,这样就证明这个东西是A发送的。

    总结

    公钥加密内容,私钥解密内容,保证内容的安全性。
    私钥加密签章,公钥解密签章,保证签章来自特定的人。

    展开全文
  • Linux服务器生成ssh公钥私钥
  • C# RSA加密、解密、加签、验签、支持JAVA格式公钥私钥、PEM格式公钥私钥、.NET格式公钥私钥 对应文章: http://blog.csdn.net/gzy11/article/details/54573973
  • Gitee 配置公钥私钥

    千次阅读 2021-05-13 15:04:26
    在对应路径下生产公钥私钥文件 /c/Users/用户名/.ssh/ |--id_rsa(私钥) |--id_rsa.pub(公钥) |--known_hosts(不用管) 公钥给别人,私钥不能泄露(非对称加密:对称加密) 对称加密: 对称加密采用了对称密码...
  • 本篇文章给大家带来的内容是关于php如何生成公钥私钥(代码),有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。//...
  • jwt 公钥 私钥 生成

    2021-07-26 14:04:20
    //生成私钥 openssl genrsa -out rsa_private_key.pem 1024 //转换私钥查看 ...//生成公钥 openssl rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem cat rsa_public_key.pem ...
  • [Java教程]java RSA 生成公钥私钥0 2016-10-14 17:00:15 /** * 引进的包都是Java自带的jar包 * 秘钥相关包 * base64 编解码 * 这里只用到了编码 */import java.security.Key;import java.security.KeyPair;import ...
  • OAuth2.0公钥私钥授权技术

    千次阅读 2020-08-21 17:51:59
    传统的资源服务授权流程如下: 客户端先去授权服务器申请令牌,申请令牌后,携带令牌...为了避免每次资源服务器反复校验令牌的合法性,我们可以利用公钥私钥完成对令牌的加密,如果加密解密成功,则表示令牌合法,
  • PHP RSA 生成公钥私钥 PSA2 加密解密
  • package org.springblade.common.utils; import org.apache.commons.codec.binary.Base64;... } } 工具类带有随机生成公钥私钥方法也可在网上在线生成 公钥私钥生成可以直接百度 ‘在线生成非对称加密公钥私钥
  • SSH 公钥私钥

    千次阅读 2020-12-08 13:48:35
    SSH 密钥对总是成双出现的,一把公钥,一把私钥公钥可以自由的放在您所需要连接的 SSH 服务器上,而私钥必须的保管好。 通常sshkey会默认生成在用户家目录下,所以查看家目录下是否存在.ssh 文件夹,以及是否存在...
  • package main import ( crypto/rand crypto/rsa crypto/x509 encoding/pem flag log os ) func main() { if err := GenerateRSAKey... //1 RSA生成私钥文件步骤 //--1生成RSA私钥对 var bits int flag.IntVa
  • 首先,所有人有一对钥(公钥私钥),公钥私钥都可以加密信息,同时可以互相解密对方的加密内容,所有人的私钥只有自己本人知道,公钥对外公开。 请想象以下场景: 小明要秘密的给小红写情书,要求是: 1,...
  • HTTPS的公钥私钥

    2021-10-21 22:25:14
    ...密钥:是一种参数,是明文转密文或...被公钥加密过的密文只能被私钥解密,过程如下: 明文 + 加密算法 + 公钥 => 密文, 密文 + 解密算法 + 私钥 => 明文 被私钥加密过的密文只能被公钥解密,过程如下: 明文
  • 公钥私钥原理讲解

    2020-05-10 13:46:17
    公钥私钥 在对称加密的时代,加密和解密用的是同一个密钥,这个密钥既用于加密,又用于解密。这样做有一个明显的缺点,如果两个人之间传输文件,两个人都要知道密钥,如果是三个人呢,五个人呢?于是就产生了非对称...
  • RSA生成公钥私钥

    2020-11-13 15:05:12
    { // KeyPairGenerator类用于生成公钥私钥对,基于RSA算法生成对象 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA"); // 初始化密钥对生成器,密钥大小为96-1024位 keyPairGen.initialize...
  • 公钥私钥使用说明

    2021-04-04 12:47:36
    文章目录1、资源服务授权流程1.1、传统授权流程1.2、公钥私钥授权流程2、公钥私钥原理3、生成私钥公钥4、导出公钥 1、资源服务授权流程 1.1、传统授权流程 资源服务器授权流程如上图,客户端先去授权服务器申请令牌...
  • 公钥来加密文件 —》 发给私钥持有者,私钥持有者用私钥来解密 --》 可以看到文本信息 私钥持有者用私钥来签名文件 —》文件发给公钥持有者 —》公钥持有者用公钥来验证签名,这样既可以知道这个文件是谁发送的 ...
  • 公钥私钥与证书

    2021-01-26 23:36:23
    公钥私钥证书 在客户端服务器的场景下,服务器拥有公钥和私钥,在加密的场景下,客户端通过使用公钥加密与服务端通信,服务端收到之后使用私钥解密。 数字签名:服务端发送给客户端之前,对消息内容使用Hash,生成...
  • 公钥私钥与数字签名

    2020-11-11 16:46:13
    首先给大家科普一下什么是公钥私钥: 公钥是与私钥算法一起使用的密钥对的非秘密一半。公钥通常用于加密会话密钥、验证数字签名,或加密可以用相应的私钥解密的数据。公钥和私钥是通过一种算法得到的一个密钥对(即...
  • 命令: ssh-keygen -t rsa -b 4096 -C "your_email@example.com" 生成两个文件 一个id_rsa,一个id_rsa.pub,前者给为私钥,后者为公钥
  • Git安装完之后,需做最后一步配置。...2、执行生成公钥私钥的命令:ssh-keygen -t rsa 并按回车3下(为什么按三下,是因为有提示你是否需要设置密码,如果设置了每次使用Git都会用到密码,一般都是直接不写为空,直.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 157,412
精华内容 62,964
关键字:

公钥私钥