`

Java加密技术 数字证书

阅读更多

一、制作证书 

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编程环境中,数字证书是用于安全通信的重要工具,它们主要应用于加密、身份验证和数据完整性保护。在“JAVA使用数字证书加密文件”的主题中,我们聚焦于如何使用RSA算法结合数字证书对文件进行加密。RSA是一种...

    java代码生成数字证书

    Java代码生成数字证书涉及到几个关键概念和技术,包括Java的密钥和证书管理、RSA加密算法以及非交互式证书创建。在此,我们将深入探讨这些主题,以便理解如何在Java环境中生成和使用数字证书。 1. **数字证书**:...

    JAVA 使用数字证书加密解密文件

    在IT领域,尤其是在网络安全和数据保护方面,加密技术扮演着至关重要的角色。本文将深入探讨如何使用Java语言结合RSA算法,通过数字证书实现文件的加密和解密操作。RSA是一种非对称加密算法,它的核心在于一对密钥:...

    java获取数字证书信息

    ### Java 获取数字证书信息 在本篇文章中,我们将深入探讨如何使用Java来获取数字证书的信息,包括使用TOMCAT和JDK搭建SSL服务的过程、如何用OpenSSL签发证书以及如何支持第三方CA等内容。 #### 一、使用TOMCAT和...

    java安全通信数字证书

    总结来说,Java提供的安全通信机制包括了消息摘要、消息验证码和数字证书等技术,它们一起确保了在网络通信中的数据安全性和身份认证。通过学习这些知识,开发者可以构建更安全的Java应用程序,保护用户的隐私和信息...

    Certificate_java_java数字签名_java签名证书_数字证书_

    总之,Java数字证书和数字签名是构建安全网络应用的核心技术,这个源码模块提供了一种实际的实现方式,可以帮助开发者更好地理解和应用这些概念。通过深入学习和实践,你可以提升在网络安全领域的专业技能,为构建更...

    Java加密和数字签名编程快速入门.rar_Java加密_java 数字 签名_java 数字签名_数字 签名_数字签名

    通过阅读"Java加密和数字签名编程快速入门",无论是初学者还是有一定经验的开发者,都能掌握Java中加密和数字签名的基本原理和实际应用。"www.pudn.com.txt"可能是提供额外链接或资源的文本文件,而"Java加密和数字...

    JAVA 用代码生成数字证书源码

    在Java编程环境中,生成数字证书是一项关键的安全技术,主要用于数据加密、身份验证和签名等应用场景。数字证书通常包含了公钥和私钥对,以及证书持有者的相关信息,这些信息经过认证机构(CA)的签名,确保了证书的...

    java加密技术大全

    Java加密技术是保护数据安全的重要工具,广泛应用于网络通信、数据存储、数字签名等领域。本资源包涵盖了Java中常见的加密算法和技术,包括基础的哈希算法、对称加密、非对称加密以及证书签名和SSL/TLS协议。下面将...

    Java 数字签名、数字证书生成源码.7z

    Java 数字签名与数字证书是网络安全领域中的重要概念,它们在确保数据的完整性和来源的可信性方面扮演着关键角色。在这个"Java 数字签名、数字证书生成源码"压缩包中,包含了实现这些功能的源代码,对于理解Java安全...

    java加密技术

    Java加密技术是Java编程语言中用于保障数据安全的一系列加密方法和技术,它包括了单向加密算法、对称加密算法、非对称加密算法以及加密算法的高级应用如数字签名和数字证书等。本文将详细介绍这些加密技术,并结合...

    java 国密算法实现包含SM2 SM3 SM4和数字签名、数字证书的验证

    下面将详细介绍这些算法以及它们在Java中的实现,以及如何进行数字签名和数字证书的验证。 1. **SM2算法**:SM2是一种基于椭圆曲线密码学(ECC)的公钥加密算法,用于非对称加密。它提供了密钥交换、签名和验证的...

    java加密技术 (网页版)

    总结来说,这个"java加密技术"资源涵盖了基础和高级的加密算法,包括Base64、DES、AES、RSA,以及哈希函数和证书管理。通过学习这些内容,开发者可以更好地理解和应用加密技术,提升系统的安全性。

    Java 数字签名、数字证书生成源码.zip

    Java 数字签名和数字证书是网络安全领域中的重要概念,它们在确保数据的完整性和来源的可信性方面扮演着关键角色。这份"Java 数字签名、数字证书生成源码"的压缩包提供了实现这些功能的代码示例,对于理解和应用Java...

    Java加密和数字签名编程快速入门

    总的来说,Java加密和数字签名编程是构建安全应用的关键技术,它涉及到密码学原理和Java的加密API。通过这个快速入门,你可以获得基本的理解,并为进一步深入学习打下坚实的基础。在实践中不断探索,你将能够熟练地...

    Java加密技术(技巧与实例) pdf.rar

    Java加密技术是软件开发中一个至关重要的领域,特别是在保护数据安全、验证信息完整性和实现安全通信方面。本书“Java加密技术(技巧与实例)”深入浅出地探讨了这一主题,为开发者提供了丰富的实践指导。以下是一些...

    Java加密技术

    Java加密技术是软件开发中一个重要的领域,尤其是在处理敏感数据、网络安全和隐私保护时不可或缺。在Java中,加密主要依赖于Java Cryptography Architecture (JCA) 和 Java Cryptography Extension (JCE)。JCA提供了...

Global site tag (gtag.js) - Google Analytics