`
yjhexy
  • 浏览: 332267 次
  • 性别: Icon_minigender_1
  • 来自: 火星
社区版块
存档分类
最新评论

JAVA 机密机制初探(JCA)—— 证书在SSL中的使用

阅读更多

直接上实例:

 

我有一个私钥证书,访问我们公司内网:

a.pfx   (PKCS12标准的证书)

 

需要用JAVA程序访问公司内网,内网采用SSL安全机制,并要求客户端出示身份证明,即a.pfx中的私钥。

 

 

需要做的事情:

1,把a.pfx导成根证书,放到trustkeyStore中去。以便在SSL握手中 客户端(我)信任 服务端(内网)用。

要做到a.pfx导出成 .cer后缀的证书文件很简单:

首先把a.pfx导入到IE。然后用IE的Internet选项--》内容--》证书--》导出成不带私钥的cer格式就搞定了

我按照以上步骤导出成a.pfx.cer 格式的证书

然后进行如下步骤:

 

# 用以下命令把cer格式的证书放到 server.keystore中去

keytool -import -v -trustcacerts -alias yajun.wuyj -file a.pfx.cer -storepass changeit -keystore server.keystore

 

2,把私钥放到 keyStore中去,以便在SSL我手中,服务器要我出示我的身份证明时使用。

 

public class AuthSSLProtocolSocketFactory implements SecureProtocolSocketFactory {

     private static final Log LOG                = LogFactory.getLog(AuthSSLProtocolSocketFactory.class);

    private String           keystoreUrl        = null;
    private String           keystorePassword   = null;
    private String           truststoreUrl      = null;
    private String           truststorePassword = null;
    private SSLContext       sslcontext         = null;

       public AuthSSLProtocolSocketFactory(final String keyStoreFile, String keystorePassword, String truststoreFile,
                                        final String truststorePassword){
        super();
        this.keystoreUrl = keyStoreFile;
        this.keystorePassword = keystorePassword;
        this.truststoreUrl = truststoreFile;
        this.truststorePassword = truststorePassword;
    }

    private static KeyStore createKeyStore(final String file, final String password) throws KeyStoreException,
                                                                                    NoSuchAlgorithmException,
                                                                                    CertificateException, IOException {

        if (file == null) {
            throw new IllegalArgumentException("Keystore url may not be null");
        }
        LOG.debug("Initializing key store");
        KeyStore keystore = null;
        InputStream is = null;
        try {
            // 尝试 使用PKCS12的格式读取私钥证书
        keystore = KeyStore.getInstance("PKCS12");
            is = new FileInputStream(new File(file));
            keystore.load(is, password != null ? password.toCharArray() : null);
        } catch (Exception ce) {
            // 再次 尝试使用JKS的格式读取私钥证书
            keystore = KeyStore.getInstance("jks");
            is = new FileInputStream(new File(file));
            keystore.load(is, password != null ? password.toCharArray() : null);
        } finally {
            IOUtils.closeQuietly(is);
        }
        return keystore;
    }

    private static KeyManager[] createKeyManagers(final KeyStore keystore, final String password)
                                                                                                 throws KeyStoreException,
                                                                                                 NoSuchAlgorithmException,
                                                                                                 UnrecoverableKeyException {
        if (keystore == null) {
            throw new IllegalArgumentException("Keystore may not be null");
        }
        LOG.debug("Initializing key manager");
        KeyManagerFactory kmfactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        kmfactory.init(keystore, password != null ? password.toCharArray() : null);
        return kmfactory.getKeyManagers();
    }

    private static TrustManager[] createTrustManagers(final KeyStore keystore) throws KeyStoreException,
                                                                              NoSuchAlgorithmException {
        if (keystore == null) {
            throw new IllegalArgumentException("Keystore may not be null");
        }
        LOG.debug("Initializing trust manager");
        TrustManagerFactory tmfactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmfactory.init(keystore);
        TrustManager[] trustmanagers = tmfactory.getTrustManagers();
        for (int i = 0; i < trustmanagers.length; i++) {
            if (trustmanagers[i] instanceof X509TrustManager) {
                trustmanagers[i] = new AuthSSLX509TrustManager((X509TrustManager) trustmanagers[i]);
            }
        }
        return trustmanagers;
    }

    private SSLContext createSSLContext() {
        try {
            KeyManager[] keymanagers = null;
            TrustManager[] trustmanagers = null;
            if (this.keystoreUrl != null) {
                // 证明自己身份的keyStore
                KeyStore keystore = createKeyStore(this.keystoreUrl, this.keystorePassword);
                if (LOG.isDebugEnabled()) {
                    Enumeration<String> aliases = keystore.aliases();
                    while (aliases.hasMoreElements()) {
                        String alias = (String) aliases.nextElement();
                        Certificate[] certs = keystore.getCertificateChain(alias);
                        if (certs != null) {
                            LOG.debug("Certificate chain '" + alias + "':");
                            for (int c = 0; c < certs.length; c++) {
                                if (certs[c] instanceof X509Certificate) {
                                    X509Certificate cert = (X509Certificate) certs[c];
                                    LOG.debug(" Certificate " + (c + 1) + ":");
                                    LOG.debug("  Subject DN: " + cert.getSubjectDN());
                                    LOG.debug("  Signature Algorithm: " + cert.getSigAlgName());
                                    LOG.debug("  Valid from: " + cert.getNotBefore());
                                    LOG.debug("  Valid until: " + cert.getNotAfter());
                                    LOG.debug("  Issuer: " + cert.getIssuerDN());
                                }
                            }
                        }
                    }
                }
                keymanagers = createKeyManagers(keystore, this.keystorePassword);
            }
            if (this.truststoreUrl != null) {
                // 信任其他的store
                KeyStore keystore = createKeyStore(this.truststoreUrl, this.truststorePassword);
                if (LOG.isDebugEnabled()) {
                    Enumeration<String> aliases = keystore.aliases();
                    while (aliases.hasMoreElements()) {
                        String alias = (String) aliases.nextElement();
                        LOG.debug("Trusted certificate '" + alias + "':");
                        Certificate trustedcert = keystore.getCertificate(alias);
                        if (trustedcert != null && trustedcert instanceof X509Certificate) {
                            X509Certificate cert = (X509Certificate) trustedcert;
                            LOG.debug("  Subject DN: " + cert.getSubjectDN());
                            LOG.debug("  Signature Algorithm: " + cert.getSigAlgName());
                            LOG.debug("  Valid from: " + cert.getNotBefore());
                            LOG.debug("  Valid until: " + cert.getNotAfter());
                            LOG.debug("  Issuer: " + cert.getIssuerDN());
                        }
                    }
                }
                trustmanagers = createTrustManagers(keystore);
            }
            SSLContext sslcontext = SSLContext.getInstance("SSL");
            sslcontext.init(keymanagers, trustmanagers, null);
            return sslcontext;
        } catch (NoSuchAlgorithmException e) {
            LOG.error(e.getMessage(), e);
            throw new AuthSSLInitializationError("Unsupported algorithm exception: " + e.getMessage());
        } catch (KeyStoreException e) {
            LOG.error(e.getMessage(), e);
            throw new AuthSSLInitializationError("Keystore exception: " + e.getMessage());
        } catch (GeneralSecurityException e) {
            LOG.error(e.getMessage(), e);
            throw new AuthSSLInitializationError("Key management exception: " + e.getMessage());
        } catch (IOException e) {
            LOG.error(e.getMessage(), e);
            throw new AuthSSLInitializationError("I/O error reading keystore/truststore file: " + e.getMessage());
        }
    }

    private SSLContext getSSLContext() {
        if (this.sslcontext == null) {
            this.sslcontext = createSSLContext();
        }
        return this.sslcontext;
    }

       public Socket createSocket(final String host, final int port, final InetAddress localAddress, final int localPort,
                               final HttpConnectionParams params) throws IOException, UnknownHostException,
                                                                 ConnectTimeoutException {
        if (params == null) {
            throw new IllegalArgumentException("Parameters may not be null");
        }
        int timeout = params.getConnectionTimeout();
        SocketFactory socketfactory = getSSLContext().getSocketFactory();
        if (timeout == 0) {
            return socketfactory.createSocket(host, port, localAddress, localPort);
        } else {
            Socket socket = socketfactory.createSocket();
            SocketAddress localaddr = new InetSocketAddress(localAddress, localPort);
            SocketAddress remoteaddr = new InetSocketAddress(host, port);
            socket.bind(localaddr);
            socket.connect(remoteaddr, timeout);
            return socket;
        }
    }

    /**
     * @see SecureProtocolSocketFactory#createSocket(java.lang.String,int,java.net.InetAddress,int)
     */
    public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort) throws IOException,
                                                                                             UnknownHostException {
        return getSSLContext().getSocketFactory().createSocket(host, port, clientHost, clientPort);
    }

    /**
     * @see SecureProtocolSocketFactory#createSocket(java.lang.String,int)
     */
    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
        return getSSLContext().getSocketFactory().createSocket(host, port);
    }

    /**
     * @see SecureProtocolSocketFactory#createSocket(java.net.Socket,java.lang.String,int,boolean)
     */
    public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException,
                                                                                       UnknownHostException {
        return getSSLContext().getSocketFactory().createSocket(socket, host, port, autoClose);
    }

 

 

3,SSL握手通过了,咱们就开始访问页面吧。

 

 

/**
 * 访问内网的程序
 * 
 * @author Administrator 2010-1-19 下午10:27:40
 */
public class pfxSSLExample {

    private static final String KEYSTORE_FILE     = "src/main/resources/a.pfx";
    private static final String TRUST_KEY_FILE    = "src/main/resources/server.keystore";
    private static final String TRUST_PASSWORD    = "changeit";
    private static final String KEYSTORE_PASSWORD = "1983413";

    public static void main(String[] args) throws Exception {
        AuthSSLProtocolSocketFactory factory = new AuthSSLProtocolSocketFactory(KEYSTORE_FILE, KEYSTORE_PASSWORD,
                                                                                TRUST_KEY_FILE, TRUST_PASSWORD);
        Protocol.registerProtocol("https", new Protocol("https", factory, 443));
        HttpClient httpclient = new HttpClient();
        GetMethod httpget = new GetMethod("https://www.cn.xxxx-inc.com/");
        try {
            httpclient.executeMethod(httpget);
            System.out.println(httpget.getResponseBodyAsString());
        } catch (HttpException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            httpget.releaseConnection();
        }

    }
}

 

 

分享到:
评论
1 楼 xiaoma19870310 2011-06-08  
代码很有用,MAIN方法测试通过,不过在tomcat下访问HTTPS网站的时候就返回500错误.不解....

相关推荐

    IBM WEBSPHERE javacore分析工具jca

    本文将深入探讨IBM WebSphere中的JCA(Java Connector Architecture)与javacore分析之间的关联。 首先,JCA是Java平台的标准,用于集成企业信息系统(EIS)和Java应用程序。它为开发者提供了一种标准接口来访问和...

    jca javacore分析工具

    Java Core文件是由JVM生成的一种日志文件,记录了JVM在特定时刻的状态,包括线程堆栈信息、内存使用情况、类加载信息等。当Java应用程序出现异常或者性能问题时,操作系统可能会触发JVM生成javacore文件,帮助...

    jca-分析javacore和dump.zip

    在"jca-分析javacore和dump.zip"这个压缩包中,包含了一个名为"jca457.jar"的JCA工具和一个"执行步骤.txt"的文本文件,后者应该是指导如何使用该工具的说明。 **Java Core (javacore) 分析** Java Core,通常简称为...

    websphere javacore 分析工具 jca412

    【标题】"Websphere Javacore 分析工具 JCA412"涉及的是IBM Websphere应用服务器中的一项核心诊断技术,Javacore,以及与Java连接器架构(JCA)相关的分析和故障排查。Javacore是IBM Websphere在遇到异常或系统崩溃...

    was内存溢出 javacore分析工具jca 456

    在IT行业中,尤其是在Java应用程序的运行环境中,内存溢出(Memory Leak)是一个常见的问题,尤其在大型企业级应用服务器如WebSphere中。本篇将详细探讨如何利用Javacore分析工具JCA 456来诊断和解决这类问题。 ...

    IBM Thread and Monitor Dump Analyzer for Java (jca) 线程分析工具 jca456.jar

    IBM Thread and Monitor Dump Analyzer for Java(简称 jca)。它可以识别Java线程中的挂起,死锁,资源竞争,和瓶颈。 使用方法: java -Xmx1000m -jar jca456.jar

    was内存溢出 javacore分析工具jca 401

    标题中的“was内存溢出 javacore分析工具jca 401”指的是在WebSphere应用服务器(WAS)环境中,出现内存溢出问题时,使用名为JCA(Java Core Analysis)401的工具进行分析的情况。内存溢出是程序运行过程中,因分配...

    Java实现浏览器CA证书的签名和验证

    本文将详细介绍CA证书的作用、在Java中如何生成和使用CA证书进行签名和验证。 首先,CA证书是网络通信中用来标识通信各方身份的一系列数据。数字证书由一个权威的机构,即证书颁发机构(Certification Authority, CA...

    javacore分析工具jca36

    通过使用JCA36,用户可以轻松地捕获和分析Java虚拟机(JVM)的核心转储文件(也称为javacore文件),这些文件包含了JVM在特定时刻的内存使用、线程状态、类加载和垃圾收集等关键信息。 JCA36的主要功能包括: 1. *...

    IBM Thread and Monitor Dump Analyzer for Java (jca) 线程分析工具 jca45

    IBM Thread and Monitor Dump Analyzer for Java(简称 jca)。它可以识别Java线程中的挂起,死锁,资源竞争,和瓶颈。 使用方法: java -Xmx1000m -jar jca456.jar

    java线程堆栈分析工具jca457.jar

    java线程堆栈分析工具jca466.jar;堆内存分析工具Memory Analyzer;分析内存泄露产生的javacore文件,以便于定位blocked线程

    java的jca演示程序

    不懂jca的朋友可以来这看看,一个jca的演示程序,程序逻辑清晰

    JCA433及JCA463

    Java Comprehensive Application (JCA) 是Java平台上的一个关键组件,主要用于在Java应用程序中集成企业级服务,例如消息传递、数据库连接等。标题提到的“JCA433及JCA463”可能是两个版本号,暗示这可能是一个用于...

    基于Java2的身份认证数字签名和SSL实现技术

    在探讨Java2平台下实现身份认证、数字签名和SSL的技术细节之前,我们首先需要理解Java2平台所提供的一系列安全框架和工具。Java2(即Java Platform, Standard Edition)自发布以来,便内置了一系列安全特性,旨在...

    jca433.jar

    JCA433.jar的工作原理是通过解析javacore文件中的各种数据结构,提取出如线程堆栈信息、内存分配情况、CPU使用率等关键指标,然后以图形化的方式展示出来,便于开发者直观地发现潜在的性能瓶颈或者内存泄漏。...

    JCA练习 JCA练习

    JCA练习 JCA练习 JCA练习 JCA练习 JCA练习

    jca分析工具.zip

    Java Core Analysis (JCA) 工具是Java开发者在排查性能问题、监控应用程序或诊断线程问题时的重要辅助工具。这个名为"jca分析工具.zip"的压缩包包含了一个名为"jca433.jar"的文件,这很可能是JCA工具的一个版本,...

    网络安全技术应用——数字签名技术在Java中的实现.pdf

    在Java语言中,可以使用Java Cryptography Architecture(JCA)来实现数字签名技术。JCA提供了一个安全的加密库,支持各种加密算法和协议,包括RSA、DSA、ECDSA等。 数字签名技术是一种重要的安全技术,能够保护...

    jca分析工具

    在实际操作中,还需要了解Java内存模型、线程同步机制以及垃圾收集的工作原理,这样才能更好地利用JCA工具进行诊断。此外,配合其他工具如JVisualVM、JProfiler等进行综合分析,可以获得更全面的问题视图。 总的来...

Global site tag (gtag.js) - Google Analytics