java使用bountycastle验证rsa公钥和证书，使用bountycastle处理pem格式密钥

最新推荐文章于 2023-11-08 08:55:31 发布
原创 最新推荐文章于 2023-11-08 08:55:31 发布 · 2k 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #后端

java验证公钥和证书
验证签名
验证签名
项目需求：通过私钥签名，公钥验证判断公钥和私钥是否配对

下面代码是通过私钥（公钥）加密，公钥（私钥）解密，通过前后对比加密数据是否一致得出配对结果。与项目需求不一致，因此重新改动一些。

项目在加入验证签名之后会出现Signature length not correct错误，是由于在转换格式的过程中出现使用getBytes函数，使得签名长度发生改变导致。
修改Signature length not correct错误
错误原因

介绍一下编码格式

本节主要介绍密钥和证书中常见的编码规则 DER和由 DER 衍生出的密钥文件格式 PEM。

DER (Distinguished Encoding Rules)DER (Distinguished Encoding Rules)

DER 是用二进制DER编码的证书，DER格式常见于java语言

PEM格式是在DER格式的基础上采用base64编码得到，PEM is Base64-encoded DER。PEM格式是采用openssl生成密钥和证书的格式。
下面是经典的PEM格式

PEM = "-----BEGIN PUBLIC KEY-----" 
  encode_base64(decode_hex(DER)) 
   "-----END PUBLIC KEY-----"

公钥密码学标准 PKCS (Public Key Cryptography Standards) 和公钥基础设施 PKIX(Public-Key Infrastructure X.509) 等使用 ASN.1 的类型定义密钥和证书的格式和编码，以描述公私钥和证书属性。 需要注意，PKCS 虽然名字是公钥密码学标准，它其实也包括私钥格式标准。

PKCS#1 格式

使用openssl genrsa生成的密钥对即是PKCS#1格式

-----BEGIN RSA PRIVATE KEY-----
....
-----END RSA PRIVATE KEY-----
PKCS#8 格式
-----BEGIN PRIVATE KEY-----
....
-----END PRIVATE KEY-----
package cc.weno.util;

import org.apache.commons.codec.binary.Base64;
import org.apache.log4j.Logger;
import org.bouncycastle.asn1.ASN1Sequence;
import org.bouncycastle.asn1.pkcs.RSAPrivateKey;
import org.bouncycastle.asn1.pkcs.RSAPrivateKeyStructure;
import org.bouncycastle.crypto.params.RSAPrivateCrtKeyParameters;
import org.bouncycastle.crypto.util.PrivateKeyFactory;
import org.bouncycastle.util.io.pem.PemObject;
import org.bouncycastle.util.io.pem.PemReader;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.io.*;
import java.nio.charset.Charset;
import java.security.*;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * openssl 证书公钥私钥读取加密解密工具类，主要用于验证上传的openssl 生成的证书和私钥文件是否正确的问题
 *
 * @author yinliang 2018.12.13 add
 * 主要逻辑:
 * 1、根据私钥文件读取私钥
 * 2、根据公钥文件读取公钥
 * 3、根据证书文件读取公钥
 * 4、根据证书公钥加密字符串
 * 5、根据证书私钥解密字符串
 * 6、如果字符串经过证书公钥加密后，再根据证书私钥解密后能后还原，说明上传的证书和私钥是正确的
 */
public class OpensslUtils {
    private static final String DEFAULT_ENCODING = "UTF-8";

    private static final Charset DEFAULT_CHARSET = Charset.forName(DEFAULT_ENCODING);

    private static final String KEY_ALGORITHM = "RSA";
    /**
     * 默认是RSA/NONE/PKCS1Padding
     */
    private static final String CIPHER_ALGORITHM = "RSA/ECB/PKCS1Padding";

    /**
     * RSA密钥长度必须是64的倍数，在512~65536之间。默认是1024
     */
    private static final int KEY_SIZE = 1024;

    /**
     * RSA最大加密明文大小:明文长度(bytes) <= 密钥长度(bytes)-11
     */
    private static final int MAX_ENCRYPT_BLOCK = KEY_SIZE / 8 - 11;

    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = KEY_SIZE / 8;

