java加密、证书整理

最新推荐文章于 2023-12-04 17:58:50 发布
最新推荐文章于 2023-12-04 17:58:50 发布
阅读量401 收藏 1
点赞数
分类专栏： 编程扩展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38060977/article/details/103317676
版权

目录

前言

最近在工作中需要对接一些项目的接口。这些接口对数据的保密性要求比较高。经常会用到一些加密算法。
刚开始非常头疼，不知道这些的方法的用法。因为一些原因，项目的文档也很简陋与过时。demo中也没有注释。只能只能自己慢慢摸索。
最后发现了解并掌握这些知识还是很有用的。毕竟不能在同一个问题上跌倒两次，所以专门对网上的资料做一下整理并实践。

一 基本概念

先阅读：java加密算法入门（一）-算法概念及单向加密
本文小结：

  1. 先区分什么是编码、什么摘要、什么是加密。
  2. BASE64是编码规则，可以解码出明文。主要为了传递安全
  3. MD5、SHA以及HMAC是摘要，任何数据加密后只会产生唯一的一个加密串，通常用来校验数据在传 输过程中是否被修改。
  4. 其中HMAC算法有一个密钥（其他几种不需要密钥），增强了数据传输过程中的安全性，强化了算法外的不可控因素。
  5. 摘要并不是无法破解，但比较难

二 对称加密

参考：java加密算法入门（二）-对称加密详解
本文小结：

  1. DES是最基本的算法，出身比较好美国军方通过IBM来实现的(可以被破解，不推荐)
  2. 3DES由于DES有漏洞不安全，所以，产生了3DES,应用更加的广泛，不过效率不高，所以才有了后来的AES
  3. AES是应用更加广泛的一种对称加密算法，安全性更高
  4. PBE本质是其他对称加密算法一种综合，加入了盐（随机字符串）防止密码的暴力破解
  5. 上面的加密过程中，密钥的使用准备工作往往有两步.先是由KeyGenerator产生密钥，然后将密钥转化成不同加密算法需要的格式

对称加密双方都有同样的密钥。密钥本身是字节数组，可以转成base64、hash等形式保存成文本

PBE的概念不太清楚，继续参照：
对称加密算法-PBE算法

三 非对称加密

加解密过程分别由公钥和私钥来进行.实际场景中往往由是双向加密，既有两组非对称加密
参考：java加密算法入门（三）-非对称加密详解

本文总结

DH算法

过程就是：

  1. 发送发产生密钥对，并把公钥发给接受方
  2. 接收方根据发送方的公钥，产生自己的密钥对；并把自己的公钥发给发送方。
  3. 两边根据同一种算法将对方的公钥和自己的私钥产生一个本地密钥（是对称加密算法的密钥，两者产生的本地密钥相同），然后使用对称加密算法进行加解密

小结
DH算法本质还是用了同一个密钥对数据进行加密，在加解密的过程中并没有使用新的算法

RSA算法

既能用于数据加密也能用于数字签名的算法，这里出现了一个新的概念数字签名，支持公钥加密、私钥解密.私钥加密、公钥解密。

数字签名可以对传输过来的数据进行校验。确保数据在传输工程中不被修改。

使用过程

  1. 甲乙双方都有自己的密钥对，分别保存自己的密钥，然后将公钥发布。
  2. 双方在传输数据前，分别用对方的公钥加密。这样就只有对方才可以用私钥解密查看信息。
  3. 但上面过程有个问题？公钥是公开的，如果用人篡改了数据，然后用重新公钥加密的数据来代替。那么就很危险
  4. 这时数字签名的作用就出来。发送方用自己的私钥对发送数据进行签名（数据摘要）,接收方需要用发送方的公钥对签名进行解密，最后对数据进行签名比对
  5. 这时候问题又来了？在网络环境下（你要是人手动获取密钥,比如u盘拷贝，肯定没这问题啊），双方如何保证自己手上的公钥就是对方的呢？这个就是需要CA来进行验证，这也是HTTPS的原理.有点扯远了。

