JAVA数字证书

在构建Java代码实现前，我们需要完成证书的制作。 
1.生成keyStroe文件 
在命令行下执行以下命令：

keytool -genkey -validity 36000 -alias jlxrsa -keyalg RSA -keystore d:\jlxrsz.keystore

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

在这里我使用的密码为 123456

2.生成自签名证书 
光有keyStore文件是不够的，还需要证书文件，证书才是直接提供给外界使用的公钥凭证。 
导出证书：

keytool -export -keystore d:\jlxrsa.keystore -alias jlxrsa -file d:\jlxrsa.cer -rfc

其中 
-export指定为导出操作 
-keystore指定keystore文件 
-alias指定导出keystore文件中的别名 
-file指向导出路径 
-rfc以文本格式输出，也就是以BASE64编码输出 
这里的密码是 123456

Ok，准备工作完成，开始Java实现！

package cert;

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);  

    }
}

　　

package cert;

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 cert;

import static org.junit.Assert.*;

import org.junit.Test;  

/**
 *
 * @author
 * @version 1.0
 * @since 1.0
 */
public class CertificateCoderTest {
    private String password = "123456";
    private String alias = "jlxrsa";
    private String certificatePath = "d:/jlx.cer";
    private String keyStorePath = "d:/jlx.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);  

    }
}

　　

时间： 2024-08-04 03:34:07

JAVA数字证书的相关文章

JAVA数字证书制作生成

1.加密算法 为了网络通讯中的报文安全,一般需要对报文进行加密,目前常用的加密算法有: 非对称加密算法:又称公钥加密算法,如RSA.DSA/DSS,最常用的就是RSA算法(算法公开,可自行百度了解算法细节),算法产生一个公钥一个私钥,用公钥加密的报 文只能用私钥解密,用私钥加密的报文只能用公钥解密: 对称加密算法:3DES.AES.RC4,加密密钥与解密密钥相同,一般用于只有通讯双方知道密钥的通讯方式: HASH算法:MD5.SHA1.SHA256,由哈希算法计划得到哈希值,加密过程不可逆,由哈

如何用JAVA代码签发数字证书

用JAVA签发数字证书 打开cmd 1.输入D: 2.输入cd keys 3.输入命令查看创建的密钥库的证书列表 keytool -list -v -keystore mykey.keystore -storepass 123456 4. 之前导出过server.cer文件,把这个文件安装到操作系统,过程默认. 5.创建一个密钥对,和之前一样,输入如下命令: --创建密钥对 keytool -genkey -dname "CN=tmp, OU=NC, O=Shanghai University,

【Java】Java与数字证书

Java与数字证书 Java与数字证书 证书的签发和应用 证书的内容和意义 其它 证书(Certificate,也称public-key certificate)是用某种签名算法对某些内容(比如公钥)进行数字签名后得到的.可以用来当成信任关系中介的数字凭证.证书发行机构通过发行证书告知证书使用者或实体其公钥(public-key)以及其它一些辅助信息.证书在电子商务安全交易中有着广泛的应用,证书发行机构也称CA(Certificate Authority). 证书的签发和应用 证书在公钥加密应用

Java加密解密与数字证书的操作

1 keytool命令总结 一.创建数字证书 交互模式 使用默认的密钥库.keystore(文件夹是c: Documents and Settingusername)和算法(DSA) keytool -genkey 默认的别名mykey 密钥库中能够存放多个条目(公钥/私钥对和证书),它们在密钥库中以别名(alias)区分. [plain] view plaincopy keytool -genkey -alias mytest -keyalg RSA -keysize 1024 -keysto

Java安全之数字证书

在前面说到,消息摘要用于验证数据完整性,对称与非对称加密用于保证数据保密性,数据签名用于数据的抗否认性,于是集这些安全手段于一身的终极武器--数字证书出现了.数字证书具备了加密/解密的必要信息,包含签名算法,可用于网络数据加密/解密交互,标识网络用户(计算机)身份.数据证书为发布公钥提供了一种简便途径,成为加密算法以及公钥的载体. 数字证书有多种文件编码格式,主要包含CER编码.DER编码等: a.CER(Canonical Encoding Rules,规范编码格式),是数字证书的一种编码格式

Java 生成数字证书系列（二）剖析数字证书

序 上一篇介绍了一下 CA 证书的几个相关概念,这几个概念还是很重要的,目的在于了解数字证书,以及其的工作原理.这篇文章主要是对 CA 证书进行剖析,讲一下证书的基本构成,这对于生成正确的.可以访问的证书是必不可少的. 构成 废话不多说,直接上内容. 先看一下证书到底是什么,在 Windows 下查看证书时(这里以 cer 为例),界面是这样的. 常规 选项卡里,主要介绍了证书信息,颁发者,和有效日期等. 而 详细信息 选项卡中,包含的信息是比较多的,他们都是以一种 Key - Value 的形

java加密与数字证书

加密与数字证书 加密与数字证书 概念 数字摘要 密钥加密技术 私用密钥(对称加密) 公共密钥(非对称加密) 数字签名 数字证书 X.509标准 工具 keytool 示例代码 加密解密 密钥库准备 代码 签名验签 代码 概念 数字摘要 数字摘要就是采用单项Hash函数将需要加密的明文"摘要"成一串固定长度(128位)的密文,这一串密文又称为数字指纹,HASH值或摘要值 ,它有固定的长度,而且不同的明文摘要成密文,其结果总是不同的,而同样的明文其摘要必定一致. 目前常用的摘要算法为MD5

Java 生成数字证书系列（四）生成数字证书（续）

序 上一篇文章讲到了 Java 生成数字证书,使用的是第三方的组件 BC .这篇文章也是介绍生成数字证书的,只不过与上一篇不同的是,这篇采用的是 KeyStore 的存储方式,导出的证书文件格式为 pfx ,这种格式的证书不仅包含有公钥,还包含有私钥.从证书中就可以读取到私钥. 正文 废话不多说,直接上内容. 与上一篇相同,这里也是使用的 Bouncy Castle 提供的组件,不同的是,这里的证书采用的是公钥加密技术12号标准生成的,简写 PKCS12 .具体内容这里就不再详细的介绍了,有需要

Java 密钥库和数字证书

密钥库中可以存放多个条目(公钥/私钥对和证书),它们在密钥库中以别名(alias)区分. 1.cd C:\Program Files (x86)\Java\jdk1.6.0_10\bin 2.生成签名证书:keytool -genkey -v -keystore android.keystore -alias android -keyalg RSA -validity 20000 [-genkey:生成密钥] [-keystore:指定存储位置可加上路径C:\Users\dxcb\android