SSLContextTest.java revision 6c78b7b94c232063ec559436b48b33751373ecf1 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package libcore.javax.net.ssl;
18
19import java.security.KeyManagementException;
20import java.security.Provider;
21import libcore.java.security.StandardNames;
22import javax.net.ServerSocketFactory;
23import javax.net.SocketFactory;
24import javax.net.ssl.SSLContext;
25import javax.net.ssl.SSLEngine;
26import javax.net.ssl.SSLParameters;
27import javax.net.ssl.SSLServerSocketFactory;
28import javax.net.ssl.SSLSessionContext;
29import javax.net.ssl.SSLSocketFactory;
30import junit.framework.TestCase;
31
32public class SSLContextTest extends TestCase {
33
34    public void test_SSLContext_getDefault() throws Exception {
35        SSLContext sslContext = SSLContext.getDefault();
36        assertNotNull(sslContext);
37        try {
38            sslContext.init(null, null, null);
39        } catch (KeyManagementException expected) {
40        }
41    }
42
43    public void test_SSLContext_setDefault() throws Exception {
44        try {
45            SSLContext.setDefault(null);
46        } catch (NullPointerException expected) {
47        }
48
49        SSLContext defaultContext = SSLContext.getDefault();
50        for (String protocol : StandardNames.SSL_CONTEXT_PROTOCOLS) {
51            SSLContext oldContext = SSLContext.getDefault();
52            assertNotNull(oldContext);
53            SSLContext newContext = SSLContext.getInstance(protocol);
54            assertNotNull(newContext);
55            assertNotSame(oldContext, newContext);
56            SSLContext.setDefault(newContext);
57            assertSame(newContext, SSLContext.getDefault());
58        }
59        SSLContext.setDefault(defaultContext);
60    }
61
62    public void test_SSLContext_getInstance() throws Exception {
63        try {
64            SSLContext.getInstance(null);
65            fail();
66        } catch (NullPointerException expected) {
67        }
68        for (String protocol : StandardNames.SSL_CONTEXT_PROTOCOLS) {
69            assertNotNull(SSLContext.getInstance(protocol));
70            assertNotSame(SSLContext.getInstance(protocol),
71                          SSLContext.getInstance(protocol));
72        }
73
74        try {
75            SSLContext.getInstance(null, (String) null);
76            fail();
77        } catch (IllegalArgumentException expected) {
78        }
79        try {
80            SSLContext.getInstance(null, "");
81            fail();
82        } catch (IllegalArgumentException expected) {
83        }
84        for (String protocol : StandardNames.SSL_CONTEXT_PROTOCOLS) {
85            try {
86                SSLContext.getInstance(protocol, (String) null);
87                fail();
88            } catch (IllegalArgumentException expected) {
89            }
90        }
91        try {
92            SSLContext.getInstance(null, StandardNames.JSSE_PROVIDER_NAME);
93            fail();
94        } catch (NullPointerException expected) {
95        }
96    }
97
98    public void test_SSLContext_getProtocol() throws Exception {
99        for (String protocol : StandardNames.SSL_CONTEXT_PROTOCOLS) {
100            String protocolName = SSLContext.getInstance(protocol).getProtocol();
101            assertNotNull(protocolName);
102            assertTrue(protocol.startsWith(protocolName));
103        }
104    }
105
106    public void test_SSLContext_getProvider() throws Exception {
107        Provider provider = SSLContext.getDefault().getProvider();
108        assertNotNull(provider);
109        assertEquals(StandardNames.JSSE_PROVIDER_NAME, provider.getName());
110    }
111
112    public void test_SSLContext_init() throws Exception {
113        for (String protocol : StandardNames.SSL_CONTEXT_PROTOCOLS) {
114            SSLContext sslContext = SSLContext.getInstance(protocol);
115            if (protocol.equals(StandardNames.SSL_CONTEXT_PROTOCOLS_DEFAULT)) {
116                try {
117                    sslContext.init(null, null, null);
118                } catch (KeyManagementException expected) {
119                }
120            } else {
121                sslContext.init(null, null, null);
122            }
123        }
124    }
125
126    public void test_SSLContext_getSocketFactory() throws Exception {
127        for (String protocol : StandardNames.SSL_CONTEXT_PROTOCOLS) {
128            if (protocol.equals(StandardNames.SSL_CONTEXT_PROTOCOLS_DEFAULT)) {
129                SSLContext.getInstance(protocol).getSocketFactory();
130            } else {
131                try {
132                    SSLContext.getInstance(protocol).getSocketFactory();
133                    fail();
134                } catch (IllegalStateException expected) {
135                }
136            }
137
138            SSLContext sslContext = SSLContext.getInstance(protocol);
139            if (!protocol.equals(StandardNames.SSL_CONTEXT_PROTOCOLS_DEFAULT)) {
140                sslContext.init(null, null, null);
141            }
142            SocketFactory sf = sslContext.getSocketFactory();
143            assertNotNull(sf);
144            assertTrue(SSLSocketFactory.class.isAssignableFrom(sf.getClass()));
145        }
146    }
147
148    public void test_SSLContext_getServerSocketFactory() throws Exception {
149        for (String protocol : StandardNames.SSL_CONTEXT_PROTOCOLS) {
150            if (protocol.equals(StandardNames.SSL_CONTEXT_PROTOCOLS_DEFAULT)) {
151                SSLContext.getInstance(protocol).getServerSocketFactory();
152            } else {
153                try {
154                    SSLContext.getInstance(protocol).getServerSocketFactory();
155                    fail();
156                } catch (IllegalStateException expected) {
157                }
158            }
159
160            SSLContext sslContext = SSLContext.getInstance(protocol);
161            if (!protocol.equals(StandardNames.SSL_CONTEXT_PROTOCOLS_DEFAULT)) {
162                sslContext.init(null, null, null);
163            }
164            ServerSocketFactory ssf = sslContext.getServerSocketFactory();
165            assertNotNull(ssf);
166            assertTrue(SSLServerSocketFactory.class.isAssignableFrom(ssf.getClass()));
167        }
168    }
169
170    public void test_SSLContext_createSSLEngine() throws Exception {
171        for (String protocol : StandardNames.SSL_CONTEXT_PROTOCOLS) {
172
173            if (protocol.equals(StandardNames.SSL_CONTEXT_PROTOCOLS_DEFAULT)) {
174                SSLContext.getInstance(protocol).createSSLEngine();
175            } else {
176                try {
177                    SSLContext.getInstance(protocol).createSSLEngine();
178                    fail();
179                } catch (IllegalStateException expected) {
180                }
181            }
182
183            if (protocol.equals(StandardNames.SSL_CONTEXT_PROTOCOLS_DEFAULT)) {
184                SSLContext.getInstance(protocol).createSSLEngine(null, -1);
185            } else {
186                try {
187                    SSLContext.getInstance(protocol).createSSLEngine(null, -1);
188                    fail();
189                } catch (IllegalStateException expected) {
190                }
191            }
192
193            {
194                SSLContext sslContext = SSLContext.getInstance(protocol);
195                if (!protocol.equals(StandardNames.SSL_CONTEXT_PROTOCOLS_DEFAULT)) {
196                    sslContext.init(null, null, null);
197                }
198                SSLEngine se = sslContext.createSSLEngine();
199                assertNotNull(se);
200            }
201
202            {
203                SSLContext sslContext = SSLContext.getInstance(protocol);
204                if (!protocol.equals(StandardNames.SSL_CONTEXT_PROTOCOLS_DEFAULT)) {
205                    sslContext.init(null, null, null);
206                }
207                SSLEngine se = sslContext.createSSLEngine(null, -1);
208                assertNotNull(se);
209            }
210        }
211    }
212
213    public void test_SSLContext_getServerSessionContext() throws Exception {
214        for (String protocol : StandardNames.SSL_CONTEXT_PROTOCOLS) {
215            SSLContext sslContext = SSLContext.getInstance(protocol);
216            SSLSessionContext sessionContext = sslContext.getServerSessionContext();
217            assertNotNull(sessionContext);
218
219            if (protocol.equals(StandardNames.SSL_CONTEXT_PROTOCOLS_DEFAULT)) {
220                assertSame(SSLContext.getInstance(protocol).getServerSessionContext(),
221                           sessionContext);
222            } else {
223                assertNotSame(SSLContext.getInstance(protocol).getServerSessionContext(),
224                              sessionContext);
225            }
226        }
227    }
228
229    public void test_SSLContext_getClientSessionContext() throws Exception {
230        for (String protocol : StandardNames.SSL_CONTEXT_PROTOCOLS) {
231            SSLContext sslContext = SSLContext.getInstance(protocol);
232            SSLSessionContext sessionContext = sslContext.getClientSessionContext();
233            assertNotNull(sessionContext);
234
235            if (protocol.equals(StandardNames.SSL_CONTEXT_PROTOCOLS_DEFAULT)) {
236                assertSame(SSLContext.getInstance(protocol).getClientSessionContext(),
237                           sessionContext);
238            } else {
239                assertNotSame(SSLContext.getInstance(protocol).getClientSessionContext(),
240                              sessionContext);
241            }
242        }
243    }
244
245    public void test_SSLContext_getDefaultSSLParameters() throws Exception {
246        for (String protocol : StandardNames.SSL_CONTEXT_PROTOCOLS) {
247            SSLContext sslContext = SSLContext.getInstance(protocol);
248            if (!protocol.equals(StandardNames.SSL_CONTEXT_PROTOCOLS_DEFAULT)) {
249                sslContext.init(null, null, null);
250            }
251
252            SSLParameters p = sslContext.getDefaultSSLParameters();
253            assertNotNull(p);
254
255            String[] cipherSuites = p.getCipherSuites();
256            assertNotNull(cipherSuites);
257            StandardNames.assertValidCipherSuites(StandardNames.CIPHER_SUITES, cipherSuites);
258
259            String[] protocols = p.getProtocols();
260            assertNotNull(protocols);
261            StandardNames.assertValidCipherSuites(StandardNames.SSL_SOCKET_PROTOCOLS, protocols);
262
263            assertFalse(p.getWantClientAuth());
264            assertFalse(p.getNeedClientAuth());
265        }
266    }
267
268    public void test_SSLContext_getSupportedSSLParameters() throws Exception {
269        for (String protocol : StandardNames.SSL_CONTEXT_PROTOCOLS) {
270            SSLContext sslContext = SSLContext.getInstance(protocol);
271            if (!protocol.equals(StandardNames.SSL_CONTEXT_PROTOCOLS_DEFAULT)) {
272                sslContext.init(null, null, null);
273            }
274
275            SSLParameters p = sslContext.getSupportedSSLParameters();
276            assertNotNull(p);
277
278            String[] cipherSuites = p.getCipherSuites();
279            assertNotNull(cipherSuites);
280            StandardNames.assertSupportedCipherSuites(StandardNames.CIPHER_SUITES, cipherSuites);
281
282            String[] protocols = p.getProtocols();
283            assertNotNull(protocols);
284            StandardNames.assertSupportedProtocols(StandardNames.SSL_SOCKET_PROTOCOLS,
285                                                   protocols);
286
287            assertFalse(p.getWantClientAuth());
288            assertFalse(p.getNeedClientAuth());
289        }
290    }
291
292    public void test_SSLContextTest_TestSSLContext_create() {
293        TestSSLContext testContext = TestSSLContext.create();
294        assertNotNull(testContext);
295        assertNotNull(testContext.clientKeyStore);
296        assertNull(testContext.clientStorePassword);
297        assertNotNull(testContext.serverKeyStore);
298        assertEquals(StandardNames.IS_RI, testContext.serverStorePassword != null);
299        assertNotNull(testContext.clientKeyManager);
300        assertNotNull(testContext.serverKeyManager);
301        assertNotNull(testContext.clientTrustManager);
302        assertNotNull(testContext.serverTrustManager);
303        assertNotNull(testContext.clientContext);
304        assertNotNull(testContext.serverContext);
305        assertNotNull(testContext.serverSocket);
306        assertNotNull(testContext.host);
307        assertTrue(testContext.port != 0);
308        testContext.close();
309    }
310}
311