现在我们深度了解一下现有的安全网络通信——SSL。
keytool -import -alias lee -file d:/lee.cer -keystore d:/lee-client.keystore
其中
-import表示导入 -alias指定别名，这里是lee-file指定算法，这里是d:/lee.cer -keystore指定存储位置，这里是d:/lee-client.keystore 在这里我使用的密码为123456
输入密钥库口令:
再次输入新口令:
所有者: CN=lee, OU=lee, O=ruiqi, L=ruiqi, ST=taiyuan, C=CN
发布者: CN=lee, OU=lee, O=ruiqi, L=ruiqi, ST=taiyuan, C=CN
序列号: 4b29e6d5
有效期开始日期: Mon May 05 20:19:45 CST 2014, 截止日期: Sun Nov 27 20:19:45 CST
112
证书指纹:
MD5: 90:0A:97:C2:D8:C6:59:2A:F7:0D:91:07:0B:16:AA:00
SHA1: 93:A2:EF:0E:D0:9D:71:D7:30:CC:5F:34:CC:7E:1D:2A:11:75:BF:26
SHA256: C9:52:14:C9:A9:FF:DC:A6:83:36:C3:E0:B9:F6:09:71:55:DD:87:85:99
4:DC:EC:56:7C:74:F7:B1:B4:98:A0
签名算法名称: SHA256withRSA
版本: 3
扩展:
#1: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: 62 1B BB 3A 65 8C 55 93 17 76 5A 7B A1 46 99 F1 b..:e.U..vZ..F..
0010: 4E FB 86 9B N...
]
]
是否信任此证书? [否]: Y
OK，最复杂的准备工作已经完成。
OK，最复杂的准备工作已经完成。
接下来我们将域名lee定位到本机上。打开C:\Windows\System32\drivers\etc\hosts文件，将lee绑定在本机上。在文件末尾追加127.0.0.1 lee。
现在，配置tomcat。先将zlex.keystore拷贝到tomcat的conf目录下，然后配置server.xml。将如下内容加入配置文件
<Connector
SSLEnabled="true"
URIEncoding="UTF-8"
clientAuth="false"
keystoreFile="conf/lee.keystore"
keystorePass="123456"
maxThreads="150"
port="8443"
protocol="HTTP/1.1"
scheme="https"
secure="true"
sslProtocol="TLS" />
现在启动tomcat，访问https://lee:8443
显然，证书未能通过认证，这个时候你可以选择安装证书（上文中的lee.cer文件就是证书），作为受信任的根证书颁发机构导入，再次重启浏览器（IE，其他浏览器对于域名www.zlex.org不支持本地方式访问），访问https://lee:8443，你会看到地址栏中会有个小锁
，就说明安装成功。所有的浏览器联网操作已经在RSA加密解密系统的保护之下了。但似乎我们感受不到。
这个时候很多人开始怀疑，如果我们要手工做一个这样的https的访问是不是需要把浏览器的这些个功能都实现呢？不需要！
接着上篇内容，给出如下代码实现
package com.lee.encrypt;
import java.io.FileInputStream;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
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 javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManagerFactory;
/**
* 证书组件
*
* @author lee
* @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";
public static final String SunX509 = "SunX509";
public static final String SSL = "SSL";
/**
* 由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);
}
/**
* 获得SSLSocektFactory
*
* @param password
* 密码
* @param keyStorePath
* 密钥库路径
*
* @param trustKeyStorePath
* 信任库路径
* @return
* @throws Exception
*/
private static SSLSocketFactory getSSLSocketFactory(String password, String keyStorePath, String trustKeyStorePath) throws Exception {
// 初始化密钥库
KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(SunX509);
KeyStore keyStore = getKeyStore(keyStorePath, password);
keyManagerFactory.init(keyStore, password.toCharArray());
// 初始化信任库
TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(SunX509);
KeyStore trustkeyStore = getKeyStore(trustKeyStorePath, password);
trustManagerFactory.init(trustkeyStore);
// 初始化SSL上下文
SSLContext ctx = SSLContext.getInstance(SSL);
ctx.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), new SecureRandom());
SSLSocketFactory sf = ctx.getSocketFactory();
return sf;
}
/**
* 为HttpsURLConnection配置SSLSocketFactory
*
* @param conn
* HttpsURLConnection
* @param password
* 密码
* @param keyStorePath
* 密钥库路径
*
* @param trustKeyStorePath
* 信任库路径
* @throws Exception
*/
public static void configSSLSocketFactory(HttpsURLConnection conn, String password, String keyStorePath, String trustKeyStorePath)
throws Exception {
conn.setSSLSocketFactory(getSSLSocketFactory(password, keyStorePath, trustKeyStorePath));
}
}
增加了configSSLSocketFactory方法供外界调用，该方法为HttpsURLConnection配置了SSLSocketFactory。当HttpsURLConnection配置了SSLSocketFactory后，我们就可以通过HttpsURLConnection的getInputStream、getOutputStream，像往常使用HttpURLConnection做操作了。尤其要说明一点，未配置SSLSocketFactory前，HttpsURLConnection的getContentLength()获得值永远都是-1。
测试代码如下：
package com.lee.encrypt;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.io.DataInputStream;
import java.io.File;
import java.io.InputStream;
import java.net.URL;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import org.apache.commons.io.FileUtils;
import org.junit.Ignore;
import org.junit.Test;
/**
*
* @author lee
* @version 1.0
* @since 1.0
*/
public class CertificateCoderTest{
private String password = "123456";
private String alias = "lee";
private String certificatePath = "d:/lee.cer";
private String keyStorePath = "d:/lee.keystore";
private String clientKeyStorePath = "d:/lee-client.keystore";
private String clientPassword = "123456";
@Test
@Ignore
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
@Ignore
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);
}
@Test
public void testHttps() throws Exception {
URL url = new URL("https://lee:8443");
HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
conn.setDoInput(true);
conn.setDoOutput(true);
CertificateCoder.configSSLSocketFactory(conn, clientPassword, clientKeyStorePath, clientKeyStorePath);
InputStream is = conn.getInputStream();
StringBuffer out = new StringBuffer();
byte[] b = new byte[4096];
for (int n; (n = is.read(b)) != -1;) {
out.append(new String(b, 0, n));
}
System.out.println(out.toString());
conn.disconnect();
}
}
分享到：
相关推荐
在计算机软件开发中，Java编程语言的应用是极为广泛与深远的。Java语言自问世以来就以其独特的特性和优势吸引...随着技术的不断发展和Java社区的持续壮大，Java编程语言在未来的软件开发中仍将展现出其不可替代的光芒。
此外，Java的加密库（如Java Cryptography Extension, JCE）提供了强大的加密功能，保证了数据的安全传输和存储。 在移动开发领域，Android操作系统大量使用Java作为开发语言。通过Android Studio和相关的SDK，...
### Java加密技术详解 #### 一、BASE64与单向加密算法MD5&SHA&MAC ##### BASE64 BASE64是一种编码格式，并非真正的加密算法。它主要用于将二进制数据转换成文本格式的数据，以便在网络上传输。由于某些传输协议只...
数据加密技术作为保护网络通信安全的核心手段，其作用不可忽视。本文将深入探讨数据加密技术在计算机网络通信中的应用及其重要性。 首先，我们要理解计算机网络通信的基本概念。计算机网络是指通过物理链路将多台...
基于游戏开发的Java语言教学初探 本文讨论了基于游戏开发的Java语言教学初探，旨在探讨如何培养学生的理论能力、分析能力、开发能力和实践能力。文章从教学设想和开发工具两个方面入手，介绍了Java语言的游戏构架、...
Java教学方法初探 Java课程是一门实践性课程，旨在培养学生的学习兴趣和应用知识能力。本文结合实际教学经验，探讨了Java教学方法的几点思考。 首先，学习兴趣的培养是至关重要的。只有当学生对学习内容产生兴趣时...
这篇"基于游戏开发的Java语言教学初探"主题探讨了如何将Java语言的学习与游戏开发相结合，以提高学生的学习兴趣和编程技能。游戏开发是一个综合性的过程，涉及到图形渲染、物理模拟、人工智能、网络通信等多个方面，...
高职Java课程设计初探 本文探讨高职院校Java课程设计的重要性和实施策略。课程建设与改革是高职院校提高教学质量的核心，也是教学改革的重点和难点。长期以来，传统学科性课程始终统治着我国的职业教育，但职业教育...
【基于游戏开发的Java语言教学初探】 Java语言教学在当今计算机教育中占有重要地位，尤其是在高校的程序设计课程中。然而，Java的学习曲线相对较陡，理论知识复杂且理论部分可能显得枯燥，这使得激发学生的学习兴趣...
【PGP加密解密技术初探与实践】 PGP（Pretty Good Privacy）是一种广泛应用的加密解密工具，基于公钥密码学原理，尤其是RSA算法。RSA由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出，是现代密码学的基石之...
COM技术初探.doc
同态加密技术是一种在加密数据上直接执行计算的高级加密技术，它允许用户对密文进行操作，而无需先解密。这种技术的核心优势在于它能够保护数据的隐私，同时保持计算过程的可行性，这对于云计算、大数据分析以及...
计算机网络通信安全是当前互联网时代非常重要的一个领域，其中数据加密技术扮演着关键角色。文章首先探讨了数据加密技术的应用方向，包括维护网络系统安全、保障信息数据安全以及推动电商等领域的发展。这些方向充分...
这篇博客"eclipse 下实现java JNI 初探"将引导我们了解如何在Eclipse环境中开发和使用JNI。 首先，我们需要了解JNI的基本概念。JNI为Java程序员提供了一种方式来编写可以调用本地（非Java）代码的Java方法。这些...
本文重点探讨物联网专业Java课程改革的初探，旨在通过教师角色的转变、教学内容的项目化改造以及教学过程的融合等多方面改革，从而提升教学效果，培养出更多适应未来物联网行业的专业人才。 首先，我们必须认识到...
近年来，随着网页游戏从Flash技术向Java技术转变，使得更多的浏览器开始支持Java平台。这预示着Java技术在未来网页游戏发展中将扮演更为重要的角色。 在游戏开发中，选择合适的开发平台和研发团队是非常关键的。...