SSLSessionTest.java revision 4557728efb66c455a52b7669a8eefef7a9e54854 
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 libcore.java.security.StandardNames;
20import libcore.java.security.TestKeyStore;
21import java.util.Arrays;
22import javax.net.ssl.SSLPeerUnverifiedException;
23import junit.framework.TestCase;
24
25public class SSLSessionTest extends TestCase {
26
27    public void test_SSLSocket_TestSSLSessions_create() {
28        TestSSLSessions s = TestSSLSessions.create();
29        assertNotNull(s.invalid);
30        assertFalse(s.invalid.isValid());
31        assertTrue(s.server.isValid());
32        assertTrue(s.client.isValid());
33    }
34
35    public void test_SSLSession_getApplicationBufferSize() {
36        TestSSLSessions s = TestSSLSessions.create();
37        assertTrue(s.invalid.getApplicationBufferSize() > 0);
38        assertTrue(s.server.getApplicationBufferSize() > 0);
39        assertTrue(s.client.getApplicationBufferSize() > 0);
40    }
41
42    public void test_SSLSession_getCipherSuite() {
43        TestSSLSessions s = TestSSLSessions.create();
44        assertNotNull(s.invalid.getCipherSuite());
45        assertEquals(StandardNames.CIPHER_SUITE_INVALID, s.invalid.getCipherSuite());
46        assertNotNull(s.server.getCipherSuite());
47        assertNotNull(s.client.getCipherSuite());
48        assertEquals(s.server.getCipherSuite(),
49                     s.client.getCipherSuite());
50        assertTrue(StandardNames.CIPHER_SUITES.contains(s.server.getCipherSuite()));
51    }
52
53    public void test_SSLSession_getCreationTime() {
54        TestSSLSessions s = TestSSLSessions.create();
55        assertTrue(s.invalid.getCreationTime() > 0);
56        assertTrue(s.server.getCreationTime() > 0);
57        assertTrue(s.client.getCreationTime() > 0);
58        assertTrue(Math.abs(s.server.getCreationTime() - s.client.getCreationTime()) < 1 * 1000);
59    }
60
61    public void test_SSLSession_getId() {
62        TestSSLSessions s = TestSSLSessions.create();
63        assertNotNull(s.invalid.getId());
64        assertNotNull(s.server.getId());
65        assertNotNull(s.client.getId());
66        assertEquals(0, s.invalid.getId().length);
67        if (TestSSLContext.sslServerSocketSupportsSessionTickets()) {
68            assertEquals(0, s.server.getId().length);
69        } else {
70            assertEquals(32, s.server.getId().length);
71            assertTrue(Arrays.equals(s.server.getId(), s.client.getId()));
72        }
73        assertEquals(32, s.client.getId().length);
74    }
75
76    public void test_SSLSession_getLastAccessedTime() {
77        TestSSLSessions s = TestSSLSessions.create();
78        assertTrue(s.invalid.getLastAccessedTime() > 0);
79        assertTrue(s.server.getLastAccessedTime() > 0);
80        assertTrue(s.client.getLastAccessedTime() > 0);
81        assertTrue(Math.abs(s.server.getLastAccessedTime()
82                            - s.client.getLastAccessedTime()) < 1 * 1000);
83        assertTrue(s.server.getLastAccessedTime() >=
84                   s.server.getCreationTime());
85        assertTrue(s.client.getLastAccessedTime() >=
86                   s.client.getCreationTime());
87    }
88
89    public void test_SSLSession_getLocalCertificates() throws Exception {
90        TestSSLSessions s = TestSSLSessions.create();
91        assertNull(s.invalid.getLocalCertificates());
92        assertNull(s.client.getLocalCertificates());
93        assertNotNull(s.server.getLocalCertificates());
94        TestKeyStore.assertChainLength(s.server.getLocalCertificates());
95        TestSSLContext.assertServerCertificateChain(s.s.c.serverTrustManager,
96                                                    s.server.getLocalCertificates());
97        TestSSLContext.assertCertificateInKeyStore(s.server.getLocalCertificates()[0],
98                                                   s.s.c.serverKeyStore);
99    }
100
101    public void test_SSLSession_getLocalPrincipal() throws Exception {
102        TestSSLSessions s = TestSSLSessions.create();
103        assertNull(s.invalid.getLocalPrincipal());
104        assertNull(s.client.getLocalPrincipal());
105        assertNotNull(s.server.getLocalPrincipal());
106        assertNotNull(s.server.getLocalPrincipal().getName());
107        TestSSLContext.assertCertificateInKeyStore(s.server.getLocalPrincipal(),
108                                                   s.s.c.serverKeyStore);
109    }
110
111    public void test_SSLSession_getPacketBufferSize() {
112        TestSSLSessions s = TestSSLSessions.create();
113        assertTrue(s.invalid.getPacketBufferSize() > 0);
114        assertTrue(s.server.getPacketBufferSize() > 0);
115        assertTrue(s.client.getPacketBufferSize() > 0);
116    }
117
118    public void test_SSLSession_getPeerCertificateChain() throws Exception {
119        TestSSLSessions s = TestSSLSessions.create();
120        try {
121            s.invalid.getPeerCertificateChain();
122            fail();
123        } catch (SSLPeerUnverifiedException expected) {
124        }
125        assertNotNull(s.client.getPeerCertificates());
126        TestKeyStore.assertChainLength(s.client.getPeerCertificateChain());
127        try {
128            assertNull(s.server.getPeerCertificateChain());
129            fail();
130        } catch (SSLPeerUnverifiedException expected) {
131        }
132    }
133
134    public void test_SSLSession_getPeerCertificates() throws Exception {
135        TestSSLSessions s = TestSSLSessions.create();
136        try {
137            s.invalid.getPeerCertificates();
138            fail();
139        } catch (SSLPeerUnverifiedException expected) {
140        }
141        assertNotNull(s.client.getPeerCertificates());
142        TestKeyStore.assertChainLength(s.client.getPeerCertificates());
143        TestSSLContext.assertServerCertificateChain(s.s.c.serverTrustManager,
144                                                    s.client.getPeerCertificates());
145        TestSSLContext.assertCertificateInKeyStore(s.client.getPeerCertificates()[0],
146                                                   s.s.c.serverKeyStore);
147        try {
148            s.server.getPeerCertificates();
149            fail();
150        } catch (SSLPeerUnverifiedException expected) {
151        }
152    }
153
154    public void test_SSLSession_getPeerHost() {
155        TestSSLSessions s = TestSSLSessions.create();
156        assertNull(s.invalid.getPeerHost());
157        assertNotNull(s.server.getPeerHost());
158        assertNotNull(s.client.getPeerHost());
159    }
160
161    public void test_SSLSession_getPeerPort() {
162        TestSSLSessions s = TestSSLSessions.create();
163        assertEquals(-1, s.invalid.getPeerPort());
164        assertTrue(s.server.getPeerPort() > 0);
165        assertEquals(s.s.c.port, s.client.getPeerPort());
166    }
167
168    public void test_SSLSession_getPeerPrincipal() throws Exception {
169        TestSSLSessions s = TestSSLSessions.create();
170        try {
171            s.invalid.getPeerPrincipal();
172            fail();
173        } catch (SSLPeerUnverifiedException expected) {
174        }
175        try {
176            s.server.getPeerPrincipal();
177            fail();
178        } catch (SSLPeerUnverifiedException expected) {
179        }
180        assertNotNull(s.client.getPeerPrincipal());
181        assertNotNull(s.client.getPeerPrincipal().getName());
182        TestSSLContext.assertCertificateInKeyStore(s.client.getPeerPrincipal(),
183                                                   s.s.c.serverKeyStore);
184    }
185
186    public void test_SSLSession_getProtocol() {
187        TestSSLSessions s = TestSSLSessions.create();
188        assertNotNull(s.invalid.getProtocol());
189        assertEquals("NONE", s.invalid.getProtocol());
190        assertNotNull(s.server.getProtocol());
191        assertNotNull(s.client.getProtocol());
192        assertEquals(s.server.getProtocol(),
193                     s.client.getProtocol());
194        assertTrue(StandardNames.SSL_SOCKET_PROTOCOLS.contains(s.server.getProtocol()));
195    }
196
197    public void test_SSLSession_getSessionContext() {
198        TestSSLSessions s = TestSSLSessions.create();
199        assertNull(s.invalid.getSessionContext());
200        assertNotNull(s.server.getSessionContext());
201        assertNotNull(s.client.getSessionContext());
202        assertEquals(s.s.c.serverContext.getServerSessionContext(),
203                     s.server.getSessionContext());
204        assertEquals(s.s.c.clientContext.getClientSessionContext(),
205                     s.client.getSessionContext());
206        assertNotSame(s.server.getSessionContext(),
207                      s.client.getSessionContext());
208    }
209
210    public void test_SSLSession_getValue() {
211        TestSSLSessions s = TestSSLSessions.create();
212        try {
213            s.invalid.getValue(null);
214        } catch (IllegalArgumentException expected) {
215        }
216        assertNull(s.invalid.getValue("BOGUS"));
217    }
218
219    public void test_SSLSession_getValueNames() {
220        TestSSLSessions s = TestSSLSessions.create();
221        assertNotNull(s.invalid.getValueNames());
222        assertEquals(0, s.invalid.getValueNames().length);
223    }
224
225    public void test_SSLSession_invalidate() {
226        TestSSLSessions s = TestSSLSessions.create();
227        assertFalse(s.invalid.isValid());
228        s.invalid.invalidate();
229        assertFalse(s.invalid.isValid());
230        assertNull(s.invalid.getSessionContext());
231
232        assertTrue(s.server.isValid());
233        s.server.invalidate();
234        assertFalse(s.server.isValid());
235        assertNull(s.server.getSessionContext());
236
237        assertTrue(s.client.isValid());
238        s.client.invalidate();
239        assertFalse(s.client.isValid());
240        assertNull(s.client.getSessionContext());
241    }
242
243    public void test_SSLSession_isValid() {
244        TestSSLSessions s = TestSSLSessions.create();
245        assertFalse(s.invalid.isValid());
246        assertTrue(s.server.isValid());
247        assertTrue(s.client.isValid());
248    }
249
250    public void test_SSLSession_putValue() {
251        TestSSLSessions s = TestSSLSessions.create();
252        String key = "KEY";
253        String value = "VALUE";
254        assertNull(s.invalid.getValue(key));
255        assertEquals(0, s.invalid.getValueNames().length);
256        s.invalid.putValue(key, value);
257        assertSame(value, s.invalid.getValue(key));
258        assertEquals(1, s.invalid.getValueNames().length);
259        assertEquals(key, s.invalid.getValueNames()[0]);
260    }
261
262    public void test_SSLSession_removeValue() {
263        TestSSLSessions s = TestSSLSessions.create();
264        String key = "KEY";
265        String value = "VALUE";
266        s.invalid.putValue(key, value);
267        assertEquals(1, s.invalid.getValueNames().length);
268        assertEquals(key, s.invalid.getValueNames()[0]);
269        s.invalid.removeValue(key);
270        assertNull(s.invalid.getValue(key));
271        assertEquals(0, s.invalid.getValueNames().length);
272    }
273}
274