ElGamal算法

只提供公钥加密,私钥解密，不提供私钥加密，公钥解密

四 证书的简单使用

参考自：1
因原文没有目录，看起来不太哦方便，所以自己整理了一下。我只看了原文的小部分，并没有把原文的全文内容整理出来

证书的制作

生成keyStroe文件

D:\idea201924workspace\encryption\src\main\resources>keytool -genkey -validity 36000 -alias www.zhuyc.com -keyalg RSA -keystore .\zhuyc.keystore
输入密钥库口令:   #我输入：koulin
密钥库口令太短 - 至少必须为 6 个字符
输入密钥库口令:
再次输入新口令:
它们不匹配。请重试
输入密钥库口令:
再次输入新口令:
您的名字与姓氏是什么?
  [Unknown]:  zhuyc
您的组织单位名称是什么?
  [Unknown]:  zhuyc
您的组织名称是什么?
  [Unknown]:  zhuyc
您所在的城市或区域名称是什么?
  [Unknown]:  hz
您所在的省/市/自治区名称是什么?
  [Unknown]:  zj
该单位的双字母国家/地区代码是什么?
  [Unknown]:  cn
CN=zhuyc, OU=zhuyc, O=zhuyc, L=hz, ST=zj, C=cn是否正确?
  [否]:  y

输入 <www.zhuyc.com> 的密钥口令
        (如果和密钥库口令相同, 按回车):  #我先是输入password，后来运行测试代码时报错。所以建议和前面密码一致
再次输入新口令:

其中

  • genkey表示生成密钥
  • validity指定证书有效期，这里是36000天
  • alias指定别名，这里是www.zlex.org
  • keyalg指定算法，这里是RSA
  • keystore指定存储位置，

生成自签名证书

D:\idea201924workspace\encryption\src\main\resources>keytool -export -keystore .\zhuyc.keystore -alias www.zhuyc.com -file .\zhuyc.cer -rfc
输入密钥库口令:
存储在文件 <.\zhuyc.cer> 中的证书

测试代码

Coder

package com.zyc.https;

import java.security.MessageDigest;

