1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 */
17
18package tests.api.javax.net.ssl;
19
20import java.io.ByteArrayInputStream;
21import java.io.InputStream;
22import java.io.OutputStream;
23import java.net.InetAddress;
24import java.net.InetSocketAddress;
25import java.security.KeyStore;
26import java.security.Principal;
27import java.security.cert.Certificate;
28import java.security.cert.X509Certificate;
29import javax.net.ssl.KeyManager;
30import javax.net.ssl.KeyManagerFactory;
31import javax.net.ssl.SSLContext;
32import javax.net.ssl.SSLServerSocket;
33import javax.net.ssl.SSLSession;
34import javax.net.ssl.SSLSessionBindingEvent;
35import javax.net.ssl.SSLSessionBindingListener;
36import javax.net.ssl.SSLSocket;
37import javax.net.ssl.TrustManager;
38import junit.framework.TestCase;
39import libcore.io.Base64;
40import tests.api.javax.net.ssl.HandshakeCompletedEventTest.MyHandshakeListener;
41import tests.api.javax.net.ssl.HandshakeCompletedEventTest.TestTrustManager;
42
43public class SSLSessionTest extends TestCase {
44
45    // set to true if on Android, false if on RI
46    boolean useBKS = true;
47
48    /**
49     * javax.net.ssl.SSLSession#getPeerHost()
50     * javax.net.ssl.SSLSession#getPeerPort()
51     */
52    public void test_getPeerHost() throws Exception {
53        SSLSession s = clientSession;
54        assertEquals(InetAddress.getLocalHost().getHostName(), s.getPeerHost());
55        assertEquals(serverSocket.getLocalPort(), s.getPeerPort());
56    }
57
58    /**
59     * javax.net.ssl.SSLSession#invalidate()
60     * javax.net.ssl.SSLSession#isValid()
61     */
62    public void test_invalidate() {
63        SSLSession s = clientSession;
64        assertTrue(s.isValid());
65        s.invalidate();
66        assertFalse(s.isValid());
67    }
68
69    /**
70     * javax.net.ssl.SSLSession#getPeerPrincipal()
71     */
72    public void test_getPeerPrincipal() throws Exception {
73        Principal p1 = clientSession.getPeerPrincipal();
74        KeyStore store = server.getStore();
75        X509Certificate cert = (X509Certificate)store.getCertificate("mykey");
76        Principal p2 = cert.getSubjectX500Principal();
77        assertEquals(p1, p2);
78    }
79
80    /**
81     * javax.net.ssl.SSLSession#getApplicationBufferSize()
82     */
83    public void test_getApplicationBufferSize() {
84        assertTrue(clientSession.getApplicationBufferSize() > 0);
85    }
86
87    /**
88     * javax.net.ssl.SSLSession#getCipherSuite()
89     */
90    public void test_getCipherSuite() {
91        assertEquals(CIPHER_SUITE, clientSession.getCipherSuite());
92    }
93
94    /**
95     * javax.net.ssl.SSLSession#getCreationTime()
96     */
97    public void test_getCreationTime() {
98        // check if creation time was in the last 10 seconds
99        long currentTime = System.currentTimeMillis();
100        long sessionTime = clientSession.getCreationTime();
101        long diff = currentTime - sessionTime;
102        assertTrue("diff between " + currentTime + " and " + sessionTime + " should be < 10000",
103                   diff < 10000);
104    }
105
106    /**
107     * javax.net.ssl.SSLSession#getId()
108     */
109    public void test_getId() {
110        byte[] id = clientSession.getId();
111        SSLSession sess = clientSslContext.getClientSessionContext().getSession(id);
112        assertNotNull("Could not find session for id " + id, sess);
113        assertEquals(clientSession, sess);
114    }
115
116    /**
117     * javax.net.ssl.SSLSession#getLastAccessedTime()
118     */
119    public void test_getLastAccessedTime() {
120        // check if last access time was in the last 10 seconds
121        long currentTime = System.currentTimeMillis();
122        long sessionTime = clientSession.getLastAccessedTime();
123        long diff = currentTime - sessionTime;
124        assertTrue("diff between " + currentTime + " and " + sessionTime + " should be < 10000",
125                   diff < 10000);
126        assertTrue ("diff should be < 10000 but is " + diff, diff < 10000);
127    }
128
129    /**
130     * javax.net.ssl.SSLSession#getLocalCertificates()
131     */
132    public void test_getLocalCertificates() throws Exception {
133        KeyStore store = client.getStore();
134        Certificate cert = store.getCertificate("mykey");
135        Certificate[] certs = clientSession.getLocalCertificates();
136        assertEquals(cert, certs[0]);
137    }
138
139    /**
140     * javax.net.ssl.SSLSession#getLocalPrincipal()
141     */
142    public void test_getLocalPrincipal() throws Exception {
143        Principal p1 = clientSession.getLocalPrincipal();
144        KeyStore store = client.getStore();
145        X509Certificate cert = (X509Certificate)store.getCertificate("mykey");
146        Principal p2 = cert.getSubjectX500Principal();
147        assertEquals(p1, p2);
148    }
149
150    /**
151     * javax.net.ssl.SSLSession#getPacketBufferSize()
152     */
153    public void test_getPacketBufferSize() {
154        assertTrue(clientSession.getPacketBufferSize() > 0);
155    }
156
157    /**
158     * javax.net.ssl.SSLSession#getPeerCertificates()
159     */
160    public void test_getPeerCertificates() throws Exception {
161        Certificate[] res = clientSession.getPeerCertificates();
162        assertTrue(res.length > 0);
163    }
164
165    /**
166     * javax.net.ssl.SSLSession#getPeerCertificateChain()
167     */
168    public void test_getPeerCertificateChain() throws Exception {
169        javax.security.cert.X509Certificate[] res = clientSession.getPeerCertificateChain();
170        assertTrue(res.length > 0);
171    }
172
173    /**
174     * javax.net.ssl.SSLSession#getProtocol()
175     */
176    public void test_getProtocol() {
177        assertEquals("TLSv1", clientSession.getProtocol());
178    }
179
180    /**
181     * javax.net.ssl.SSLSession#getSessionContext()
182     */
183    public void test_getSessionContext() {
184        assertEquals(clientSession.getSessionContext(),
185                     clientSslContext.getClientSessionContext());
186    }
187
188    /**
189     * javax.net.ssl.SSLSession#putValue(String name, Object value)
190     * javax.net.ssl.SSLSession#removeValue(String name)
191     * javax.net.ssl.SSLSession#getValueNames()
192     */
193    public void test_putValue() {
194        SSLSession s = clientSession;
195        mySSLSessionBindingListener sbl = new mySSLSessionBindingListener();
196        assertNotNull(s.getValueNames());
197        assertEquals(0, s.getValueNames().length);
198        s.putValue("Name_01", sbl);
199        s.putValue("Name_02", sbl);
200        s.putValue("Name_03", sbl);
201        assertEquals(3, s.getValueNames().length);
202        s.removeValue("Name_01");
203        assertEquals(2, s.getValueNames().length);
204
205        try {
206            s.putValue(null, null);
207            fail("IllegalArgumentException wasn't thrown");
208        } catch (IllegalArgumentException expected) {
209            // expected
210        }
211        try {
212            s.putValue("ABC", null);
213            fail("IllegalArgumentException wasn't thrown");
214        } catch (IllegalArgumentException expected) {
215            // expected
216        }
217        try {
218            s.putValue(null, sbl);
219            fail("IllegalArgumentException wasn't thrown");
220        } catch (IllegalArgumentException expected) {
221            // expected
222        }
223
224        try {
225            s.removeValue(null);
226            fail("IllegalArgumentException wasn't thrown");
227        } catch (IllegalArgumentException expected) {
228            // expected
229        }
230    }
231
232    /**
233     * javax.net.ssl.SSLSession#getValue(String name)
234     */
235    public void test_getValue() {
236        SSLSession s = clientSession;
237        mySSLSessionBindingListener sbl = new mySSLSessionBindingListener();
238
239        try {
240            s.getValue(null);
241            fail("IllegalArgumentException wasn't thrown");
242        } catch (IllegalArgumentException expected) {
243            // expected
244        }
245
246        s.putValue("Name", sbl);
247        Object obj = s.getValue("Name");
248        assertTrue(obj instanceof SSLSessionBindingListener);
249    }
250
251    Thread serverThread, clientThread;
252    TestServer server;
253    TestClient client;
254
255    @Override
256    protected void setUp() throws Exception {
257        String serverKeys = (useBKS ? SERVER_KEYS_BKS : SERVER_KEYS_JKS);
258        String clientKeys = (useBKS ? CLIENT_KEYS_BKS : CLIENT_KEYS_JKS);
259        server = new TestServer(true, TestServer.CLIENT_AUTH_WANTED, serverKeys);
260        client = new TestClient(true, clientKeys);
261
262        serverThread = new Thread(server);
263        clientThread = new Thread(client);
264
265        serverThread.start();
266        try {
267            Thread.currentThread().sleep(1000);
268            clientThread.start();
269        } catch (InterruptedException e) {
270            fail("Could not create server or cient " + e.getMessage());
271        }
272        while (clientSession == null
273                && server.exception == null
274                && client.exception == null) {
275            try {
276                Thread.currentThread().sleep(500);
277            } catch (InterruptedException e) {
278                fail("couldn't create session");
279            }
280        }
281        if (server.exception != null) {
282            server.exception.printStackTrace();
283        }
284        assertNull("server thread has a pending exception: " + server.exception,
285                server.exception);
286        if (client.exception != null) {
287            client.exception.printStackTrace();
288        }
289        assertNull("client thread has a pending exception: " + client.exception,
290                client.exception);
291        assertNotNull("Could not initialize session", clientSession);
292    }
293
294    @Override
295    protected void tearDown() {
296        notFinished = false;
297        try {
298            serverThread.join();
299        } catch (InterruptedException e) {
300            throw new RuntimeException(e);
301        }
302        try {
303            clientThread.join();
304        } catch (InterruptedException e) {
305            throw new RuntimeException(e);
306        }
307
308        // The server must have completed without an exception.
309        if (server.getException() != null) {
310            throw new RuntimeException(server.getException());
311        }
312
313        // The client must have completed without an exception.
314        if (client.getException() != null) {
315            throw new RuntimeException(client.getException());
316        }
317    }
318
319    public class mySSLSessionBindingListener implements
320            SSLSessionBindingListener {
321        mySSLSessionBindingListener() {
322        }
323        public void valueBound(SSLSessionBindingEvent event) {}
324        public void valueUnbound(SSLSessionBindingEvent event) {}
325    }
326
327    /**
328     * Defines the keystore contents for the server, BKS version. Holds just a
329     * single self-generated key. The subject name is "Test Server".
330     */
331    private static final String SERVER_KEYS_BKS =
332            "AAAAAQAAABQDkebzoP1XwqyWKRCJEpn/t8dqIQAABDkEAAVteWtleQAAARpYl20nAAAAAQAFWC41"
333            + "MDkAAAJNMIICSTCCAbKgAwIBAgIESEfU1jANBgkqhkiG9w0BAQUFADBpMQswCQYDVQQGEwJVUzET"
334            + "MBEGA1UECBMKQ2FsaWZvcm5pYTEMMAoGA1UEBxMDTVRWMQ8wDQYDVQQKEwZHb29nbGUxEDAOBgNV"
335            + "BAsTB0FuZHJvaWQxFDASBgNVBAMTC1Rlc3QgU2VydmVyMB4XDTA4MDYwNTExNTgxNFoXDTA4MDkw"
336            + "MzExNTgxNFowaTELMAkGA1UEBhMCVVMxEzARBgNVBAgTCkNhbGlmb3JuaWExDDAKBgNVBAcTA01U"
337            + "VjEPMA0GA1UEChMGR29vZ2xlMRAwDgYDVQQLEwdBbmRyb2lkMRQwEgYDVQQDEwtUZXN0IFNlcnZl"
338            + "cjCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0LIdKaIr9/vsTq8BZlA3R+NFWRaH4lGsTAQy"
339            + "DPMF9ZqEDOaL6DJuu0colSBBBQ85hQTPa9m9nyJoN3pEi1hgamqOvQIWcXBk+SOpUGRZZFXwniJV"
340            + "zDKU5nE9MYgn2B9AoiH3CSuMz6HRqgVaqtppIe1jhukMc/kHVJvlKRNy9XMCAwEAATANBgkqhkiG"
341            + "9w0BAQUFAAOBgQC7yBmJ9O/eWDGtSH9BH0R3dh2NdST3W9hNZ8hIa8U8klhNHbUCSSktZmZkvbPU"
342            + "hse5LI3dh6RyNDuqDrbYwcqzKbFJaq/jX9kCoeb3vgbQElMRX8D2ID1vRjxwlALFISrtaN4VpWzV"
343            + "yeoHPW4xldeZmoVtjn8zXNzQhLuBqX2MmAAAAqwAAAAUvkUScfw9yCSmALruURNmtBai7kQAAAZx"
344            + "4Jmijxs/l8EBaleaUru6EOPioWkUAEVWCxjM/TxbGHOi2VMsQWqRr/DZ3wsDmtQgw3QTrUK666sR"
345            + "MBnbqdnyCyvM1J2V1xxLXPUeRBmR2CXorYGF9Dye7NkgVdfA+9g9L/0Au6Ugn+2Cj5leoIgkgApN"
346            + "vuEcZegFlNOUPVEs3SlBgUF1BY6OBM0UBHTPwGGxFBBcetcuMRbUnu65vyDG0pslT59qpaR0TMVs"
347            + "P+tcheEzhyjbfM32/vwhnL9dBEgM8qMt0sqF6itNOQU/F4WGkK2Cm2v4CYEyKYw325fEhzTXosck"
348            + "MhbqmcyLab8EPceWF3dweoUT76+jEZx8lV2dapR+CmczQI43tV9btsd1xiBbBHAKvymm9Ep9bPzM"
349            + "J0MQi+OtURL9Lxke/70/MRueqbPeUlOaGvANTmXQD2OnW7PISwJ9lpeLfTG0LcqkoqkbtLKQLYHI"
350            + "rQfV5j0j+wmvmpMxzjN3uvNajLa4zQ8l0Eok9SFaRr2RL0gN8Q2JegfOL4pUiHPsh64WWya2NB7f"
351            + "V+1s65eA5ospXYsShRjo046QhGTmymwXXzdzuxu8IlnTEont6P4+J+GsWk6cldGbl20hctuUKzyx"
352            + "OptjEPOKejV60iDCYGmHbCWAzQ8h5MILV82IclzNViZmzAapeeCnexhpXhWTs+xDEYSKEiG/camt"
353            + "bhmZc3BcyVJrW23PktSfpBQ6D8ZxoMfF0L7V2GQMaUg+3r7ucrx82kpqotjv0xHghNIm95aBr1Qw"
354            + "1gaEjsC/0wGmmBDg1dTDH+F1p9TInzr3EFuYD0YiQ7YlAHq3cPuyGoLXJ5dXYuSBfhDXJSeddUkl"
355            + "k1ufZyOOcskeInQge7jzaRfmKg3U94r+spMEvb0AzDQVOKvjjo1ivxMSgFRZaDb/4qw=";
356
357    /**
358     * Defines the keystore contents for the client, BKS version. Holds just a
359     * single self-generated key. The subject name is "Test Client".
360     */
361    private static final String CLIENT_KEYS_BKS =
362            "AAAAAQAAABT4Rka6fxbFps98Y5k2VilmbibNkQAABfQEAAVteWtleQAAARpYl+POAAAAAQAFWC41"
363            + "MDkAAAJNMIICSTCCAbKgAwIBAgIESEfU9TANBgkqhkiG9w0BAQUFADBpMQswCQYDVQQGEwJVUzET"
364            + "MBEGA1UECBMKQ2FsaWZvcm5pYTEMMAoGA1UEBxMDTVRWMQ8wDQYDVQQKEwZHb29nbGUxEDAOBgNV"
365            + "BAsTB0FuZHJvaWQxFDASBgNVBAMTC1Rlc3QgQ2xpZW50MB4XDTA4MDYwNTExNTg0NVoXDTA4MDkw"
366            + "MzExNTg0NVowaTELMAkGA1UEBhMCVVMxEzARBgNVBAgTCkNhbGlmb3JuaWExDDAKBgNVBAcTA01U"
367            + "VjEPMA0GA1UEChMGR29vZ2xlMRAwDgYDVQQLEwdBbmRyb2lkMRQwEgYDVQQDEwtUZXN0IENsaWVu"
368            + "dDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEApUvmWsQDHPpbDKK13Yez2/q54tTOmRml/qva"
369            + "2K6dZjkjSTW0iRuk7ztaVEvdJpfVIDv1oBsCI51ttyLHROy1epjF+GoL74mJb7fkcd0VOoSOTjtD"
370            + "+3GgZkHPAm5YmUYxiJXqxKKJJqMCTIW46eJaA2nAep9QIwZ14/NFAs4ObV8CAwEAATANBgkqhkiG"
371            + "9w0BAQUFAAOBgQCJrCr3hZQFDlLIfsSKI1/w+BLvyf4fubOid0pBxfklR8KBNPTiqjSmu7pd/C/F"
372            + "1FR8CdZUDoPflZHCOU+fj5r5KUC1HyigY/tEUvlforBpfB0uCF+tXW4DbUfOWhfMtLV4nCOJOOZg"
373            + "awfZLJWBJouLKOp427vDftxTSB+Ks8YjlgAAAqwAAAAU+NH6TtrzjyDdCXm5B6Vo7xX5G4YAAAZx"
374            + "EAUkcZtmykn7YdaYxC1jRFJ+GEJpC8nZVg83QClVuCSIS8a5f8Hl44Bk4oepOZsPzhtz3RdVzDVi"
375            + "RFfoyZFsrk9F5bDTVJ6sQbb/1nfJkLhZFXokka0vND5AXMSoD5Bj1Fqem3cK7fSUyqKvFoRKC3XD"
376            + "FQvhqoam29F1rbl8FaYdPvhhZo8TfZQYUyUKwW+RbR44M5iHPx+ykieMe/C/4bcM3z8cwIbYI1aO"
377            + "gjQKS2MK9bs17xaDzeAh4sBKrskFGrDe+2dgvrSKdoakJhLTNTBSG6m+rzqMSCeQpafLKMSjTSSz"
378            + "+KoQ9bLyax8cbvViGGju0SlVhquloZmKOfHr8TukIoV64h3uCGFOVFtQjCYDOq6NbfRvMh14UVF5"
379            + "zgDIGczoD9dMoULWxBmniGSntoNgZM+QP6Id7DBasZGKfrHIAw3lHBqcvB5smemSu7F4itRoa3D8"
380            + "N7hhUEKAc+xA+8NKmXfiCBoHfPHTwDvt4IR7gWjeP3Xv5vitcKQ/MAfO5RwfzkYCXQ3FfjfzmsE1"
381            + "1IfLRDiBj+lhQSulhRVStKI88Che3M4JUNGKllrc0nt1pWa1vgzmUhhC4LSdm6trTHgyJnB6OcS9"
382            + "t2furYjK88j1AuB4921oxMxRm8c4Crq8Pyuf+n3YKi8Pl2BzBtw++0gj0ODlgwut8SrVj66/nvIB"
383            + "jN3kLVahR8nZrEFF6vTTmyXi761pzq9yOVqI57wJGx8o3Ygox1p+pWUPl1hQR7rrhUbgK/Q5wno9"
384            + "uJk07h3IZnNxE+/IKgeMTP/H4+jmyT4mhsexJ2BFHeiKF1KT/FMcJdSi+ZK5yoNVcYuY8aZbx0Ef"
385            + "lHorCXAmLFB0W6Cz4KPP01nD9YBB4olxiK1t7m0AU9zscdivNiuUaB5OIEr+JuZ6dNw=";
386
387    private static final String CIPHER_SUITE = "SSL_RSA_WITH_RC4_128_MD5";
388    /**
389     * Defines the keystore contents for the server, JKS version. Holds just a
390     * single self-generated key. The subject name is "Test Server".
391     */
392    private static final String SERVER_KEYS_JKS =
393            "/u3+7QAAAAIAAAABAAAAAQAFbXlrZXkAAAEaWFfBeAAAArowggK2MA4GCisGAQQBKgIRAQEFAASC"
394            + "AqI2kp5XjnF8YZkhcF92YsJNQkvsmH7zqMM87j23zSoV4DwyE3XeC/gZWq1ToScIhoqZkzlbWcu4"
395            + "T/Zfc/DrfGk/rKbBL1uWKGZ8fMtlZk8KoAhxZk1JSyJvdkyKxqmzUbxk1OFMlN2VJNu97FPVH+du"
396            + "dvjTvmpdoM81INWBW/1fZJeQeDvn4mMbbe0IxgpiLnI9WSevlaDP/sm1X3iO9yEyzHLL+M5Erspo"
397            + "Cwa558fOu5DdsICMXhvDQxjWFKFhPHnKtGe+VvwkG9/bAaDgx3kfhk0w5zvdnkKb+8Ed9ylNRzdk"
398            + "ocAa/mxlMTOsTvDKXjjsBupNPIIj7OP4GNnZaxkJjSs98pEO67op1GX2qhy6FSOPNuq8k/65HzUc"
399            + "PYn6voEeh6vm02U/sjEnzRevQ2+2wXoAdp0EwtQ/DlMe+NvcwPGWKuMgX4A4L93DZGb04N2VmAU3"
400            + "YLOtZwTO0LbuWrcCM/q99G/7LcczkxIVrO2I/rh8RXVczlf9QzcrFObFv4ATuspWJ8xG7DhsMbnk"
401            + "rT94Pq6TogYeoz8o8ZMykesAqN6mt/9+ToIemmXv+e+KU1hI5oLwWMnUG6dXM6hIvrULY6o+QCPH"
402            + "172YQJMa+68HAeS+itBTAF4Clm/bLn6reHCGGU6vNdwU0lYldpiOj9cB3t+u2UuLo6tiFWjLf5Zs"
403            + "EQJETd4g/EK9nHxJn0GAKrWnTw7pEHQJ08elzUuy04C/jEEG+4QXU1InzS4o/kR0Sqz2WTGDoSoq"
404            + "ewuPRU5bzQs/b9daq3mXrnPtRBL6HfSDAdpTK76iHqLCGdqx3avHjVSBm4zFvEuYBCev+3iKOBmg"
405            + "yh7eQRTjz4UOWfy85omMBr7lK8PtfVBDzOXpasxS0uBgdUyBDX4tO6k9jZ8a1kmQRQAAAAEABVgu"
406            + "NTA5AAACSDCCAkQwggGtAgRIR8SKMA0GCSqGSIb3DQEBBAUAMGkxCzAJBgNVBAYTAlVTMRMwEQYD"
407            + "VQQIEwpDYWxpZm9ybmlhMQwwCgYDVQQHEwNNVFYxDzANBgNVBAoTBkdvb2dsZTEQMA4GA1UECxMH"
408            + "QW5kcm9pZDEUMBIGA1UEAxMLVGVzdCBTZXJ2ZXIwHhcNMDgwNjA1MTA0ODQyWhcNMDgwOTAzMTA0"
409            + "ODQyWjBpMQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZvcm5pYTEMMAoGA1UEBxMDTVRWMQ8w"
410            + "DQYDVQQKEwZHb29nbGUxEDAOBgNVBAsTB0FuZHJvaWQxFDASBgNVBAMTC1Rlc3QgU2VydmVyMIGf"
411            + "MA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCwoC6chqCI84rj1PrXuJgbiit4EV909zR6N0jNlYfg"
412            + "itwB39bP39wH03rFm8T59b3mbSptnGmCIpLZn25KPPFsYD3JJ+wFlmiUdEP9H05flfwtFQJnw9uT"
413            + "3rRIdYVMPcQ3RoZzwAMliGr882I2thIDbA6xjGU/1nRIdvk0LtxH3QIDAQABMA0GCSqGSIb3DQEB"
414            + "BAUAA4GBAJn+6YgUlY18Ie+0+Vt8oEi81DNi/bfPrAUAh63fhhBikx/3R9dl3wh09Z6p7cIdNxjW"
415            + "n2ll+cRW9eqF7z75F0Omm0C7/KAEPjukVbszmzeU5VqzkpSt0j84YWi+TfcHRrfvhLbrlmGITVpY"
416            + "ol5pHLDyqGmDs53pgwipWqsn/nEXEBgj3EoqPeqHbDf7YaP8h/5BSt0=";
417
418    /**
419     * Defines the keystore contents for the client, JKS version. Holds just a
420     * single self-generated key. The subject name is "Test Client".
421     */
422    private static final String CLIENT_KEYS_JKS =
423            "/u3+7QAAAAIAAAABAAAAAQAFbXlrZXkAAAEaWFhyMAAAArkwggK1MA4GCisGAQQBKgIRAQEFAASC"
424            + "AqGVSfXolBStZy4nnRNn4fAr+S7kfU2BS23wwW8uB2Ru3GvtLzlK9q08Gvq/LNqBafjyFTVL5FV5"
425            + "SED/8YomO5a98GpskSeRvytCiTBLJdgGhws5TOGekgIAcBROPGIyOtJPQ0HfOQs+BqgzGDHzHQhw"
426            + "u/8Tm6yQwiP+W/1I9B1QnaEztZA3mhTyMMJsmsFTYroGgAog885D5Cmzd8sYGfxec3R6I+xcmBAY"
427            + "eibR5kGpWwt1R+qMvRrtBqh5r6WSKhCBNax+SJVbtUNRiKyjKccdJg6fGqIWWeivwYTy0OhjA6b4"
428            + "NiZ/ZZs5pxFGWUj/Rlp0RYy8fCF6aw5/5s4Bf4MI6dPSqMG8Hf7sJR91GbcELyzPdM0h5lNavgit"
429            + "QPEzKeuDrGxhY1frJThBsNsS0gxeu+OgfJPEb/H4lpYX5IvuIGbWKcxoO9zq4/fimIZkdA8A+3eY"
430            + "mfDaowvy65NBVQPJSxaOyFhLHfeLqOeCsVENAea02vA7andZHTZehvcrqyKtm+z8ncHGRC2H9H8O"
431            + "jKwKHfxxrYY/jMAKLl00+PBb3kspO+BHI2EcQnQuMw/zr83OR9Meq4TJ0TMuNkApZELAeFckIBbS"
432            + "rBr8NNjAIfjuCTuKHhsTFWiHfk9ZIzigxXagfeDRiyVc6khOuF/bGorj23N2o7Rf3uLoU6PyXWi4"
433            + "uhctR1aL6NzxDoK2PbYCeA9hxbDv8emaVPIzlVwpPK3Ruvv9mkjcOhZ74J8bPK2fQmbplbOljcZi"
434            + "tZijOfzcO/11JrwhuJZRA6wanTqHoujgChV9EukVrmbWGGAcewFnAsSbFXIik7/+QznXaDIt5NgL"
435            + "H/Bcz4Z/fdV7Ae1eUaxKXdPbI//4J+8liVT/d8awjW2tldIaDlmGMR3aoc830+3mAAAAAQAFWC41"
436            + "MDkAAAJIMIICRDCCAa0CBEhHxLgwDQYJKoZIhvcNAQEEBQAwaTELMAkGA1UEBhMCVVMxEzARBgNV"
437            + "BAgTCkNhbGlmb3JuaWExDDAKBgNVBAcTA01UVjEPMA0GA1UEChMGR29vZ2xlMRAwDgYDVQQLEwdB"
438            + "bmRyb2lkMRQwEgYDVQQDEwtUZXN0IENsaWVudDAeFw0wODA2MDUxMDQ5MjhaFw0wODA5MDMxMDQ5"
439            + "MjhaMGkxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlhMQwwCgYDVQQHEwNNVFYxDzAN"
440            + "BgNVBAoTBkdvb2dsZTEQMA4GA1UECxMHQW5kcm9pZDEUMBIGA1UEAxMLVGVzdCBDbGllbnQwgZ8w"
441            + "DQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAIK3Q+KiFbmCGg422TAo4gggdhMH6FJhiuz8DxRyeMKR"
442            + "UAfP4MK0wtc8N42waZ6OKvxpBFUy0BRfBsX0GD4Ku99yu9/tavSigTraeJtwV3WWRRjIqk7L3wX5"
443            + "cmgS2KSD43Y0rNUKrko26lnt9N4qiYRBSj+tcAN3Lx9+ptqk1LApAgMBAAEwDQYJKoZIhvcNAQEE"
444            + "BQADgYEANb7Q1GVSuy1RPJ0FmiXoMYCCtvlRLkmJphwxovK0cAQK12Vll+yAzBhHiQHy/RA11mng"
445            + "wYudC7u3P8X/tBT8GR1Yk7QW3KgFyPafp3lQBBCraSsfrjKj+dCLig1uBLUr4f68W8VFWZWWTHqp"
446            + "NMGpCX6qmjbkJQLVK/Yfo1ePaUexPSOX0G9m8+DoV3iyNw6at01NRw==";
447
448
449    SSLServerSocket serverSocket;
450    MyHandshakeListener listener;
451    String host = "localhost";
452    boolean notFinished = true;
453    SSLSession clientSession = null;
454    SSLContext clientSslContext = null;
455    String testData = "PING";
456
457    private String PASSWORD = "android";
458
459    /**
460     * Implements a test SSL socket server. It waits for a connection on a given
461     * port, requests client authentication (if specified), reads from the socket,
462     * and writes to the socket.
463     */
464    class TestServer implements Runnable {
465
466        public static final int CLIENT_AUTH_NONE = 0;
467
468        public static final int CLIENT_AUTH_WANTED = 1;
469
470        public static final int CLIENT_AUTH_NEEDED = 2;
471
472        private TestTrustManager trustManager;
473
474        private Exception exception;
475
476        String keys;
477
478        private int clientAuth;
479
480        private boolean provideKeys;
481
482        private KeyStore store;
483
484        public TestServer(boolean provideKeys, int clientAuth, String keys) throws Exception {
485            this.keys = keys;
486            this.clientAuth = clientAuth;
487            this.provideKeys = provideKeys;
488
489            trustManager = new TestTrustManager();
490
491            store = provideKeys ? getKeyStore(keys) : null;
492            KeyManager[] keyManagers = store != null ? getKeyManagers(store) : null;
493            TrustManager[] trustManagers = new TrustManager[] { trustManager };
494
495            SSLContext sslContext = SSLContext.getInstance("TLS");
496            sslContext.init(keyManagers, trustManagers, null);
497
498            serverSocket = (SSLServerSocket)sslContext.getServerSocketFactory().createServerSocket();
499
500            if (clientAuth == CLIENT_AUTH_WANTED) {
501                serverSocket.setWantClientAuth(true);
502            } else if (clientAuth == CLIENT_AUTH_NEEDED) {
503                serverSocket.setNeedClientAuth(true);
504            } else {
505                serverSocket.setWantClientAuth(false);
506            }
507
508            serverSocket.bind(null);
509        }
510
511        public void run() {
512            try {
513                SSLSocket clientSocket = (SSLSocket)serverSocket.accept();
514
515                InputStream istream = clientSocket.getInputStream();
516                byte[] buffer = new byte[1024];
517                istream.read(buffer);
518
519                OutputStream ostream = clientSocket.getOutputStream();
520                ostream.write(testData.getBytes());
521                ostream.flush();
522
523                while (notFinished) {
524                    Thread.currentThread().sleep(500);
525                }
526
527                clientSocket.close();
528                serverSocket.close();
529
530            } catch (Exception ex) {
531                exception = ex;
532            }
533        }
534
535        public Exception getException() {
536            return exception;
537        }
538
539        public javax.security.cert.X509Certificate[] getChain() {
540            return trustManager.getChain();
541        }
542
543        public KeyStore getStore() {
544            return store;
545        }
546
547    }
548
549    /**
550     * Implements a test SSL socket client. It opens a connection to localhost on
551     * a given port, writes to the socket, and reads from the socket.
552     */
553    class TestClient implements Runnable {
554
555        private TestTrustManager trustManager;
556
557        private Exception exception;
558
559        private String keys;
560
561        private boolean provideKeys;
562
563        private KeyStore store;
564
565        public TestClient(boolean provideKeys, String keys) {
566            this.keys = keys;
567            this.provideKeys = provideKeys;
568
569            trustManager = new TestTrustManager();
570        }
571
572        public void run() {
573            try {
574                store = provideKeys ? getKeyStore(keys) : null;
575                KeyManager[] keyManagers = store != null ? getKeyManagers(store) : null;
576                TrustManager[] trustManagers = new TrustManager[] { trustManager };
577
578                clientSslContext = SSLContext.getInstance("TLS");
579                clientSslContext.init(keyManagers, trustManagers, null);
580
581                SSLSocket socket = (SSLSocket)clientSslContext.getSocketFactory().createSocket();
582
583                socket.connect(serverSocket.getLocalSocketAddress());
584                OutputStream ostream = socket.getOutputStream();
585                ostream.write(testData.getBytes());
586                ostream.flush();
587
588                InputStream istream = socket.getInputStream();
589                byte[] buffer = new byte[1024];
590                istream.read(buffer);
591
592                clientSession = socket.getSession();
593                while (notFinished) {
594                    Thread.currentThread().sleep(500);
595                }
596                socket.close();
597
598            } catch (Exception ex) {
599                exception = ex;
600            }
601        }
602
603        public Exception getException() {
604            return exception;
605        }
606
607        public javax.security.cert.X509Certificate[] getChain() {
608            return trustManager.getChain();
609        }
610
611        public KeyStore getStore() {
612            return store;
613        }
614    }
615
616    /**
617     * Loads a keystore from a base64-encoded String. Returns the KeyManager[]
618     * for the result.
619     */
620    private KeyStore getKeyStore(String keys) throws Exception {
621        byte[] bytes = Base64.decode(keys.getBytes());
622        InputStream inputStream = new ByteArrayInputStream(bytes);
623
624        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
625        keyStore.load(inputStream, PASSWORD.toCharArray());
626        inputStream.close();
627        return keyStore;
628    }
629
630    /**
631     * Loads a keystore from a base64-encoded String. Returns the KeyManager[]
632     * for the result.
633     */
634    private KeyManager[] getKeyManagers(KeyStore keyStore) throws Exception {
635        String algorithm = KeyManagerFactory.getDefaultAlgorithm();
636        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(algorithm);
637        keyManagerFactory.init(keyStore, PASSWORD.toCharArray());
638
639        return keyManagerFactory.getKeyManagers();
640    }
641}
642