    private static Logger logger = Logger.getLogger(OpensslUtils.class);
    /**
     * 利用开源的工具类解析openssl私钥，openssl私钥文件格式为pem，需要去除页眉页脚后才能被java读取
     *
     * @param file
     * @return
     */
    public static PrivateKey getPrivateKey(File file) {
        if (file == null) {
            return null;
        }
        PrivateKey privKey = null;
        PemReader pemReader = null;
        try {
            pemReader = new PemReader(new FileReader(file));
            PemObject pemObject = pemReader.readPemObject();
            byte[] pemContent = pemObject.getContent();
            //支持从PKCS#1或PKCS#8 格式的私钥文件中提取私钥
            if (pemObject.getType().endsWith("RSA PRIVATE KEY")) {
                // 取得私钥  for PKCS#1
                RSAPrivateKey asn1PrivKey = RSAPrivateKey.getInstance(pemContent);
                RSAPrivateKeySpec rsaPrivKeySpec = new RSAPrivateKeySpec(asn1PrivKey.getModulus(), asn1PrivKey.getPrivateExponent());
                KeyFactory keyFactory= KeyFactory.getInstance("RSA");
                privKey= keyFactory.generatePrivate(rsaPrivKeySpec);
            } else if (pemObject.getType().endsWith("PRIVATE KEY")) {
                //取得私钥 for PKCS#8
                PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(pemContent);
                KeyFactory kf = KeyFactory.getInstance("RSA");
                privKey = kf.generatePrivate(privKeySpec);
            }
        } catch (FileNotFoundException e) {
            logger.error("read private key fail,the reason is the file not exist");
            e.printStackTrace();
        } catch (IOException e) {
            logger.error("read private key fail,the reason is :"+e.getMessage());
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            logger.error("read private key fail,the reason is :"+e.getMessage());
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            logger.error("read private key fail,the reason is :"+e.getMessage());
            e.printStackTrace();
        }  finally {
            try {
                if (pemReader != null) {
                    pemReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return privKey;
    }

    /**
     * 利用java自带的方法读取openssl私钥,openssl私钥文件格式为pem，需要去除页眉页脚后，再进行base64位解码才能被java读取
     * 注意该方法有缺陷,只是简单的根据注释将页眉页脚去掉了,不是很完善,如果页眉页脚前面有空格和注释的情况的会有问题,保留此方法是为方便弄清楚openssl私钥解析原理
     *
     * @param file
     * @return
     */
    public static PrivateKey getPrivateKey1(File file) {
        if (file == null) {
            return null;
        }
        PrivateKey privKey = null;
        try {
            BufferedReader privateKey = new BufferedReader(new FileReader(
                    file));
            String line = "";
            String strPrivateKey = "";
            while ((line = privateKey.readLine()) != null) {
                if (line.contains("--")) {//过滤掉首尾页眉页脚
                    continue;
                }
                strPrivateKey += line;
            }
            privateKey.close();
            ;
            //使用base64位解码
            byte[] privKeyByte = Base64.decodeBase64(strPrivateKey);
            //私钥需要使用pkcs8格式编码
            PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(privKeyByte);
            KeyFactory kf = KeyFactory.getInstance("RSA");
            privKey = kf.generatePrivate(privKeySpec);
            return privKey;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
        return privKey;
    }


    /**
     * 从证书文件获取公钥
     *
     * @param file
     * @return
     * @throws CertificateException
     * @throws FileNotFoundException
     */
    public static PublicKey getPublicKeyFromCert(File file) {
        try {
            CertificateFactory cf = CertificateFactory.getInstance("X.509");
            FileInputStream in = new FileInputStream(file);
            Certificate crt = cf.generateCertificate(in);
            PublicKey publicKey = crt.getPublicKey();
            return publicKey;
        } catch (CertificateException e) {
            logger.error("read public key fail,the reason is :"+e.getMessage());
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            logger.error("read public key fail,the reason is the file not exist");
            e.printStackTrace();

        }
        return null;
    }

    /**
     * 从openssl公钥文件中读取公钥
     * @param file
     * @return
     */
    public static PublicKey getPublicKey(File file) {
        if (file == null) {
            return null;
        }
        PublicKey pubKey = null;
        PemReader pemReader = null;
        try {
            pemReader = new PemReader(new FileReader(file));
            PemObject pemObject = pemReader.readPemObject();
            byte[] pemContent = pemObject.getContent();
            //公钥需要使用x509格式编码
            X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(pemContent);
            KeyFactory kf = KeyFactory.getInstance("RSA");
            pubKey = kf.generatePublic(pubKeySpec);
            return pubKey;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        } catch (GeneralSecurityException e) {
            e.printStackTrace();
        } finally {
            try {
                if (pemReader != null) {
                    pemReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return pubKey;
    }



    /**
     * 加密
     *
     * @param key
     * @param plainBytes
     * @return
     */
    public static byte[] encrypt(PublicKey key, byte[] plainBytes) {

        ByteArrayOutputStream out = null;
        try {
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, key);

            int inputLen = plainBytes.length;
            if (inputLen <= MAX_ENCRYPT_BLOCK) {
                return cipher.doFinal(plainBytes);
            }
            out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 数据太长对数据分段加密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(plainBytes, offSet, MAX_ENCRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(plainBytes, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            return out.toByteArray();
        } catch (NoSuchAlgorithmException e) {
            logger.error("rencrypt fail,the reason is : no such decryption algorithm,"+e.getMessage());
            e.printStackTrace();
            return null;
        } catch (NoSuchPaddingException e) {
            logger.error("rencrypt fail,the reason is :"+e.getMessage());
            e.printStackTrace();
            return null;
        } catch (InvalidKeyException e) {
            logger.error("rencrypt fail,the reason is : decrypting the private key is illegal, please check,"+e.getMessage());
            e.printStackTrace();
            return null;
        } catch (IllegalBlockSizeException e) {
            logger.error("rencrypt fail,the reason is : Illegal ciphertext length, please check,"+e.getMessage());
            e.printStackTrace();
            return null;
        } catch (BadPaddingException e) {
            logger.error("rencrypt fail,the reason is : ciphertext data is corrupt, please check,"+e.getMessage());
            e.printStackTrace();
            return null;
        } finally {
            try {
                if (out != null) out.close();
            } catch (Exception e2) {
            }
        }
    }

    /**
     * 根据公钥加密字符串
     *
     * @param key
     * @param plainText 需要加密的字符串
     * @return
     */
    public static String encrypt(PublicKey key, String plainText) {
        byte[] encodeBytes = encrypt(key, plainText.getBytes(DEFAULT_CHARSET));
        return Base64.encodeBase64String(encodeBytes);
    }

    /**
     * 解密
     *
     * @param key
     * @param encodedText
     * @return
     */
    public static String decrypt(PrivateKey key, byte[] encodedText) {

        ByteArrayOutputStream out = null;
        try {
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, key);
            int inputLen = encodedText.length;

            if (inputLen <= MAX_DECRYPT_BLOCK) {
                return new String(cipher.doFinal(encodedText), DEFAULT_CHARSET);
            }

            out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                    cache = cipher.doFinal(encodedText, offSet, MAX_DECRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(encodedText, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            return new String(out.toByteArray(), DEFAULT_CHARSET);
        } catch (NoSuchAlgorithmException e) {
            logger.error("rencrypt fail,the reason is : no such decryption algorithm,"+e.getMessage());
            e.printStackTrace();
            return null;
        } catch (NoSuchPaddingException e) {
            logger.error("rencrypt fail,the reason is :"+e.getMessage());
            e.printStackTrace();
            return null;
        } catch (InvalidKeyException e) {
            logger.error("rencrypt fail,the reason is : decrypting the private key is illegal, please check,"+e.getMessage());
            e.printStackTrace();
            return null;
        } catch (IllegalBlockSizeException e) {
            logger.error("rencrypt fail,the reason is : Illegal ciphertext length, please check,"+e.getMessage());
            e.printStackTrace();
            return null;
        } catch (BadPaddingException e) {
            logger.error("rencrypt fail,the reason is : ciphertext data is corrupt, please check,"+e.getMessage());
            e.printStackTrace();
            return null;
        } finally {
            try {
                if (out != null) out.close();
            } catch (Exception e2) {
            }
        }
    }

    /**
     * 根据私钥解密加密过的字符串
     *
     * @param key
     * @param encodedText 加密过的字符串
     * @return 解密后的字符串
     */
    public static String decrypt(PrivateKey key, String encodedText) {
        byte[] bytes = Base64.decodeBase64(encodedText);
        return decrypt(key, bytes);
    }

    /**
     * 验证证书
     * @param cert
     * @return
     */
    public static String validateCert(File cert){
        if (cert == null) {
            return "证书CRT文件不能为空";
        }
        PublicKey publicKey = getPublicKeyFromCert(cert);
        if (publicKey == null) {
            return "无法读取证书公钥,证书CRT文件格式错误";
        }
        return null;
    }

    /**
     * 验证私钥
     * @param privateKey
     * @return
     */
    public static String validatePrivateKey( File privateKey){
        if (privateKey == null) {
            return "证书私钥不能为空";
        }
        PrivateKey privKey = getPrivateKey(privateKey);
        if (privKey == null) {
            return "无法读取证书私钥,证书私钥文件格式错误";
        }
        return null;
    }

    /**
     * 验证证书私钥是否匹配,如果不匹配返回错误消息
     * @param cert
     * @param privateKey
     * @return 错误消息
     */
    public static String validate(File cert, File privateKey) {
        String res = validateCert(cert);//验证证书
        if((res!=null)&&(res.length()>0)){
            return res;//返回错误消息
        }
        res = validatePrivateKey(privateKey);//验证私钥
        if((res!=null)&&(res.length()>0)){
            return res;//返回错误消息
        }
        PublicKey publicKey = getPublicKeyFromCert(cert);
        PrivateKey privKey = getPrivateKey(privateKey);
        String str = "你好";//测试字符串
        String encryptStr = OpensslUtils.encrypt(publicKey, str);//根据证书公钥对字符串进行加密
        String decryptStr = OpensslUtils.decrypt(privKey, encryptStr);//根据证书私钥对加密字符串进行解密
        System.out.println(decryptStr);
        if(!str.equals(decryptStr)){//字符串根据证书公钥加密，私钥解密后不能还原说明证书与私钥不匹配
            return "证书与私钥不匹配";
        }
        return "ok";
    }

    /**
     * 测试主方法
     *
     * @param args
     */
    public static void main(String[] args) {
        File privateKeyFile = new File("C:\\Users\\ASUS\\Desktop\\CA\\rootca.key");
//        PrivateKey privKey = OpensslUtils.getPrivateKey(privateKeyFile);
//        System.out.println("privKey1:" + privKey);
//        privKey = OpensslUtils.getPrivateKey1(privateKeyFile);
//        System.out.println("privKey2:" + privKey);
//        File publicKeyFile = new File("src/main/resources/test.public.key");
//        PublicKey publicKey = OpensslUtils.getPublicKey(publicKeyFile);
//        System.out.println("publicKey:" + publicKey);
        File certFile = new File("C:\\Users\\ASUS\\Desktop\\CA\\rootca.pem");
        //publicKey = OpensslUtils.getPublicKeyFromCert(certFile);
//        System.out.println("publicKey2:" + publicKey);
//        String str = "haha";
//        String encryptStr = OpensslUtils.encrypt(publicKey, str);
//        System.out.println("encryptStr:" + encryptStr);
//        String decryptStr = OpensslUtils.decrypt(privKey, encryptStr);
//        System.out.println("decryptStr:" + decryptStr);
        String validateResult = validate(certFile,privateKeyFile);
        System.out.println("validateResult:" + validateResult);
    }
}

下面是根据项目需求新增加的改动，通过私钥签名，公钥签名验证

public static boolean checkSign( String message, String sign, File cert )
    {
        boolean ret = false;


        {
            try {
                ret = OpensslUtils.verify( message, sign, getPublicKeyFromCert(cert));
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (SignatureException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return ret;
    }
    private static PublicKey getKey( File keyPath )
            throws NoSuchAlgorithmException, IOException, InvalidKeySpecException
    {
        final KeyFactory keyFactory = KeyFactory.getInstance( "RSA");
        final PemReader reader = new PemReader( new FileReader( keyPath ) );
        final byte[] pubKey = reader.readPemObject(  ).getContent(  );
        final X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec( pubKey );

        return keyFactory.generatePublic( publicKeySpec );
    }
    private static boolean verify( String message, String sign, PublicKey publicKey )
            throws NoSuchAlgorithmException, InvalidKeyException, SignatureException, UnsupportedEncodingException
    {
        final Signature sig = Signature.getInstance("MD5withRSA");
        sig.initVerify( publicKey );
        sig.update( message.getBytes("utf-8") );

        //final byte[] bytes = Base64Decoder.decode( URLDecoder.decode( sign, "utf-8") );
        byte[] signByte = Base64.decodeBase64(sign);
        return sig.verify(signByte );
    }
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64.decodeBase64(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance("MD5withRSA");
        signature.initSign(privateK);
        signature.update(data);
        return Base64.encodeBase64String(signature.sign());
    }
    /**
     * 测试主方法
     *
     * @param args
     */

    public static void main(String[] args) {
        File certFile = new File("C:\\Users\\ASUS\\Desktop\\CA\\client.pem");
        String str = "sdifhjksabdnkfbasdjhhh";
        File privateKeyFile = new File("C:\\Users\\ASUS\\Desktop\\CA\\client.key");
        PrivateKey privKey = getPrivateKey(privateKeyFile);
        String encryptStr = OpensslUtils.encrypt(privKey, str);
        String sign = null;

        {
            try {
                sign = OpensslUtils.sign(encryptStr.getBytes(StandardCharsets.UTF_8), Base64.encodeBase64String(privKey.getEncoded()));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        boolean bl = checkSign(encryptStr, sign, certFile);
        System.out.println(bl);
    }
Dorby .
关注
java验证openssl生成的ssl证书和私钥是否匹配
weixin_30871293的博客
12-13 1649
最近有一个需求上传ssl证书和私钥，但是上传之前需要验证ssl证书和私钥是否正确，其中的业务逻辑涉及到以下几点： 一、读取ssl证书，读取ssl证书公钥 要实现该功能比较简单，java里面有现成的api支持。 证书格式： -----BEGIN CERTIFICATE----- MIICYTCCAcoCCQCs45mePIbzRTANBgkqhk...
java利用bouncycastle生成国密x509证书并将证书以pem格式存入文件，附golang对生成证书的验证
qq_38026782的博客
09-06 9431
小白一枚，搞这个弄得心力交瘁，希望对你们有用… 参考了大牛的实现，https://github.com/ZZMarquis/gmhelper 感谢大牛的贡献，不然我等小白真的… pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" ...
java基于BouncyCastle实现RSA算法的加密、解密
hqy1719239337的博客
04-04 8803
背景： Bouncy Castle Crypto是一个Java实现的加密包，同时也有C#版本。它包含一套轻量级的API可以在包括J2ME在内的绝大多数环境中运行。部分手机不支持JSR177也可使用该加密包实现加密功能。Bouncy Castle加密包包含了大多数流行的加密实现（如：AES、DES、Blowfish等）、散列算法（如：MD5、SHA等）、字节字符编码（如：Base64...
验证私钥匹配证书
jason的专栏
05-31 979
1. 验证私钥一致性 openssl rsa -check -noout -in myserver.key RSA Key is ok 2. 验证证书和私钥有相同的modulus openssl x509 -modulus -noout -in myserver.crt | openssl md5 openssl rsa -modulus -noout -in myserver.key | openssl md5
使用Java代码生成RSA公私钥的.pem文件
神韵
11-15 4849
大家好，我是神韵，是一个技术&生活博主。出文章目的主要是两个，一是好记忆不如烂笔头，记录总结中提高自己。二是希望我的文章可以帮到大家。欢迎大家留言讨论，你们的行动将是我无限的动力。代码首先通过KeyPairGenerator指定algorithm为RSA，长度为2048，生成长度为48的RSA密钥。然后通过PemWriter这个类来写出PemObject文件。最后会在资源目录下生成两个pem文件，如下所示。其它代码都是文件输出的基础，这里不再介绍。用代码生成RSA公私钥的.pem文件。
检测证书和私钥是否匹配的办法你知道吗
蔚可云的博客
02-17 3420
SSH 为 Secure Shell 的缩写， 为建立在应用层基础上的安全协议。一般，通过ssh登录远程服务器时，使用密码认证，分别输入用户名和密码，两者满足一定规则就可以登录。但是密码认证有以下的缺点： 1、用户无法设置空密码（即使系统允许空密码，也会十分危险） 2、密码容易被人偷窥或猜到 3、服务器上的一个帐户若要给多人使用，则必须让所有使用者都知道密码，导致密码容易泄露，修改密码时必须通知所有人 而使用公钥认证则可以解决上述问题： 公钥认证允许使用空密码，省去每次登录都需要输入密码.
BouncyCastle.Crypto
06-28
BouncyCastle.Crypto.dll 版本1.8.1 ，内含使用API，The Legion of the Bouncy Castle
java使用bouncycastle加解密
gsls200808的专栏
11-06 1万+
jdk默认带了一些常见的加解密方式，当我们常见的加解密不能满足时，就需要用到一些第三方的库了，bouncycastle就是其中一种。但是bouncycastle文档比较少。简单介绍一下写法。
Java解析公私钥文件
最新发布
qq_34823185的博客
11-08 1136
公私钥
利用BouncyCastle开源库解析国密SM2证书 Java实现
奔向自由实现
11-20 1万+
利用BouncyCastle开源库解析国密SM2证书 Java实现1.数字证书科普2.代码用法： 1.数字证书科普 数字证书由权威机构——CA机构，又称为证书授权（Certificate Authority）中心发行。 现阶段多为X.509格式证书，X.509是ITU-T标准化部门基于他们之前的ASN.1定义的一套证书标准。之前有X.500。 编码方式有两种：DER编码 PEM编...
如何读取 PEM 文件以获取公钥和私钥
热门推荐
sonadorje的专栏
07-13 3万+
1. 概述 在公钥密码学（也称为非对称密码术）中，加密机制依赖于两个相关的密钥，一个公钥和一个私钥。公钥用于加密消息，而只有私钥的所有者才能解密消息。 在本教程中，我们将了解如何从 PEM 文件中读取公钥和私钥。 首先，我们将研究有关公钥密码学的一些重要概念。然后，我们将学习如何使用纯 Java 读取 PEM 文件。 最后，我们将探索BouncyCastle库作为替代方法。 2. 概念 在开始之前，让我们先了解一些关键概念。 X.509 是定义公钥证书格式的标准。因此，这种...
使用BouncyCastle 实现RSA常用方法
杨小熊学习笔记
07-21 4148
使用BouncyCastle 解析私钥 项目地址 相关openssl命令 # OpenSSL 1.1.1h 22 Sep 2020 # 生成一个3072bit的RSA私钥 openssl genpkey -algorithm RSA-PSS -pkeyopt rsa_keygen_bits:3072 -pkeyopt rsa_keygen_pubexp:65537 -pkeyopt rsa_pss_keygen_md:sha256 -pkeyopt rsa_pss_keygen_mgf1_md:sha2
Java使用BouncyCastleProvider进行RSA加解密
z69183787的专栏
02-14 7462
公司项目，对方的外链地址是通过 post一个地址，成功验证rsa后会进行跳转，跳转后的那个地址是最终我们需要的， 即 httpstatus=302的时候，获取header中的location 得到他的redirect地址 <dependency> <groupId>org.apache.httpcomponents</groupId> ...
java encrypt加密_RSA使用JSEncrypt加密并使用BouncyCastle(Java)解密
weixin_36429702的博客
02-21 1777
这可能是 this answered question的重复,但我似乎无法得到相同的结果.希望在这里有一些指导.JSEncrypt(客户端)let encrypt = new Encrypt.JSEncrypt();encrypt.setPublicKey(this.publicKey); // retrieved from serverencrypt.encrypt(password);Bou...
java rsa pem_Java读取OpenSSL生成的PEM公钥文件操作
weixin_34081553的博客
02-12 727
JDK8的JCE是不支持读取PEM文件的。需要使用bouncycastle。项目需求，使用SHA1WithRSA算法，对接口数据做签名。代码如下：@Serviceclass SignService {private static Logger LOG = LoggerFactory.getLogger(SignService.class);@Autowiredprivate Config conf...
JAVA的rsa默认实现_JAVA实现RSA算法
weixin_42515058的博客
02-24 488
实现一对密钥对整个项目所有加密解密文件都适用的方法,采用先生成一对密钥.保存到xml文件中,以后获得私匙和公钥只需要从xml文件中取得就可以了./*** 把成生的一对密钥保存到RSAKey.xml文件中*/public void saveRSAKey() {try {SecureRandom sr = new SecureRandom();KeyPairGenerator kg = KeyPair...
java 文件存在自动添加数字_Java对文件添加数字签名
weixin_36217920的博客
02-13 331
一：需要包含的包import java.security.*;import java.io.*;import java.util.*;import java.security.*;import java.security.cert.*;import sun.security.x509.*import java.security.cert.Certificate;import java.securi...
利用Java6和BouncyCastle对文件进行加解密
A Blog Just For Qiailin
01-21 3781
过Bouncy Castle提供的下载地址（http://www.bouncycastle.org/latest_releases.html），下载最新的加密组件包，主要是bcprov-jdk16-143.jar和bcprov-ext-jdk16-143.jar两个文件，当然这里只用bcprov-jdk16-143.jar，自己可以去下载添加到项目中。package sample; import javax.crypto.Cipher; import java.security.*; import j
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值