import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * 基础加密组件
 *
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public abstract class Coder {
    public static final String KEY_SHA = "SHA";
    public static final String KEY_MD5 = "MD5";

    /**
     * MAC算法可选以下多种算法
     *
     * <pre>
     * HmacMD5
     * HmacSHA1
     * HmacSHA256
     * HmacSHA384
     * HmacSHA512
     * </pre>
     */
    public static final String KEY_MAC = "HmacMD5";

    /**
     * BASE64解密
     *
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptBASE64(String key) throws Exception {
        return (new BASE64Decoder()).decodeBuffer(key);
    }

    /**
     * BASE64加密
     *
     * @param key
     * @return
     * @throws Exception
     */
    public static String encryptBASE64(byte[] key) throws Exception {
        return (new BASE64Encoder()).encodeBuffer(key);
    }

    /**
     * MD5加密
     *
     * @param data
     * @return
     * @throws Exception
     */
    public static byte[] encryptMD5(byte[] data) throws Exception {

        MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
        md5.update(data);

        return md5.digest();

    }

    /**
     * SHA加密
     *
     * @param data
     * @return
     * @throws Exception
     */
    public static byte[] encryptSHA(byte[] data) throws Exception {

        MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
        sha.update(data);

        return sha.digest();

    }

    /**
     * 初始化HMAC密钥
     *
     * @return
     * @throws Exception
     */
    public static String initMacKey() throws Exception {
        KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);

        SecretKey secretKey = keyGenerator.generateKey();
        return encryptBASE64(secretKey.getEncoded());
    }

    /**
     * HMAC加密
     *
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] encryptHMAC(byte[] data, String key) throws Exception {

        SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);
        Mac mac = Mac.getInstance(secretKey.getAlgorithm());
        mac.init(secretKey);

        return mac.doFinal(data);

    }
}

CertificateCoder

package com.zyc.https;

import java.io.FileInputStream;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.util.Date;

import javax.crypto.Cipher;

/**
 * 证书组件
 *
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public abstract class CertificateCoder extends Coder {


    /**
     * Java密钥库(Java Key Store，JKS)KEY_STORE
     */
    public static final String KEY_STORE = "JKS";

    public static final String X509 = "X.509";

    /**
     * 由KeyStore获得私钥
     *
     * @param keyStorePath
     * @param alias
     * @param password
     * @return
     * @throws Exception
     */
    private static PrivateKey getPrivateKey(String keyStorePath, String alias,
                                            String password) throws Exception {
        KeyStore ks = getKeyStore(keyStorePath, password);
        PrivateKey key = (PrivateKey) ks.getKey(alias, password.toCharArray());
        return key;
    }

    /**
     * 由Certificate获得公钥
     *
     * @param certificatePath
     * @return
     * @throws Exception
     */
    private static PublicKey getPublicKey(String certificatePath)
            throws Exception {
        Certificate certificate = getCertificate(certificatePath);
        PublicKey key = certificate.getPublicKey();
        return key;
    }

    /**
     * 获得Certificate
     *
     * @param certificatePath
     * @return
     * @throws Exception
     */
    private static Certificate getCertificate(String certificatePath)
            throws Exception {
        CertificateFactory certificateFactory = CertificateFactory
                .getInstance(X509);
        FileInputStream in = new FileInputStream(certificatePath);

        Certificate certificate = certificateFactory.generateCertificate(in);
        in.close();

        return certificate;
    }

    /**
     * 获得Certificate
     *
     * @param keyStorePath
     * @param alias
     * @param password
     * @return
     * @throws Exception
     */
    private static Certificate getCertificate(String keyStorePath,
                                              String alias, String password) throws Exception {
        KeyStore ks = getKeyStore(keyStorePath, password);
        Certificate certificate = ks.getCertificate(alias);

        return certificate;
    }

    /**
     * 获得KeyStore
     *
     * @param keyStorePath
     * @param password
     * @return
     * @throws Exception
     */
    private static KeyStore getKeyStore(String keyStorePath, String password)
            throws Exception {
        FileInputStream is = new FileInputStream(keyStorePath);
        KeyStore ks = KeyStore.getInstance(KEY_STORE);
        ks.load(is, password.toCharArray());
        is.close();
        return ks;
    }

    /**
     * 私钥加密
     *
     * @param data
     * @param keyStorePath
     * @param alias
     * @param password
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String keyStorePath,
                                             String alias, String password) throws Exception {
        // 取得私钥
        PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);

        // 对数据加密
        Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);

        return cipher.doFinal(data);

    }

    /**
     * 私钥解密
     *
     * @param data
     * @param keyStorePath
     * @param alias
     * @param password
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] data, String keyStorePath,
                                             String alias, String password) throws Exception {
        // 取得私钥
        PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);

        // 对数据加密
        Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);

        return cipher.doFinal(data);

    }

    /**
     * 公钥加密
     *
     * @param data
     * @param certificatePath
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String certificatePath)
            throws Exception {

        // 取得公钥
        PublicKey publicKey = getPublicKey(certificatePath);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        return cipher.doFinal(data);

    }

    /**
     * 公钥解密
     *
     * @param data
     * @param certificatePath
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] data, String certificatePath)
            throws Exception {
        // 取得公钥
        PublicKey publicKey = getPublicKey(certificatePath);

        // 对数据加密
        Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicKey);

        return cipher.doFinal(data);

    }

    /**
     * 验证Certificate
     *
     * @param certificatePath
     * @return
     */
    public static boolean verifyCertificate(String certificatePath) {
        return verifyCertificate(new Date(), certificatePath);
    }

    /**
     * 验证Certificate是否过期或无效
     *
     * @param date
     * @param certificatePath
     * @return
     */
    public static boolean verifyCertificate(Date date, String certificatePath) {
        boolean status = true;
        try {
            // 取得证书
            Certificate certificate = getCertificate(certificatePath);
            // 验证证书是否过期或无效
            status = verifyCertificate(date, certificate);
        } catch (Exception e) {
            status = false;
        }
        return status;
    }

    /**
     * 验证证书是否过期或无效
     *
     * @param date
     * @param certificate
     * @return
     */
    private static boolean verifyCertificate(Date date, Certificate certificate) {
        boolean status = true;
        try {
            X509Certificate x509Certificate = (X509Certificate) certificate;
            x509Certificate.checkValidity(date);
        } catch (Exception e) {
            status = false;
        }
        return status;
    }

    /**
     * 签名
     *
     * @param keyStorePath
     * @param alias
     * @param password
     *
     * @return
     * @throws Exception
     */
    public static String sign(byte[] sign, String keyStorePath, String alias,
                              String password) throws Exception {
        // 获得证书
        X509Certificate x509Certificate = (X509Certificate) getCertificate(
                keyStorePath, alias, password);
        // 获取私钥
        KeyStore ks = getKeyStore(keyStorePath, password);
        // 取得私钥
        PrivateKey privateKey = (PrivateKey) ks.getKey(alias, password
                .toCharArray());

        // 构建签名
        Signature signature = Signature.getInstance(x509Certificate
                .getSigAlgName());
        signature.initSign(privateKey);
        signature.update(sign);
        return encryptBASE64(signature.sign());
    }

    /**
     * 验证签名
     *
     * @param data
     * @param sign
     * @param certificatePath
     * @return
     * @throws Exception
     */
    public static boolean verify(byte[] data, String sign,
                                 String certificatePath) throws Exception {
        // 获得证书
        X509Certificate x509Certificate = (X509Certificate) getCertificate(certificatePath);
        // 获得公钥
        PublicKey publicKey = x509Certificate.getPublicKey();
        // 构建签名
        Signature signature = Signature.getInstance(x509Certificate
                .getSigAlgName());
        signature.initVerify(publicKey);
        signature.update(data);

        return signature.verify(decryptBASE64(sign));

    }

    /**
     * 验证Certificate
     *
     * @param keyStorePath
     * @param alias
     * @param password
     * @return
     */
    public static boolean verifyCertificate(Date date, String keyStorePath,
                                            String alias, String password) {
        boolean status = true;
        try {
            Certificate certificate = getCertificate(keyStorePath, alias,
                    password);
            status = verifyCertificate(date, certificate);
        } catch (Exception e) {
            status = false;
        }
        return status;
    }

    /**
     * 验证Certificate
     *
     * @param keyStorePath
     * @param alias
     * @param password
     * @return
     */
    public static boolean verifyCertificate(String keyStorePath, String alias,
                                            String password) {
        return verifyCertificate(new Date(), keyStorePath, alias, password);
    }
}

