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        s.close();
34    }
35
36    public void test_SSLSession_getApplicationBufferSize() {
37        TestSSLSessions s = TestSSLSessions.create();
38        assertTrue(s.invalid.getApplicationBufferSize() > 0);
39        assertTrue(s.server.getApplicationBufferSize() > 0);
40        assertTrue(s.client.getApplicationBufferSize() > 0);
41        s.close();
42    }
43
44    public void test_SSLSession_getCipherSuite() {
45        TestSSLSessions s = TestSSLSessions.create();
46        assertNotNull(s.invalid.getCipherSuite());
47        assertEquals(StandardNames.CIPHER_SUITE_INVALID, s.invalid.getCipherSuite());
48        assertNotNull(s.server.getCipherSuite());
49        assertNotNull(s.client.getCipherSuite());
50        assertEquals(s.server.getCipherSuite(),
51                     s.client.getCipherSuite());
52        assertTrue(StandardNames.CIPHER_SUITES.contains(s.server.getCipherSuite()));
53        s.close();
54    }
55
56    public void test_SSLSession_getCreationTime() {
57        // We use OpenSSL, which only returns times accurate to the nearest second.
58        // NativeCrypto just multiplies by 1000, which looks like truncation, which
59        // would make it appear as if the OpenSSL side of things was created before
60        // we called it.
61        long t0 = System.currentTimeMillis() / 1000;
62        TestSSLSessions s = TestSSLSessions.create();
63        long t1 = System.currentTimeMillis() / 1000;
64
65        assertTrue(s.invalid.getCreationTime() > 0);
66
67        long sTime = s.server.getCreationTime() / 1000;
68        assertTrue(sTime + " >= " + t0, sTime >= t0);
69        assertTrue(sTime + " <= " + t1, sTime <= t1);
70
71        long cTime = s.client.getCreationTime() / 1000;
72        assertTrue(cTime + " >= " + t0, cTime >= t0);
73        assertTrue(cTime + " <= " + t1, cTime <= t1);
74
75        s.close();
76    }
77
78    public void test_SSLSession_getId() {
79        TestSSLSessions s = TestSSLSessions.create();
80        assertNotNull(s.invalid.getId());
81        assertNotNull(s.server.getId());
82        assertNotNull(s.client.getId());
83        assertEquals(0, s.invalid.getId().length);
84        if (TestSSLContext.sslServerSocketSupportsSessionTickets()) {
85            assertEquals(0, s.server.getId().length);
86        } else {
87            assertEquals(32, s.server.getId().length);
88            assertTrue(Arrays.equals(s.server.getId(), s.client.getId()));
89        }
90        assertEquals(32, s.client.getId().length);
91        s.close();
92    }
93
94    public void test_SSLSession_getLastAccessedTime() {
95        TestSSLSessions s = TestSSLSessions.create();
96        assertTrue(s.invalid.getLastAccessedTime() > 0);
97        assertTrue(s.server.getLastAccessedTime() > 0);
98        assertTrue(s.client.getLastAccessedTime() > 0);
99        assertTrue(Math.abs(s.server.getLastAccessedTime()
100                            - s.client.getLastAccessedTime()) < 1 * 1000);
101        assertTrue(s.server.getLastAccessedTime() >=
102                   s.server.getCreationTime());
103        assertTrue(s.client.getLastAccessedTime() >=
104                   s.client.getCreationTime());
105        s.close();
106    }
107
108    public void test_SSLSession_getLocalCertificates() throws Exception {
109        TestSSLSessions s = TestSSLSessions.create();
110        assertNull(s.invalid.getLocalCertificates());
111        assertNull(s.client.getLocalCertificates());
112        assertNotNull(s.server.getLocalCertificates());
113        TestKeyStore.assertChainLength(s.server.getLocalCertificates());
114        TestSSLContext.assertServerCertificateChain(s.s.c.serverTrustManager,
115                                                    s.server.getLocalCertificates());
116        TestSSLContext.assertCertificateInKeyStore(s.server.getLocalCertificates()[0],
117                                                   s.s.c.serverKeyStore);
118        s.close();
119    }
120
121    public void test_SSLSession_getLocalPrincipal() throws Exception {
122        TestSSLSessions s = TestSSLSessions.create();
123        assertNull(s.invalid.getLocalPrincipal());
124        assertNull(s.client.getLocalPrincipal());
125        assertNotNull(s.server.getLocalPrincipal());
126        assertNotNull(s.server.getLocalPrincipal().getName());
127        TestSSLContext.assertCertificateInKeyStore(s.server.getLocalPrincipal(),
128                                                   s.s.c.serverKeyStore);
129        s.close();
130    }
131
132    public void test_SSLSession_getPacketBufferSize() {
133        TestSSLSessions s = TestSSLSessions.create();
134        assertTrue(s.invalid.getPacketBufferSize() > 0);
135        assertTrue(s.server.getPacketBufferSize() > 0);
136        assertTrue(s.client.getPacketBufferSize() > 0);
137        s.close();
138    }
139
140    public void test_SSLSession_getPeerCertificateChain() throws Exception {
141        TestSSLSessions s = TestSSLSessions.create();
142        try {
143            s.invalid.getPeerCertificateChain();
144            fail();
145        } catch (SSLPeerUnverifiedException expected) {
146        }
147        assertNotNull(s.client.getPeerCertificates());
148        TestKeyStore.assertChainLength(s.client.getPeerCertificateChain());
149        try {
150            assertNull(s.server.getPeerCertificateChain());
151            fail();
152        } catch (SSLPeerUnverifiedException expected) {
153        }
154        s.close();
155    }
156
157    public void test_SSLSession_getPeerCertificates() throws Exception {
158        TestSSLSessions s = TestSSLSessions.create();
159        try {
160            s.invalid.getPeerCertificates();
161            fail();
162        } catch (SSLPeerUnverifiedException expected) {
163        }
164        assertNotNull(s.client.getPeerCertificates());
165        TestKeyStore.assertChainLength(s.client.getPeerCertificates());
166        TestSSLContext.assertServerCertificateChain(s.s.c.serverTrustManager,
167                                                    s.client.getPeerCertificates());
168        TestSSLContext.assertCertificateInKeyStore(s.client.getPeerCertificates()[0],
169                                                   s.s.c.serverKeyStore);
170        try {
171            s.server.getPeerCertificates();
172            fail();
173        } catch (SSLPeerUnverifiedException expected) {
174        }
175        s.close();
176    }
177
178    public void test_SSLSession_getPeerHost() {
179        TestSSLSessions s = TestSSLSessions.create();
180        assertNull(s.invalid.getPeerHost());
181        assertNotNull(s.server.getPeerHost());
182        assertNotNull(s.client.getPeerHost());
183        s.close();
184    }
185
186    public void test_SSLSession_getPeerPort() {
187        TestSSLSessions s = TestSSLSessions.create();
188        assertEquals(-1, s.invalid.getPeerPort());
189        assertTrue(s.server.getPeerPort() > 0);
190        assertEquals(s.s.c.port, s.client.getPeerPort());
191        s.close();
192    }
193
194    public void test_SSLSession_getPeerPrincipal() throws Exception {
195        TestSSLSessions s = TestSSLSessions.create();
196        try {
197            s.invalid.getPeerPrincipal();
198            fail();
199        } catch (SSLPeerUnverifiedException expected) {
200        }
201        try {
202            s.server.getPeerPrincipal();
203            fail();
204        } catch (SSLPeerUnverifiedException expected) {
205        }
206        assertNotNull(s.client.getPeerPrincipal());
207        assertNotNull(s.client.getPeerPrincipal().getName());
208        TestSSLContext.assertCertificateInKeyStore(s.client.getPeerPrincipal(),
209                                                   s.s.c.serverKeyStore);
210        s.close();
211    }
212
213    public void test_SSLSession_getProtocol() {
214        TestSSLSessions s = TestSSLSessions.create();
215        assertNotNull(s.invalid.getProtocol());
216        assertEquals("NONE", s.invalid.getProtocol());
217        assertNotNull(s.server.getProtocol());
218        assertNotNull(s.client.getProtocol());
219        assertEquals(s.server.getProtocol(),
220                     s.client.getProtocol());
221        assertTrue(StandardNames.SSL_SOCKET_PROTOCOLS.contains(s.server.getProtocol()));
222        s.close();
223    }
224
225    public void test_SSLSession_getSessionContext() {
226        TestSSLSessions s = TestSSLSessions.create();
227        assertNull(s.invalid.getSessionContext());
228        assertNotNull(s.server.getSessionContext());
229        assertNotNull(s.client.getSessionContext());
230        assertEquals(s.s.c.serverContext.getServerSessionContext(),
231                     s.server.getSessionContext());
232        assertEquals(s.s.c.clientContext.getClientSessionContext(),
233                     s.client.getSessionContext());
234        assertNotSame(s.server.getSessionContext(),
235                      s.client.getSessionContext());
236        s.close();
237    }
238
239    public void test_SSLSession_getValue() {
240        TestSSLSessions s = TestSSLSessions.create();
241        try {
242            s.invalid.getValue(null);
243        } catch (IllegalArgumentException expected) {
244        }
245        assertNull(s.invalid.getValue("BOGUS"));
246        s.close();
247    }
248
249    public void test_SSLSession_getValueNames() {
250        TestSSLSessions s = TestSSLSessions.create();
251        assertNotNull(s.invalid.getValueNames());
252        assertEquals(0, s.invalid.getValueNames().length);
253        s.close();
254    }
255
256    public void test_SSLSession_invalidate() {
257        TestSSLSessions s = TestSSLSessions.create();
258
259        assertFalse(s.invalid.isValid());
260        s.invalid.invalidate();
261        assertFalse(s.invalid.isValid());
262        assertNull(s.invalid.getSessionContext());
263
264        assertTrue(s.server.isValid());
265        s.server.invalidate();
266        assertFalse(s.server.isValid());
267        assertNull(s.server.getSessionContext());
268
269        assertTrue(s.client.isValid());
270        s.client.invalidate();
271        assertFalse(s.client.isValid());
272        assertNull(s.client.getSessionContext());
273
274        s.close();
275    }
276
277    public void test_SSLSession_isValid() {
278        TestSSLSessions s = TestSSLSessions.create();
279        assertFalse(s.invalid.isValid());
280        assertTrue(s.server.isValid());
281        assertTrue(s.client.isValid());
282        s.close();
283    }
284
285    public void test_SSLSession_putValue() {
286        TestSSLSessions s = TestSSLSessions.create();
287        String key = "KEY";
288        String value = "VALUE";
289        assertNull(s.invalid.getValue(key));
290        assertEquals(0, s.invalid.getValueNames().length);
291        s.invalid.putValue(key, value);
292        assertSame(value, s.invalid.getValue(key));
293        assertEquals(1, s.invalid.getValueNames().length);
294        assertEquals(key, s.invalid.getValueNames()[0]);
295        s.close();
296    }
297
298    public void test_SSLSession_removeValue() {
299        TestSSLSessions s = TestSSLSessions.create();
300        String key = "KEY";
301        String value = "VALUE";
302        s.invalid.putValue(key, value);
303        assertEquals(1, s.invalid.getValueNames().length);
304        assertEquals(key, s.invalid.getValueNames()[0]);
305        s.invalid.removeValue(key);
306        assertNull(s.invalid.getValue(key));
307        assertEquals(0, s.invalid.getValueNames().length);
308        s.close();
309    }
310}
311