001 /*
002 * $HeadURL: http://juliusdavies.ca/svn/not-yet-commons-ssl/tags/commons-ssl-0.3.11/src/java/org/apache/commons/ssl/JavaImpl.java $
003 * $Revision: 155 $
004 * $Date: 2009-09-17 14:00:58 -0700 (Thu, 17 Sep 2009) $
005 *
006 * ====================================================================
007 * Licensed to the Apache Software Foundation (ASF) under one
008 * or more contributor license agreements. See the NOTICE file
009 * distributed with this work for additional information
010 * regarding copyright ownership. The ASF licenses this file
011 * to you under the Apache License, Version 2.0 (the
012 * "License"); you may not use this file except in compliance
013 * with the License. You may obtain a copy of the License at
014 *
015 * http://www.apache.org/licenses/LICENSE-2.0
016 *
017 * Unless required by applicable law or agreed to in writing,
018 * software distributed under the License is distributed on an
019 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
020 * KIND, either express or implied. See the License for the
021 * specific language governing permissions and limitations
022 * under the License.
023 * ====================================================================
024 *
025 * This software consists of voluntary contributions made by many
026 * individuals on behalf of the Apache Software Foundation. For more
027 * information on the Apache Software Foundation, please see
028 * <http://www.apache.org/>.
029 *
030 */
031
032 package org.apache.commons.ssl;
033
034 import javax.net.SocketFactory;
035 import javax.net.ssl.SSLPeerUnverifiedException;
036 import javax.net.ssl.SSLServerSocket;
037 import javax.net.ssl.SSLServerSocketFactory;
038 import javax.net.ssl.SSLSession;
039 import javax.net.ssl.SSLSocket;
040 import javax.net.ssl.SSLSocketFactory;
041 import java.io.IOException;
042 import java.net.InetAddress;
043 import java.net.Socket;
044 import java.security.KeyManagementException;
045 import java.security.KeyStore;
046 import java.security.KeyStoreException;
047 import java.security.NoSuchAlgorithmException;
048 import java.security.UnrecoverableKeyException;
049 import java.security.cert.Certificate;
050 import java.security.cert.CertificateException;
051 import java.security.cert.X509Certificate;
052
053 /**
054 * @author Credit Union Central of British Columbia
055 * @author <a href="http://www.cucbc.com/">www.cucbc.com</a>
056 * @author <a href="mailto:juliusdavies@cucbc.com">juliusdavies@cucbc.com</a>
057 * @since 30-Jun-2006
058 */
059 public abstract class JavaImpl {
060 private static JavaImpl HANDLER;
061
062 static {
063 JavaImpl h = null;
064 try {
065 h = Java14.getInstance();
066 }
067 catch (Throwable t) {
068 // System.out.println( t.toString() );
069 System.out.println("commons-ssl reverting to: Java 1.3 + jsse.jar");
070 }
071 if (h == null) {
072 h = Java13.getInstance();
073 }
074 HANDLER = h;
075 }
076
077 public static void downgrade() {
078 if (HANDLER instanceof Java14) {
079 HANDLER = Java13.getInstance();
080 }
081 }
082
083 public static boolean isJava13() {
084 return HANDLER instanceof Java13;
085 }
086
087 public static void uprade() {
088 if (HANDLER instanceof Java13) {
089 HANDLER = Java14.getInstance();
090 }
091 }
092
093 public abstract String getVersion();
094
095 protected abstract Object buildKeyManagerFactory(KeyStore ks, char[] pass)
096 throws NoSuchAlgorithmException, KeyStoreException,
097 UnrecoverableKeyException;
098
099 protected abstract Object[] retrieveKeyManagers(Object keyManagerFactory);
100
101 protected abstract Object buildTrustManagerFactory(KeyStore ks)
102 throws NoSuchAlgorithmException, KeyStoreException;
103
104 protected abstract Object[] retrieveTrustManagers(Object trustManagerFactory);
105
106 protected abstract String retrieveSubjectX500(X509Certificate cert);
107
108 protected abstract String retrieveIssuerX500(X509Certificate cert);
109
110 protected abstract Certificate[] retrievePeerCerts(SSLSession sslSession)
111 throws SSLPeerUnverifiedException;
112
113 protected abstract SSLSocketFactory buildSSLSocketFactory(Object ssl);
114
115 protected abstract SSLServerSocketFactory buildSSLServerSocketFactory(Object ssl);
116
117 protected abstract SSLSocket buildSocket(SSL ssl)
118 throws IOException;
119
120 protected abstract SSLSocket buildSocket(
121 SSL ssl, String remoteHost, int remotePort, InetAddress localHost, int localPort, int connectTimeout
122 ) throws IOException;
123
124 protected abstract Socket buildPlainSocket(
125 SSL ssl, String remoteHost, int remotePort, InetAddress localHost, int localPort, int connectTimeout
126 ) throws IOException;
127
128 protected abstract Socket connectSocket(Socket s, SocketFactory sf,
129 String remoteHost, int remotePort,
130 InetAddress localHost, int localPort,
131 int timeout, SSL ssl)
132 throws IOException;
133
134 protected abstract SSLServerSocket buildServerSocket(SSL ssl)
135 throws IOException;
136
137 protected abstract void wantClientAuth(Object o, boolean wantClientAuth);
138
139 protected abstract void enabledProtocols(Object o, String[] enabledProtocols);
140
141 protected abstract RuntimeException buildRuntimeException(Exception cause);
142
143 protected abstract Object initSSL(SSL ssl, TrustChain tc, KeyMaterial km)
144 throws NoSuchAlgorithmException, KeyStoreException,
145 CertificateException, KeyManagementException, IOException;
146
147 protected abstract void checkTrusted(Object trustManager,
148 X509Certificate[] chain,
149 String authType)
150 throws CertificateException;
151
152 public static Object init(SSL ssl, TrustChain trustChain, KeyMaterial keyMaterial)
153 throws NoSuchAlgorithmException, KeyStoreException,
154 CertificateException, KeyManagementException, IOException {
155 return HANDLER.initSSL(ssl, trustChain, keyMaterial);
156 }
157
158 public static RuntimeException newRuntimeException(Exception cause) {
159 return HANDLER.buildRuntimeException(cause);
160 }
161
162 public static SSLSocketFactory getSSLSocketFactory(Object sslContext) {
163 return HANDLER.buildSSLSocketFactory(sslContext);
164 }
165
166 public static SSLServerSocketFactory getSSLServerSocketFactory(Object sslContext) {
167 return HANDLER.buildSSLServerSocketFactory(sslContext);
168 }
169
170 public static String getSubjectX500(X509Certificate cert) {
171 return HANDLER.retrieveSubjectX500(cert);
172 }
173
174 public static String getIssuerX500(X509Certificate cert) {
175 return HANDLER.retrieveIssuerX500(cert);
176 }
177
178 public static Object newKeyManagerFactory(KeyStore ks, char[] password)
179 throws NoSuchAlgorithmException, KeyStoreException,
180 UnrecoverableKeyException {
181 return HANDLER.buildKeyManagerFactory(ks, password);
182 }
183
184 public static Object[] getKeyManagers(Object keyManagerFactory) {
185 return HANDLER.retrieveKeyManagers(keyManagerFactory);
186 }
187
188 public static Object newTrustManagerFactory(KeyStore ks)
189 throws NoSuchAlgorithmException, KeyStoreException {
190 return HANDLER.buildTrustManagerFactory(ks);
191 }
192
193 public static Object[] getTrustManagers(Object trustManagerFactory) {
194 return HANDLER.retrieveTrustManagers(trustManagerFactory);
195 }
196
197 public static SSLSocket createSocket(SSL ssl)
198 throws IOException {
199 return HANDLER.buildSocket(ssl);
200 }
201
202 public static SSLSocket createSocket(SSL ssl, String remoteHost,
203 int remotePort, InetAddress localHost,
204 int localPort, int connectTimeout)
205 throws IOException {
206 return HANDLER.buildSocket(ssl, remoteHost, remotePort, localHost,
207 localPort, connectTimeout);
208 }
209
210 public static Socket createPlainSocket(
211 SSL ssl, String remoteHost, int remotePort, InetAddress localHost, int localPort,
212 int connectTimeout
213 ) throws IOException {
214 return HANDLER.buildPlainSocket(
215 ssl, remoteHost, remotePort, localHost, localPort, connectTimeout
216 );
217 }
218
219 protected static Socket connect(Socket s, SocketFactory sf,
220 String remoteHost, int remotePort,
221 InetAddress localHost, int localPort,
222 int timeout, SSL ssl)
223 throws IOException {
224 return HANDLER.connectSocket(s, sf, remoteHost, remotePort, localHost,
225 localPort, timeout, ssl);
226 }
227
228 public static SSLServerSocket createServerSocket(SSL ssl)
229 throws IOException {
230 return HANDLER.buildServerSocket(ssl);
231 }
232
233 public static void setWantClientAuth(Object o, boolean wantClientAuth) {
234 HANDLER.wantClientAuth(o, wantClientAuth);
235 }
236
237 public static void setEnabledProtocols(Object o, String[] enabledProtocols) {
238 HANDLER.enabledProtocols(o, enabledProtocols);
239 }
240
241 public static Certificate[] getPeerCertificates(SSLSession session)
242 throws SSLPeerUnverifiedException {
243 return HANDLER.retrievePeerCerts(session);
244 }
245
246 public static void testTrust(Object trustManager, X509Certificate[] chain,
247 String authType)
248 throws CertificateException {
249 HANDLER.checkTrusted(trustManager, chain, authType);
250 }
251
252 public static void load() {
253 HANDLER.hashCode();
254 }
255
256 }