测试类

package com.zyc.https;

import static org.junit.Assert.*;

import org.junit.Test;

/**
 *
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public class CertificateCoderTest {
    private String password = "koulin";
    private String alias = "www.zhuyc.com";
    private String certificatePath = "D:\\idea201924workspace\\encryption\\src\\main\\resources\\zhuyc.cer";
    private String keyStorePath = "D:\\idea201924workspace\\encryption\\src\\main\\resources\\zhuyc.keystore";

    @Test
    public void test() throws Exception {
        System.err.println("公钥加密——私钥解密");
        String inputStr = "Ceritifcate";
        byte[] data = inputStr.getBytes();

        byte[] encrypt = CertificateCoder.encryptByPublicKey(data,
                certificatePath);

        byte[] decrypt = CertificateCoder.decryptByPrivateKey(encrypt,
                keyStorePath, alias, password);
        String outputStr = new String(decrypt);

        System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);

        // 验证数据一致
        assertArrayEquals(data, decrypt);

        // 验证证书有效
        assertTrue(CertificateCoder.verifyCertificate(certificatePath));

    }

    @Test
    public void testSign() throws Exception {
        System.err.println("私钥加密——公钥解密");

        String inputStr = "sign";
        byte[] data = inputStr.getBytes();

        byte[] encodedData = CertificateCoder.encryptByPrivateKey(data,
                keyStorePath, alias, password);

        byte[] decodedData = CertificateCoder.decryptByPublicKey(encodedData,
                certificatePath);

        String outputStr = new String(decodedData);
        System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
        assertEquals(inputStr, outputStr);

        System.err.println("私钥签名——公钥验证签名");
        // 产生签名
        String sign = CertificateCoder.sign(encodedData, keyStorePath, alias,
                password);
        System.err.println("签名:\r" + sign);

        // 验证签名
        boolean status = CertificateCoder.verify(encodedData, sign,
                certificatePath);
        System.err.println("状态:\r" + status);
        assertTrue(status);

    }
}

参考

上面参考文章的源码地址

ycCoding
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 软件加密
IT部落格
11-02 897
MD5字符串加密 /*** * MD5加码 生成32位md5码 */ public static String string2MD5(String inStr){ MessageDigest md5 = null; try{ md5 = MessageDigest.getInstance("MD5
java证书加解密过程
only06的博客
08-01 4069
前提铺垫： 本机上构造两个数字证书用作测试，一个 Server 端 与一个Client 端 使用java keytool 生成自签名证书。 过程如下: 参数如下：  -genkeypair 生成密钥对 -keyalg 指定密钥算法 -keysize 指定密钥长度 -sigalg 指定签名算法 -validity 证书有效期 -alias 别名 -keystore 密
JAVA使用数字证书加密文件
11-17
java rsa证书加密，crt、pem、pfx、cer等 内附工具
Java开发中的加密、解密、签名、验签，密钥，证书，这篇就够了
Joker的博客
05-06 3638
Java开发中的加密、解密、签名、验签，密钥，证书
java 加密证书_Java的安全学习（包括加密，数字签名，证书和认证）
weixin_29163581的博客
03-01 151
(1)消息摘要：消息摘要(Message Digest)又称为数字摘要(Digital Digest)。它是一个唯一对应一个消息或文本的固定长度的值，它由一个单向Hash加密函数对消息进行作用而产生。如果消息在途中改变了，则接收者通过对收到消息的新产生的摘要与原摘要比较，就可知道消息是否被改变了。因此消息摘要保证了消息的完整性。 消息摘要采用单向Hash 函数将需加密的明文"摘要"成一...
java加密解密与数字证书的操作
热门推荐
lihuayong的专栏
12-14 1万+
1 keytool命令总结 一、创建数字证书 交互模式 使用默认的密钥库.keystore(目录是c: Documents and Setting用户名)和算法(DSA) keytool -genkey 默认的别名mykey 密钥库中可以存放多个条目（公钥/私钥对和证书），它们在密钥库中以别名(alias)区分。 keytool -genkey -alia
Java——数字证书详解
最新发布
吴声子夜歌的博客
12-04 913
数字证书集合了多种密码学算法：自身带有公钥信息，可完成相应的加密/解密操作；同时，还带有数字签名，可鉴别消息来源；且自身带有消息摘要信息，可验证证书的完整性；由于证书本身含有用户身份信息，因而具有认证性。数字证书具备常规加密/解密必要的信息，包含签名算法，可用于网络数据加密/解密交互，标识网络用户（计算机）身份。数字证书为发布公钥提供了一种简便的途径，其数字证书则成为加密算法以及公钥的载体。依靠数字证书，我们可以构建一个简单的加密网络应用平台。
Java加密解密工具集+JCT+v1Java实用源码整理learns
09-06
总的来说，这个Java加密解密工具集结合了JCT，为开发者提供了一站式的加密解决方案，涵盖了对称加密、非对称加密、哈希计算和数字证书处理等多个方面。通过深入学习和实践这些源码，开发者能够提升其在信息安全领域...
5300证书10个，JAVA的证书
07-25
【标题】：“5300证书10个，JAVA的证书”指的是与Java相关的5300个证书集合，这通常涉及到的是Java平台上的安全证书，用于验证软件、服务器身份或者进行加密通信。 【描述】：“5300JAVA证书 今天整理电脑，发现...
一些Java EE面试问答整理
04-21
- 在WebLogic中配置SSL，需要启用SSL并设置端口，使用KeyStore（如DemoIdentity.jks和DemoTrust.jks），在生产环境中需要导入CA证书。 7. **EJB查看**： - 通过WebLogic管理控制台的Deployment部分可以查看已发布...
java　证书 加密 解密
07-26
NULL 博文链接：https://philip01.iteye.com/blog/659749
JAVA 使用数字证书加密解密文件
10-31
学习RSA算法,读取数字证书中的私钥对文件进行加密,使用数字证书的公钥解密,这种方式就是RSA算法.
Java实现RSA加密解密,数字证书生成与验证(有搭Socket)
12-10
AB双方通信,A把需要传输的文件MD5值用自己的私钥生成数字签名,连同明文用B的公钥加密后传送给B,B用私钥解密验证数字签名,并计算明文MD5值跟密文的MD5值比较
java 证书进行加解密和签名验签
weixin_42588592的博客
06-14 1477
java 证书进行加解密和签名验签 使用keytool工具进行生成公私钥对 使用keytool工具进行生成公私钥对 详情请参考别人的一篇文章：link. 本文生成一个pkcs12格式的bo.keystore keytool -genkeypair -alias www.bo.org -keyalg RSA -keystore d:\github\bo.keystore -storetype pkcs12 之后进行处理，详细代码如下： package com.longxinwu.util; import
java加密技术(八) 数字证书_Java加密技术（八）——数字证书
weixin_33232550的博客
02-13 78
importjava.io.FileInputStream;importjava.security.KeyStore;importjava.security.PrivateKey;importjava.security.PublicKey;importjava.security.Signature;importjava.security.cert.Certificate;import...
java.security 框架之签名、加密、摘要及证书
长安明月的博客
08-03 1938
单向加密是不可逆的，MD5、SHA、MAC 都是单向加密算法，也称之为摘要算法。MD5、SHA 会根据明文用哈希算法计算一个固定长度的摘要（哈希值），然后把明文和摘要发送给接收者，接收者根据同样的算法计算出摘要，对比两个摘要是否一样即可验证明文的正确性。它的应用场景是防止报文被篡改和校验数据。MD5、SHA 等算法是开源的，容易被试探出来。有没有更安全的摘要算法呢？HMAC（带密钥的哈希函数），用一个密钥和一个明文消息作为输入，生成一个消息摘要。.........
Java加解密（八）数字证书
yunyun1886358的专栏
01-15 4533
数字证书（Digital Certificate），一般指公钥证书(Public Key Certificate，PKC)，类似于我们生活中的身份证，用于标识网络中的用户（计算机）身份，里面记有姓名、组织，邮箱，地区，国家等个人信息，以及属于此人的公钥，还包含由认证机构（Certification Authority，CA）施加的数字签名。公钥证书也简称为证书（Certificate）。上面的描述是不是很抽象，下面我们来具体看一看一个证书包含的具体数据。下面的内容是通过Java程序从证书文件。
Java加密技术（八）
【大漠孤烟】 的专栏
09-07 1096
本篇的主要内容为Java证书体系的实现。  请大家在阅读本篇内容时先阅读 Java加密技术（四），预先了解RSA加密算法。  在构建Java代码实现前，我们需要完成证书的制作。  1.生成keyStroe文件  在命令行下执行以下命令：  She
Java加密解密方法详解与应用
Java加密解密方法大全是一份关于在Java编程中实施数据安全的重要指南，由郭克华编撰，旨在介绍和讲解加密技术的基础概念和实践应用。该讲义涵盖了加密和解密的核心原理，适用于开发人员理解和保护敏感信息。 加密...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值