`
crazier9527
  • 浏览: 1008761 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Java加密技术（八）

    博客分类：
  • Java
JavaTomcatSecurityjunit算法 
阅读更多
    本篇的主要内容为Java证书体系的实现。

请大家在阅读本篇内容时先阅读 Java加密技术（四），预先了解RSA加密算法。

在构建Java代码实现前，我们需要完成证书的制作。
1.生成keyStroe文件
在命令行下执行以下命令：
Shell代码 复制代码
  1. keytool -genkey -alias tomcat -keyalg RSA -keystore d:\.keystore  
keytool -genkey -alias tomcat -keyalg RSA -keystore d:\.keystore

其中-genkey表示生成密钥 -alias指定别名，这里是tomcat -keyalg指定算法，这里是RSA -keystore指定存储位置，这里是d:\.keystore
在这里我使用的密码为 123456
控制台输出：
Console代码 复制代码
  1. 输入keystore密码：   
  2. 再次输入新密码:   
  3. 您的名字与姓氏是什么？   
  4.   [Unknown]：  zlex   
  5. 您的组织单位名称是什么？   
  6.   [Unknown]：  zlex   
  7. 您的组织名称是什么？   
  8.   [Unknown]：  zlex   
  9. 您所在的城市或区域名称是什么？   
  10.   [Unknown]：  BJ   
  11. 您所在的州或省份名称是什么？   
  12.   [Unknown]：  BJ   
  13. 该单位的两字母国家代码是什么   
  14.   [Unknown]：  CN   
  15. CN=zlex, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN 正确吗？   
  16.   [否]：  Y   
  17.   
  18. 输入<tomcat>的主密码   
  19.         （如果和 keystore 密码相同，按回车）：   
  20. 再次输入新密码:  
输入keystore密码：
再次输入新密码:
您的名字与姓氏是什么？
  [Unknown]：  zlex
您的组织单位名称是什么？
  [Unknown]：  zlex
您的组织名称是什么？
  [Unknown]：  zlex
您所在的城市或区域名称是什么？
  [Unknown]：  BJ
您所在的州或省份名称是什么？
  [Unknown]：  BJ
该单位的两字母国家代码是什么
  [Unknown]：  CN
CN=zlex, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN 正确吗？
  [否]：  Y

输入<tomcat>的主密码
        （如果和 keystore 密码相同，按回车）：
再次输入新密码:

这时，在D盘下会生成一个.keystore的文件。

2.生成证书
光有keyStore文件是不够的，还需要证书文件，证书才是直接提供给外界使用的公钥凭证。
导出证书：
Shell代码 复制代码
  1. keytool -export -keystore d:\.keystore -alias tomcat -file d:\tomcat.cer  
keytool -export -keystore d:\.keystore -alias tomcat -file d:\tomcat.cer

其中 -export指定为导出操作 -keystore指定keystore文件 -alias指定导出keystore文件中的别名 -file指向导出路径

这里的密码是 123456
控制台输出：
Console代码 复制代码
  1. 输入keystore密码：   
  2. 保存在文件中的认证 <d:\tomcat.cer>  
输入keystore密码：
保存在文件中的认证 <d:\tomcat.cer>


当然，使用方是需要注册证书的！

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

通过java代码实现如下：Coder类见 Java加密技术（一）
Java代码 复制代码
  1. import java.io.FileInputStream;   
  2. import java.security.KeyFactory;   
  3. import java.security.KeyStore;   
  4. import java.security.PrivateKey;   
  5. import java.security.PublicKey;   
  6. import java.security.Signature;   
  7. import java.security.cert.Certificate;   
  8. import java.security.cert.CertificateFactory;   
  9. import java.security.cert.X509Certificate;   
  10. import java.security.spec.PKCS8EncodedKeySpec;   
  11. import java.security.spec.X509EncodedKeySpec;   
  12. import java.util.Date;   
  13.   
  14. /**  
  15.  * 证书组件  
  16.  *   
  17.  * @author 梁栋  
  18.  * @version 1.0  
  19.  * @since 1.0  
  20.  */  
  21. public abstract class CertificateCoder extends Coder {   
  22.   
  23.     /**  
  24.      * Java密钥库(Java Key Store，JKS)KEY_STORE  
  25.      */  
  26.     public static final String KEY_STORE = "JKS";   
  27.   
  28.     public static final String X509 = "X.509";   
  29.   
  30.     /**  
  31.      * 由KeyStore获得私钥  
  32.      *   
  33.      * @param keyStorePath  
  34.      * @param alias  
  35.      * @param password  
  36.      * @return  
  37.      * @throws Exception  
  38.      */  
  39.     public static String getPrivateKey(String keyStorePath, String alias,   
  40.             String password) throws Exception {   
  41.         KeyStore ks = getKeyStore(keyStorePath, alias, password);   
  42.         PrivateKey key = (PrivateKey) ks.getKey(alias, password.toCharArray());   
  43.         return encryptBASE64(key.getEncoded());   
  44.     }   
  45.   
  46.     /**  
  47.      * 由Certificate获得公钥  
  48.      *   
  49.      * @param certificatePath  
  50.      * @return  
  51.      * @throws Exception  
  52.      */  
  53.     public static String getPublicKey(String certificatePath) throws Exception {   
  54.         Certificate certificate = getCertificate(certificatePath);   
  55.         PublicKey key = certificate.getPublicKey();   
  56.         return encryptBASE64(key.getEncoded());   
  57.     }   
  58.   
  59.     /**  
  60.      * 获得Certificate  
  61.      *   
  62.      * @param certificatePath  
  63.      * @return  
  64.      * @throws Exception  
  65.      */  
  66.     private static Certificate getCertificate(String certificatePath)   
  67.             throws Exception {   
  68.         CertificateFactory certificateFactory = CertificateFactory   
  69.                 .getInstance(X509);   
  70.         FileInputStream in = new FileInputStream(certificatePath);   
  71.   
  72.         Certificate certificate = certificateFactory.generateCertificate(in);   
  73.         in.close();   
  74.   
  75.         return certificate;   
  76.     }   
  77.   
  78.     /**  
  79.      * 获得Certificate  
  80.      *   
  81.      * @param keyStorePath  
  82.      * @param alias  
  83.      * @param password  
  84.      * @return  
  85.      * @throws Exception  
  86.      */  
  87.     private static Certificate getCertificate(String keyStorePath,   
  88.             String alias, String password) throws Exception {   
  89.         KeyStore ks = getKeyStore(keyStorePath, alias, password);   
  90.         Certificate certificate = ks.getCertificate(alias);   
  91.   
  92.         return certificate;   
  93.     }   
  94.   
  95.     /**  
  96.      * 获得KeyStore  
  97.      *   
  98.      * @param keyStorePath  
  99.      * @param alias  
  100.      * @param password  
  101.      * @return  
  102.      * @throws Exception  
  103.      */  
  104.     private static KeyStore getKeyStore(String keyStorePath, String alias,   
  105.             String password) throws Exception {   
  106.         FileInputStream is = new FileInputStream(keyStorePath);   
  107.         KeyStore ks = KeyStore.getInstance(KEY_STORE);   
  108.         ks.load(is, password.toCharArray());   
  109.         is.close();   
  110.         return ks;   
  111.     }   
  112.   
  113.     /**  
  114.      * 验证Certificate  
  115.      *   
  116.      * @param certificatePath  
  117.      * @return  
  118.      */  
  119.     public static boolean verifyCertificate(String certificatePath) {   
  120.         return verifyCertificate(new Date(), certificatePath);   
  121.     }   
  122.   
  123.     /**  
  124.      * 验证Certificate是否过期或无效  
  125.      *   
  126.      * @param date  
  127.      * @param certificatePath  
  128.      * @return  
  129.      */  
  130.     public static boolean verifyCertificate(Date date, String certificatePath) {   
  131.         boolean status = true;   
  132.         try {   
  133.             // 取得证书   
  134.             Certificate certificate = getCertificate(certificatePath);   
  135.             // 验证证书是否过期或无效   
  136.             status = verifyCertificate(date, certificate);   
  137.         } catch (Exception e) {   
  138.             status = false;   
  139.         }   
  140.         return status;   
  141.     }   
  142.   
  143.     /**  
  144.      * 验证公钥是否同属该证书  
  145.      *   
  146.      * @param publicKey  
  147.      * @param certificatePath  
  148.      * @return  
  149.      */  
  150.     public static boolean verifyPublicKey(String publicKey,   
  151.             String certificatePath) {   
  152.         boolean status = true;   
  153.         try {   
  154.             Certificate certificate = getCertificate(certificatePath);   
  155.   
  156.             // 对公钥解密   
  157.             byte[] keyBytes = decryptBASE64(publicKey);   
  158.   
  159.             // 取得公钥   
  160.             X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);   
  161.             KeyFactory keyFactory = KeyFactory.getInstance(certificate   
  162.                     .getPublicKey().getAlgorithm());   
  163.             PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);   
  164.   
  165.             certificate.verify(pubKey);   
  166.   
  167.         } catch (Exception e) {   
  168.             status = false;   
  169.         }   
  170.         return status;   
  171.     }   
  172.   
  173.     /**  
  174.      * 验证证书是否过期或无效  
  175.      *   
  176.      * @param date  
  177.      * @param certificate  
  178.      * @return  
  179.      */  
  180.     private static boolean verifyCertificate(Date date, Certificate certificate) {   
  181.         boolean status = true;   
  182.         try {   
  183.             X509Certificate x509Certificate = (X509Certificate) certificate;   
  184.             x509Certificate.checkValidity(date);   
  185.         } catch (Exception e) {   
  186.             status = false;   
  187.         }   
  188.         return status;   
  189.     }   
  190.   
  191.     /**  
  192.      * 签名  
  193.      * @param keyStorePath  
  194.      * @param privateKey  
  195.      * @param alias  
  196.      * @param password  
  197.      * @return  
  198.      * @throws Exception  
  199.      */  
  200.     public static String sign(byte[] sign, String keyStorePath, String privateKey,   
  201.             String alias, String password) throws Exception {   
  202.         // 获得证书   
  203.         X509Certificate x509Certificate = (X509Certificate) getCertificate(   
  204.                 keyStorePath, alias, password);   
  205.         // 解密由base64编码的私钥   
  206.         byte[] keyBytes = decryptBASE64(privateKey);   
  207.   
  208.         // 构造PKCS8EncodedKeySpec对象   
  209.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);   
  210.   
  211.         // 由证书公钥获得对应加密算法   
  212.         KeyFactory keyFactory = KeyFactory.getInstance(x509Certificate   
  213.                 .getPublicKey().getAlgorithm());   
  214.   
  215.         // 获取私钥   
  216.         PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);   
  217.   
  218.         // 构建签名   
  219.         Signature signature = Signature.getInstance(x509Certificate   
  220.                 .getSigAlgName());   
  221.         signature.initSign(priKey);   
  222.         signature.update(sign);   
  223.         return encryptBASE64(signature.sign());   
  224.     }   
  225.   
  226.     /**  
  227.      * 验证签名  
  228.      *   
  229.      * @param data  
  230.      * @param sign  
  231.      * @param certificatePath  
  232.      * @return  
  233.      * @throws Exception  
  234.      */  
  235.     public static boolean verify(byte[] data, String sign,   
  236.             String certificatePath) throws Exception {   
  237.         // 获得证书   
  238.         X509Certificate x509Certificate = (X509Certificate) getCertificate(certificatePath);   
  239.         // 获得公钥   
  240.         PublicKey publicKey = x509Certificate.getPublicKey();   
  241.         // 构建签名   
  242.         Signature signature = Signature.getInstance(x509Certificate   
  243.                 .getSigAlgName());   
  244.         signature.initVerify(publicKey);   
  245.         signature.update(data);   
  246.   
  247.         return signature.verify(decryptBASE64(sign));   
  248.   
  249.     }   
  250.   
  251.     /**  
  252.      * 验证Certificate  
  253.      *   
  254.      * @param keyStorePath  
  255.      * @param alias  
  256.      * @param password  
  257.      * @return  
  258.      */  
  259.     public static boolean verifyCertificate(Date date, String keyStorePath,   
  260.             String alias, String password) {   
  261.         boolean status = true;   
  262.         try {   
  263.             Certificate certificate = getCertificate(keyStorePath, alias,   
  264.                     password);   
  265.             status = verifyCertificate(date, certificate);   
  266.         } catch (Exception e) {   
  267.             status = false;   
  268.         }   
  269.         return status;   
  270.     }   
  271.   
  272.     /**  
  273.      * 验证Certificate  
  274.      *   
  275.      * @param keyStorePath  
  276.      * @param alias  
  277.      * @param password  
  278.      * @return  
  279.      */  
  280.     public static boolean verifyCertificate(String keyStorePath, String alias,   
  281.             String password) {   
  282.         return verifyCertificate(new Date(), keyStorePath, alias, password);   
  283.     }   
  284. }  
import java.io.FileInputStream;
import java.security.KeyFactory;
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.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Date;

/**
 * 证书组件
 * 
 * @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
	 */
	public static String getPrivateKey(String keyStorePath, String alias,
			String password) throws Exception {
		KeyStore ks = getKeyStore(keyStorePath, alias, password);
		PrivateKey key = (PrivateKey) ks.getKey(alias, password.toCharArray());
		return encryptBASE64(key.getEncoded());
	}

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

	/**
	 * 获得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, alias, password);
		Certificate certificate = ks.getCertificate(alias);

		return certificate;
	}

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

	/**
	 * 验证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 publicKey
	 * @param certificatePath
	 * @return
	 */
	public static boolean verifyPublicKey(String publicKey,
			String certificatePath) {
		boolean status = true;
		try {
			Certificate certificate = getCertificate(certificatePath);

			// 对公钥解密
			byte[] keyBytes = decryptBASE64(publicKey);

			// 取得公钥
			X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
			KeyFactory keyFactory = KeyFactory.getInstance(certificate
					.getPublicKey().getAlgorithm());
			PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

			certificate.verify(pubKey);

		} 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 privateKey
	 * @param alias
	 * @param password
	 * @return
	 * @throws Exception
	 */
	public static String sign(byte[] sign, String keyStorePath, String privateKey,
			String alias, String password) throws Exception {
		// 获得证书
		X509Certificate x509Certificate = (X509Certificate) getCertificate(
				keyStorePath, alias, password);
		// 解密由base64编码的私钥
		byte[] keyBytes = decryptBASE64(privateKey);

		// 构造PKCS8EncodedKeySpec对象
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

		// 由证书公钥获得对应加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(x509Certificate
				.getPublicKey().getAlgorithm());

		// 获取私钥
		PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 构建签名
		Signature signature = Signature.getInstance(x509Certificate
				.getSigAlgName());
		signature.initSign(priKey);
		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);
	}
}


再给出一个测试类：
Java代码 复制代码
  1. import static org.junit.Assert.*;   
  2.   
  3. import org.junit.Before;   
  4. import org.junit.Test;   
  5.   
  6. /**  
  7.  *   
  8.  * @author 梁栋  
  9.  * @version 1.0  
  10.  * @since 1.0  
  11.  */  
  12. public class CertificateCoderTest {   
  13.     private String publicKey;   
  14.     private String privateKey;   
  15.     private String password = "123456";   
  16.     private String alias = "tomcat";   
  17.     private String certificatePath = "D:/tomcat.cer";   
  18.     private String keyStorePath = "D:/.keystore";   
  19.   
  20.     @Before  
  21.     public void setUp() throws Exception {   
  22.         publicKey = CertificateCoder.getPublicKey(certificatePath);   
  23.         privateKey = CertificateCoder.getPrivateKey(keyStorePath, alias,   
  24.                 password);   
  25.         System.err.println("公钥: \n\r" + publicKey);   
  26.         System.err.println("私钥： \n\r" + privateKey);   
  27.   
  28.     }   
  29.   
  30.     @Test  
  31.     public void test() throws Exception {   
  32.         System.err.println("公钥加密——私钥解密");   
  33.         String inputStr = "Ceritificate";   
  34.         byte[] data = inputStr.getBytes();   
  35.   
  36.         byte[] encrypt = RSACoder.encryptByPublicKey(data, publicKey);   
  37.   
  38.         byte[] decrypt = RSACoder.decryptByPrivateKey(encrypt, privateKey);   
  39.         String outputStr = new String(decrypt);   
  40.   
  41.         System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);   
  42.   
  43.         // 验证数据一致   
  44.         assertArrayEquals(data, decrypt);   
  45.   
  46.         // 验证证书有效   
  47.         assertTrue(CertificateCoder.verifyCertificate(certificatePath));   
  48.   
  49.         // 验证证书公钥匹配   
  50.         assertTrue(CertificateCoder.verifyPublicKey(publicKey, certificatePath));   
  51.   
  52.     }   
  53.   
  54.     @Test  
  55.     public void testSign() throws Exception {   
  56.         System.err.println("私钥加密——公钥解密");   
  57.   
  58.         String inputStr = "sign";   
  59.         byte[] data = inputStr.getBytes();   
  60.   
  61.         byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);   
  62.   
  63.         byte[] decodedData = RSACoder   
  64.                 .decryptByPublicKey(encodedData, publicKey);   
  65.   
  66.         String outputStr = new String(decodedData);   
  67.         System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);   
  68.         assertEquals(inputStr, outputStr);   
  69.   
  70.         System.err.println("私钥签名——公钥验证签名");   
  71.         // 产生签名   
  72.         String sign = CertificateCoder.sign(encodedData, keyStorePath, privateKey,   
  73.                 alias, password);   
  74.         System.err.println("签名:\r" + sign);   
  75.   
  76.         // 验证签名   
  77.         boolean status = CertificateCoder.verify(encodedData, sign, certificatePath);   
  78.         System.err.println("状态:\r" + status);   
  79.         assertTrue(status);   
  80.   
  81.     }   
  82. }  
import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

/**
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public class CertificateCoderTest {
	private String publicKey;
	private String privateKey;
	private String password = "123456";
	private String alias = "tomcat";
	private String certificatePath = "D:/tomcat.cer";
	private String keyStorePath = "D:/.keystore";

	@Before
	public void setUp() throws Exception {
		publicKey = CertificateCoder.getPublicKey(certificatePath);
		privateKey = CertificateCoder.getPrivateKey(keyStorePath, alias,
				password);
		System.err.println("公钥: \n\r" + publicKey);
		System.err.println("私钥： \n\r" + privateKey);

	}

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

		byte[] encrypt = RSACoder.encryptByPublicKey(data, publicKey);

		byte[] decrypt = RSACoder.decryptByPrivateKey(encrypt, privateKey);
		String outputStr = new String(decrypt);

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

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

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

		// 验证证书公钥匹配
		assertTrue(CertificateCoder.verifyPublicKey(publicKey, certificatePath));

	}

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

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

		byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);

		byte[] decodedData = RSACoder
				.decryptByPublicKey(encodedData, publicKey);

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

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

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

	}
}


控制台输出：
Console代码 复制代码
  1. 公钥:    
  2.   
  3. MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDBQ/VMxf5Sb+urKceu5Ja4GfxHso+i+CCpQV2c   
  4. W/O0yyu6u//7emmbwQGV3BLvaq9hEav1yGdvBteITS+mKMQFr2vFMsxhs+Dh82haQF2CXm11KtOg   
  5. 2cjN6zgRmPVdYndVjeq7I9z+lkyHYZsOFUGr+oiPcas2Y9fa07TEfM4LXwIDAQAB   
  6.   
  7. 私钥：    
  8.   
  9. MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAMFD9UzF/lJv66spx67klrgZ/Eey   
  10. j6L4IKlBXZxb87TLK7q7//t6aZvBAZXcEu9qr2ERq/XIZ28G14hNL6YoxAWva8UyzGGz4OHzaFpA   
  11. XYJebXUq06DZyM3rOBGY9V1id1WN6rsj3P6WTIdhmw4VQav6iI9xqzZj19rTtMR8zgtfAgMBAAEC   
  12. gYEAlB0y932d5SvlHy5L3JtPbxRrJb+RGUK0NULlLRnDckFq6BeAnQg5u6Z1QpaA5H+MnQXgFeNa   
  13. cdp6f/k3lU4UuzgGbt0A31hRlR7J0WjsutkrDJp4h6PD9OIJSblv2T+h7KHzMKY7kx8dn4CIg2Cm   
  14. 9NCyJWmhglGaf4Nl/6e4FdECQQD18SLbOxndmyHd5OU88oIY/qAyngQJIqcyHOwgwcLd5G/M3h0H   
  15. bEj2fEKa4y2EG1xCH4MQSu0aRrR+ihv+thRjAkEAyStUwkyaNUE06ioGWCYu26QTcLyRwMyuVTcE   
  16. jLbD6wRLF7A3gx9dgSV8mO1VqJ1G9y379YenzLz89MFHOTwn1QJBALNEcx3NtIrdexAcuiN0uPOz   
  17. Fd4PY+2svqY+grdVxM6spfl0pUA14/EWng38Lb8vmk3wXj5P/we6JfJehQ1idvUCQQCTohkx/sWt   
  18. D42ly/Gb/2mkB2W89qaAt7W5FAdivT5K23vAhrI2qG4WuUwXbxXOCJ5sCHNAXa3ns0pw1OdQObWB   
  19. AkBm7JAy3jUh6xiEdI+SWnJ9V/k5bqenkN930uDFdqc6FzfOTgd3RVnckfpdCkEmo8AmeUQZwZ3y   
  20. g4Xlfjray07N   
  21.   
  22. 公钥加密——私钥解密   
  23. 加密前: Ceritificate   
  24.   
  25. 解密后: Ceritificate   
  26. 公钥:    
  27.   
  28. MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDBQ/VMxf5Sb+urKceu5Ja4GfxHso+i+CCpQV2c   
  29. W/O0yyu6u//7emmbwQGV3BLvaq9hEav1yGdvBteITS+mKMQFr2vFMsxhs+Dh82haQF2CXm11KtOg   
  30. 2cjN6zgRmPVdYndVjeq7I9z+lkyHYZsOFUGr+oiPcas2Y9fa07TEfM4LXwIDAQAB   
  31.   
  32. 私钥：    
  33.   
  34. MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAMFD9UzF/lJv66spx67klrgZ/Eey   
  35. j6L4IKlBX
    分享到：
    | Java加密技术（七）
    评论
    发表评论

    您还没有登录,请您登录后再发表评论

相关推荐

    Java加密技术

    Java加密技术

    java加密技术详解

    ### Java加密技术详解：以MD5为例 在Java中，加密技术是确保数据安全和完整性的关键工具之一。本文将深入探讨Java中的加密技术，特别是MD5加密算法，通过实例和代码片段，帮助读者理解其工作原理及如何在实际项目中...

    基于JAVA的加密算法（包括10种加密技术）

    Java加密技术（一） 关键字: java 加密基础, base64, md5, mac, sha, 单向加密 。。。。。。。。。。。。。。

    java加密技术大全

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

    java加密技术 （网页版）

    Java加密技术是软件开发中一个重要的安全领域，主要用于保护数据的隐私性和完整性。在这个网页版的资源中，可能涵盖了各种加密算法的Java实现，以及它们之间的比较。让我们深入探讨一下这些知识点。 首先，我们来看...

    运用加密技术保护java源代码

    因此，运用加密技术保护Java源代码成为了一项重要的课题。 ### Java源代码加密的重要性 Java源代码加密主要涉及两个层面：一是源代码本身的安全，二是编译后的字节码（.class文件）的安全。对于源代码，加密可以...

    JAVA加密技术.docx

    在Java编程中，加密技术是确保信息安全的关键组成部分。本文将探讨几种常见的加密算法，包括单向加密和对称及非对称加密算法。首先，我们来看基础的单向加密算法，如BASE64、MD5、SHA和HMAC。 **BASE64** 是一种...

    java加密技术研究

    java加密技术研究

    Java加密技术(一)

    总之，Java加密技术提供了丰富的工具和算法，可以帮助开发者构建安全的应用程序。然而，随着技术的发展，加密算法的安全性也需要不断更新，以抵御新的攻击手段。在设计系统时，应考虑最新的安全标准和最佳实践，确保...

    java加密技术

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

    Java加密技术(四)

    总结来说，Java加密技术第四部分主要介绍了ECC加密技术的概念、其在Java中的有限支持，以及如何通过Java代码实现ECC的加密和解密操作。尽管Java的标准实现并不直接支持ECC的加密/解密，但可以通过扩展和利用非公开...

    Java加密技术全集

    Java加密技术是信息安全领域的重要组成部分，它用于保护数据的隐私性和完整性。在这个“Java加密技术全集”中，我们将会探讨MD5、SHA和BASE64等常见的加密算法及其在Java中的实现。 MD5（Message-Digest Algorithm ...

    Java加密技术(三)

    Java加密技术(三),相当有用的加密技术(三)，值得学习参考！希望对你有点帮助！

    Java加密技术 pdf版

    Java加密技术 pdf版 加密解密，曾经是我一个毕业设计的重要组件。在工作了多年以后回想当时那个加密、解密算法，实在是太单纯了。 言归正传，这里我们主要描述Java已经实现的一些加密解密算法，最后介绍数字证书

    Java加密技术（技巧与实例） pdf.rar

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

    Java加密技术MD5/BASE64等加密技术

    Java加密技术是软件开发中的重要组成部分，特别是在保护数据安全、用户隐私以及确保网络通信的完整性方面。本资源主要关注两种常见的加密算法：MD5（Message-Digest Algorithm 5）和BASE64编码，它们在Java中有着...

Magicbox
Global site tag (gtag.js) - Google Analytics