一、制作证书
1.生成keyStroe文件
在命令行下执行以下命令：
keytool -genkey -validity 1 -alias www.tzz-sf.com -keyalg RSA -keystore d:\tzz-sf.keystore
其中
-genkey 表示生成密钥
-validity 指定证书有效期，这里是1天
-alias 指定别名，这里是www.tzz-sf.com
-keyalg 指定算法，这里是RSA
-keystore 指定存储位置，这里是d:\tzz-sf.keystore
根据命令行提示输入：
输入keystore密码： Keystore 密码太短 -至少必须为6个字符 输入keystore密码： 再次输入新密码: 您的名字与姓氏是什么？ [Unknown]： tzz 您的组织单位名称是什么？ [Unknown]： www.tzz-sf.com 您的组织名称是什么？ [Unknown]： tzz-sf 您所在的城市或区域名称是什么？ [Unknown]： sz 您所在的州或省份名称是什么？ [Unknown]： sz 该单位的两字母国家代码是什么 [Unknown]： cn CN=tzz, OU=www.tzz-sf.com, O=tzz-sf, L=sz, ST=sz, C=cn 正确吗？ [否]： y 输入<www.tzz-sf.com>的主密码
在这里我使用的密码为 123456789
2.生成自签名证书
光有keyStore文件是不够的，还需要证书文件，证书才是直接提供给外界使用的公钥凭证。
keytool -export -keystore d:\tzz-sf.keystore -alias www.tzz-sf.com -file d:\tzz-sf.cer -rfc
其中
-export 指定为导出操作
-keystore 指定keystore文件
-alias 指定导出keystore文件中的别名
-file 指向导出路径
-rfc 以文本格式输出，也就是以BASE64编码输出
这里的密码是 123456789
当然，使用方是需要导入证书的！
可以通过自签名证书完成CAS单点登录系统的构建！
import java.io.IOException;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
public class Coder {
public static String encryptBASE64(byte[] key) {
return (new BASE64Encoder()).encodeBuffer(key);
}
public static byte[] decryptBASE64(String key) throws IOException {
return new BASE64Decoder().decodeBuffer(key);
}
}
package cn.tzz.java.crypto.certificate;
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;
import cn.tzz.java.crypto.Coder;
/**
* Java加密技术——数字证书
*
*/
public abstract class CertificateCryptUtil 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 cn.tzz.java.crypto.certificate;
import static org.junit.Assert.*;
import org.junit.Test;
/**
* 测试--Java加密技术——数字证书
*
*/
public class CertificateCryptUtilTest {
private String password = "123456789";
private String alias = "www.tzz-sf.com";
//生成证书
//keytool -genkey -validity 1 -alias www.tzz-sf.com -keyalg RSA -keystore d:\tzz-sf.keystore
//keytool -export -keystore d:\tzz-sf.keystore -alias www.tzz-sf.com -file d:\tzz-sf.cer -rfc
private String keyStorePath = "d:/tzz-sf.keystore";
private String certificatePath = "d:/tzz-sf.cer";
/**公钥加密——私钥解密*/
@Test
public void test() throws Exception {
String inputStr = "加密字符123456Abc";
byte[] data = inputStr.getBytes();
byte[] encrypt = CertificateCryptUtil.encryptByPublicKey(data, certificatePath);
byte[] decrypt = CertificateCryptUtil.decryptByPrivateKey(encrypt, keyStorePath, alias, password);
String outputStr = new String(decrypt);
System.err.println("加密前: " + inputStr + "-----" + "解密后: " + outputStr);
// 验证数据一致
assertArrayEquals(data, decrypt);
// 验证证书有效
assertTrue(CertificateCryptUtil.verifyCertificate(certificatePath));
}
/**私钥加密——公钥解密*/
@Test
public void testSign() throws Exception {
String inputStr = "加密字符123456Abc";
byte[] data = inputStr.getBytes();
byte[] encodedData = CertificateCryptUtil.encryptByPrivateKey(data, keyStorePath, alias, password);
byte[] decodedData = CertificateCryptUtil.decryptByPublicKey(encodedData, certificatePath);
String outputStr = new String(decodedData);
System.err.println("加密前: " + inputStr + "----" + "解密后: " + outputStr);
assertEquals(inputStr, outputStr);
// 产生签名
String sign = CertificateCryptUtil.sign(encodedData, keyStorePath, alias, password);
System.err.println("签名:\r" + sign);
// 验证签名
boolean status = CertificateCryptUtil.verify(encodedData, sign, certificatePath);
System.err.println("状态:\r" + status);
assertTrue(status);
}
}
相关推荐
在Java编程环境中，数字证书是用于安全通信的重要工具，它们主要应用于加密、身份验证和数据完整性保护。在“JAVA使用数字证书加密文件”的主题中，我们聚焦于如何使用RSA算法结合数字证书对文件进行加密。RSA是一种...
Java代码生成数字证书涉及到几个关键概念和技术，包括Java的密钥和证书管理、RSA加密算法以及非交互式证书创建。在此，我们将深入探讨这些主题，以便理解如何在Java环境中生成和使用数字证书。 1. **数字证书**：...
在IT领域，尤其是在网络安全和数据保护方面，加密技术扮演着至关重要的角色。本文将深入探讨如何使用Java语言结合RSA算法，通过数字证书实现文件的加密和解密操作。RSA是一种非对称加密算法，它的核心在于一对密钥：...
### Java 获取数字证书信息 在本篇文章中，我们将深入探讨如何使用Java来获取数字证书的信息，包括使用TOMCAT和JDK搭建SSL服务的过程、如何用OpenSSL签发证书以及如何支持第三方CA等内容。 #### 一、使用TOMCAT和...
总结来说，Java提供的安全通信机制包括了消息摘要、消息验证码和数字证书等技术，它们一起确保了在网络通信中的数据安全性和身份认证。通过学习这些知识，开发者可以构建更安全的Java应用程序，保护用户的隐私和信息...
本文将深入探讨Java中常用的加密技术，包括基本的单向加密算法、对称加密、非对称加密以及数字证书等相关知识点。 #### 二、基本概念 **单向加密算法**是一种加密过程不可逆的算法，即一旦数据被加密，就不能被...
总之，Java数字证书和数字签名是构建安全网络应用的核心技术，这个源码模块提供了一种实际的实现方式，可以帮助开发者更好地理解和应用这些概念。通过深入学习和实践，你可以提升在网络安全领域的专业技能，为构建更...
通过阅读"Java加密和数字签名编程快速入门"，无论是初学者还是有一定经验的开发者，都能掌握Java中加密和数字签名的基本原理和实际应用。"www.pudn.com.txt"可能是提供额外链接或资源的文本文件，而"Java加密和数字...
在Java编程环境中，生成数字证书是一项关键的安全技术，主要用于数据加密、身份验证和签名等应用场景。数字证书通常包含了公钥和私钥对，以及证书持有者的相关信息，这些信息经过认证机构（CA）的签名，确保了证书的...
Java加密技术是保护数据安全的重要工具，广泛应用于网络通信、数据存储、数字签名等领域。本资源包涵盖了Java中常见的加密算法和技术，包括基础的哈希算法、对称加密、非对称加密以及证书签名和SSL/TLS协议。下面将...
Java 数字签名与数字证书是网络安全领域中的重要概念，它们在确保数据的完整性和来源的可信性方面扮演着关键角色。在这个"Java 数字签名、数字证书生成源码"压缩包中，包含了实现这些功能的源代码，对于理解Java安全...
Java加密技术是Java编程语言中用于保障数据安全的一系列加密方法和技术，它包括了单向加密算法、对称加密算法、非对称加密算法以及加密算法的高级应用如数字签名和数字证书等。本文将详细介绍这些加密技术，并结合...
下面将详细介绍这些算法以及它们在Java中的实现，以及如何进行数字签名和数字证书的验证。 1. **SM2算法**：SM2是一种基于椭圆曲线密码学（ECC）的公钥加密算法，用于非对称加密。它提供了密钥交换、签名和验证的...
总结来说，这个"java加密技术"资源涵盖了基础和高级的加密算法，包括Base64、DES、AES、RSA，以及哈希函数和证书管理。通过学习这些内容，开发者可以更好地理解和应用加密技术，提升系统的安全性。
Java 数字签名和数字证书是网络安全领域中的重要概念，它们在确保数据的完整性和来源的可信性方面扮演着关键角色。这份"Java 数字签名、数字证书生成源码"的压缩包提供了实现这些功能的代码示例，对于理解和应用Java...
总的来说，Java加密和数字签名编程是构建安全应用的关键技术，它涉及到密码学原理和Java的加密API。通过这个快速入门，你可以获得基本的理解，并为进一步深入学习打下坚实的基础。在实践中不断探索，你将能够熟练地...
Java加密技术是软件开发中一个至关重要的领域，特别是在保护数据安全、验证信息完整性和实现安全通信方面。本书“Java加密技术（技巧与实例）”深入浅出地探讨了这一主题，为开发者提供了丰富的实践指导。以下是一些...
Java加密技术是软件开发中一个重要的领域，尤其是在处理敏感数据、网络安全和隐私保护时不可或缺。在Java中，加密主要依赖于Java Cryptography Architecture (JCA) 和 Java Cryptography Extension (JCE)。JCA提供了...