1/*
2 * Copyright (C) 2007 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 tests.api.javax.net.ssl;
18
19import junit.framework.TestCase;
20
21import libcore.io.Base64;
22
23import java.io.ByteArrayInputStream;
24import java.io.IOException;
25import java.io.InputStream;
26import java.net.InetAddress;
27import java.security.KeyStore;
28import java.security.SecureRandom;
29import java.util.Arrays;
30
31import javax.net.ssl.KeyManager;
32import javax.net.ssl.KeyManagerFactory;
33import javax.net.ssl.SSLContext;
34import javax.net.ssl.SSLServerSocket;
35
36public class SSLServerSocketTest extends TestCase {
37
38    // set to true if on Android, false if on RI
39    boolean useBKS = true;
40
41    /**
42     * Additional class for SSLServerSocket constructor verification
43     */
44    class mySSLServerSocket extends SSLServerSocket {
45
46        public mySSLServerSocket() throws IOException{
47            super();
48        }
49
50        public mySSLServerSocket(int port) throws IOException{
51            super(port);
52        }
53
54        public mySSLServerSocket(int port, int backlog) throws IOException{
55            super(port, backlog);
56        }
57
58        public mySSLServerSocket(int port, int backlog, InetAddress address) throws IOException{
59            super(port, backlog, address);
60        }
61
62        public String[] getSupportedCipherSuites() {
63            return null;
64        }
65
66        public void setEnabledCipherSuites(String[] suites) {
67
68        }
69
70        public String[] getEnabledCipherSuites() {
71            return null;
72        }
73
74        public String[] getSupportedProtocols() {
75            return null;
76        }
77
78        public String[] getEnabledProtocols() {
79            return null;
80        }
81
82        public void setEnabledProtocols(String[] protocols) {
83
84        }
85
86        public void setEnableSessionCreation(boolean flag) {
87
88        }
89
90        public boolean getEnableSessionCreation() {
91            return false;
92        }
93
94        public void setNeedClientAuth(boolean need) {
95
96        }
97
98        public boolean getNeedClientAuth() {
99            return false;
100        }
101
102        public boolean getUseClientMode() {
103            return false;
104        }
105
106        public void setUseClientMode(boolean mode) {
107
108        }
109
110        public boolean getWantClientAuth() {
111            return false;
112        }
113        public void setWantClientAuth(boolean mode) {
114
115        }
116    }
117
118    /**
119     * javax.net.ssl.SSLServerSocket#SSLServerSocket()
120     */
121    public void testConstructor() throws Exception {
122        SSLServerSocket ssl = new mySSLServerSocket();
123    }
124
125    /**
126     * javax.net.ssl.SSLServerSocket#SSLServerSocket(int port)
127     */
128    public void testConstructor_I() throws Exception {
129        int[] port_invalid = {-1, 65536, Integer.MIN_VALUE, Integer.MAX_VALUE};
130
131        SSLServerSocket ssl = new mySSLServerSocket(0);
132
133        for (int i = 0; i < port_invalid.length; i++) {
134            try {
135                new mySSLServerSocket(port_invalid[i]);
136                fail("IllegalArgumentException should be thrown");
137            } catch (IllegalArgumentException expected) {
138            }
139        }
140
141        try {
142            new mySSLServerSocket(ssl.getLocalPort());
143            fail("IOException Expected when opening an already opened port");
144        } catch (IOException expected) {
145        }
146    }
147
148    /**
149     * javax.net.ssl.SSLServerSocket#SSLServerSocket(int port, int backlog)
150     */
151    public void testConstructor_II() throws Exception {
152        mySSLServerSocket ssl = new mySSLServerSocket(0, 1);
153        int[] port_invalid = {-1, Integer.MIN_VALUE, Integer.MAX_VALUE};
154
155        for (int i = 0; i < port_invalid.length; i++) {
156            try {
157                new mySSLServerSocket(port_invalid[i], 1);
158                fail("IllegalArgumentException should be thrown");
159            } catch (IllegalArgumentException expected) {
160            }
161        }
162
163        try {
164            new mySSLServerSocket(ssl.getLocalPort(), 1);
165            fail("IOException should be thrown");
166        } catch (IOException expected) {
167        }
168    }
169
170    /**
171     * javax.net.ssl.SSLServerSocket#SSLServerSocket(int port, int backlog, InetAddress address)
172     */
173    public void testConstructor_IIInetAddress() throws Exception {
174        // A null InetAddress is okay.
175        new mySSLServerSocket(0, 0, null);
176
177        int[] port_invalid = {-1, 65536, Integer.MIN_VALUE, Integer.MAX_VALUE};
178
179        mySSLServerSocket ssl = new mySSLServerSocket(0, 0, InetAddress.getLocalHost());
180
181        for (int i = 0; i < port_invalid.length; i++) {
182            try {
183                new mySSLServerSocket(port_invalid[i], 1, InetAddress.getLocalHost());
184                fail("IllegalArgumentException should be thrown");
185            } catch (IllegalArgumentException expected) {
186            }
187        }
188
189        try {
190            new mySSLServerSocket(ssl.getLocalPort(), 0, InetAddress.getLocalHost());
191            fail("IOException should be thrown for");
192        } catch (IOException expected) {
193        }
194    }
195
196    /**
197     * @throws Exception
198     * javax.net.ssl.SSLServerSocket#getSupportedCipherSuites()
199     */
200    public void test_getSupportedCipherSuites() throws Exception {
201        SSLServerSocket sss = getSSLServerSocket();
202        String[] res = sss.getSupportedCipherSuites();
203        assertNotNull("NULL result", res);
204        assertTrue("no supported cipher suites available.", res.length > 0);
205    }
206
207    /**
208     * @throws IOException
209     * javax.net.ssl.SSLServerSocket#getEnabledCipherSuites()
210     * javax.net.ssl.SSLServerSocket#setEnabledCipherSuites(String[] suites)
211     */
212    public void test_EnabledCipherSuites() throws Exception {
213        SSLServerSocket sss = getSSLServerSocket();
214        try {
215            sss.setEnabledCipherSuites(null);
216        } catch (IllegalArgumentException iae) {
217            //expected
218        }
219        String[] unsupportedCipherSuites = {"unsupported"};
220        try {
221            sss.setEnabledCipherSuites(unsupportedCipherSuites);
222        } catch (IllegalArgumentException iae) {
223            //expected
224        }
225        int count = sss.getSupportedCipherSuites().length;
226        assertTrue("No supported cipher suites", count > 0);
227        sss.setEnabledCipherSuites(sss.getSupportedCipherSuites());
228        String[] res = sss.getEnabledCipherSuites();
229        assertNotNull("NULL result", res);
230        assertEquals("not all supported cipher suites were enabled",
231                     Arrays.asList(sss.getSupportedCipherSuites()),
232                     Arrays.asList(res));
233    }
234
235    /**
236     * @throws IOException
237     * javax.net.ssl.SSLServerSocket#getSupportedProtocols()
238     */
239    public void test_getSupportedProtocols() throws Exception {
240        SSLServerSocket sss = getSSLServerSocket();
241        String[] res = sss.getSupportedCipherSuites();
242        assertNotNull("NULL result", res);
243        assertTrue("no supported protocols available.", res.length > 0);
244    }
245
246    /**
247     * @throws IOException
248     * javax.net.ssl.SSLServerSocket#getEnabledProtocols()
249     * javax.net.ssl.SSLServerSocket#setEnabledProtocols(String[] protocols)
250     */
251    public void test_EnabledProtocols() throws Exception {
252        SSLServerSocket sss = getSSLServerSocket();
253        try {
254            sss.setEnabledProtocols(null);
255        } catch (IllegalArgumentException iae) {
256            //expected
257        }
258        String[] unsupportedProtocols = {"unsupported"};
259        try {
260            sss.setEnabledProtocols(unsupportedProtocols);
261        } catch (IllegalArgumentException iae) {
262            //expected
263        }
264        int count = sss.getSupportedProtocols().length;
265        assertTrue("No supported protocols", count > 0);
266        sss.setEnabledProtocols(sss.getSupportedProtocols());
267        String[] res = sss.getEnabledProtocols();
268        assertNotNull("NULL result", res);
269        assertTrue("no enabled protocols.", res.length == count);
270    }
271
272    /**
273     * @throws IOException
274     * javax.net.ssl.SSLServerSocket#setEnableSessionCreation(boolean flag)
275     * javax.net.ssl.SSLServerSocket#getEnableSessionCreation()
276     */
277    public void test_EnableSessionCreation() throws Exception {
278        SSLServerSocket sss = getSSLServerSocket();
279        assertTrue(sss.getEnableSessionCreation());
280        sss.setEnableSessionCreation(false);
281        assertFalse(sss.getEnableSessionCreation());
282        sss.setEnableSessionCreation(true);
283        assertTrue(sss.getEnableSessionCreation());
284    }
285
286    /**
287     * @throws IOException
288     * javax.net.ssl.SSLServerSocket#setNeedClientAuth(boolean need)
289     * javax.net.ssl.SSLServerSocket#getNeedClientAuthCreation()
290     */
291    public void test_NeedClientAuth() throws Exception {
292        SSLServerSocket sss = getSSLServerSocket();
293        sss.setNeedClientAuth(true);
294        assertTrue(sss.getNeedClientAuth());
295        sss.setNeedClientAuth(false);
296        assertFalse(sss.getNeedClientAuth());
297    }
298
299    /**
300     * @throws IOException
301     * javax.net.ssl.SSLServerSocket#getUseClientMode()
302     * javax.net.ssl.SSLServerSocket#setUseClientMode(boolean mode)
303     */
304    public void test_UseClientMode() throws Exception {
305        SSLServerSocket sss = getSSLServerSocket();
306        sss.setUseClientMode(false);
307        assertFalse(sss.getUseClientMode());
308        sss.setUseClientMode(true);
309        assertTrue(sss.getUseClientMode());
310    }
311
312    /**
313     * @throws IOException
314     * javax.net.ssl.SSLServerSocket#setWantClientAuth(boolean want)
315     * javax.net.ssl.SSLServerSocket#getWantClientAuthCreation()
316     */
317    public void test_WantClientAuth() throws Exception {
318        SSLServerSocket sss = getSSLServerSocket();
319        sss.setWantClientAuth(true);
320        assertTrue(sss.getWantClientAuth());
321        sss.setWantClientAuth(false);
322        assertFalse(sss.getWantClientAuth());
323    }
324
325
326    /**
327     * Defines the keystore contents for the server, BKS version. Holds just a
328     * single self-generated key. The subject name is "Test Server".
329     */
330    private static final String SERVER_KEYS_BKS =
331        "AAAAAQAAABQDkebzoP1XwqyWKRCJEpn/t8dqIQAABDkEAAVteWtleQAAARpYl20nAAAAAQAFWC41" +
332        "MDkAAAJNMIICSTCCAbKgAwIBAgIESEfU1jANBgkqhkiG9w0BAQUFADBpMQswCQYDVQQGEwJVUzET" +
333        "MBEGA1UECBMKQ2FsaWZvcm5pYTEMMAoGA1UEBxMDTVRWMQ8wDQYDVQQKEwZHb29nbGUxEDAOBgNV" +
334        "BAsTB0FuZHJvaWQxFDASBgNVBAMTC1Rlc3QgU2VydmVyMB4XDTA4MDYwNTExNTgxNFoXDTA4MDkw" +
335        "MzExNTgxNFowaTELMAkGA1UEBhMCVVMxEzARBgNVBAgTCkNhbGlmb3JuaWExDDAKBgNVBAcTA01U" +
336        "VjEPMA0GA1UEChMGR29vZ2xlMRAwDgYDVQQLEwdBbmRyb2lkMRQwEgYDVQQDEwtUZXN0IFNlcnZl" +
337        "cjCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0LIdKaIr9/vsTq8BZlA3R+NFWRaH4lGsTAQy" +
338        "DPMF9ZqEDOaL6DJuu0colSBBBQ85hQTPa9m9nyJoN3pEi1hgamqOvQIWcXBk+SOpUGRZZFXwniJV" +
339        "zDKU5nE9MYgn2B9AoiH3CSuMz6HRqgVaqtppIe1jhukMc/kHVJvlKRNy9XMCAwEAATANBgkqhkiG" +
340        "9w0BAQUFAAOBgQC7yBmJ9O/eWDGtSH9BH0R3dh2NdST3W9hNZ8hIa8U8klhNHbUCSSktZmZkvbPU" +
341        "hse5LI3dh6RyNDuqDrbYwcqzKbFJaq/jX9kCoeb3vgbQElMRX8D2ID1vRjxwlALFISrtaN4VpWzV" +
342        "yeoHPW4xldeZmoVtjn8zXNzQhLuBqX2MmAAAAqwAAAAUvkUScfw9yCSmALruURNmtBai7kQAAAZx" +
343        "4Jmijxs/l8EBaleaUru6EOPioWkUAEVWCxjM/TxbGHOi2VMsQWqRr/DZ3wsDmtQgw3QTrUK666sR" +
344        "MBnbqdnyCyvM1J2V1xxLXPUeRBmR2CXorYGF9Dye7NkgVdfA+9g9L/0Au6Ugn+2Cj5leoIgkgApN" +
345        "vuEcZegFlNOUPVEs3SlBgUF1BY6OBM0UBHTPwGGxFBBcetcuMRbUnu65vyDG0pslT59qpaR0TMVs" +
346        "P+tcheEzhyjbfM32/vwhnL9dBEgM8qMt0sqF6itNOQU/F4WGkK2Cm2v4CYEyKYw325fEhzTXosck" +
347        "MhbqmcyLab8EPceWF3dweoUT76+jEZx8lV2dapR+CmczQI43tV9btsd1xiBbBHAKvymm9Ep9bPzM" +
348        "J0MQi+OtURL9Lxke/70/MRueqbPeUlOaGvANTmXQD2OnW7PISwJ9lpeLfTG0LcqkoqkbtLKQLYHI" +
349        "rQfV5j0j+wmvmpMxzjN3uvNajLa4zQ8l0Eok9SFaRr2RL0gN8Q2JegfOL4pUiHPsh64WWya2NB7f" +
350        "V+1s65eA5ospXYsShRjo046QhGTmymwXXzdzuxu8IlnTEont6P4+J+GsWk6cldGbl20hctuUKzyx" +
351        "OptjEPOKejV60iDCYGmHbCWAzQ8h5MILV82IclzNViZmzAapeeCnexhpXhWTs+xDEYSKEiG/camt" +
352        "bhmZc3BcyVJrW23PktSfpBQ6D8ZxoMfF0L7V2GQMaUg+3r7ucrx82kpqotjv0xHghNIm95aBr1Qw" +
353        "1gaEjsC/0wGmmBDg1dTDH+F1p9TInzr3EFuYD0YiQ7YlAHq3cPuyGoLXJ5dXYuSBfhDXJSeddUkl" +
354        "k1ufZyOOcskeInQge7jzaRfmKg3U94r+spMEvb0AzDQVOKvjjo1ivxMSgFRZaDb/4qw=";
355
356    /**
357     * Defines the keystore contents for the server, JKS version. Holds just a
358     * single self-generated key. The subject name is "Test Server".
359     */
360    private static final String SERVER_KEYS_JKS =
361        "/u3+7QAAAAIAAAABAAAAAQAFbXlrZXkAAAEaWFfBeAAAArowggK2MA4GCisGAQQBKgIRAQEFAASC" +
362        "AqI2kp5XjnF8YZkhcF92YsJNQkvsmH7zqMM87j23zSoV4DwyE3XeC/gZWq1ToScIhoqZkzlbWcu4" +
363        "T/Zfc/DrfGk/rKbBL1uWKGZ8fMtlZk8KoAhxZk1JSyJvdkyKxqmzUbxk1OFMlN2VJNu97FPVH+du" +
364        "dvjTvmpdoM81INWBW/1fZJeQeDvn4mMbbe0IxgpiLnI9WSevlaDP/sm1X3iO9yEyzHLL+M5Erspo" +
365        "Cwa558fOu5DdsICMXhvDQxjWFKFhPHnKtGe+VvwkG9/bAaDgx3kfhk0w5zvdnkKb+8Ed9ylNRzdk" +
366        "ocAa/mxlMTOsTvDKXjjsBupNPIIj7OP4GNnZaxkJjSs98pEO67op1GX2qhy6FSOPNuq8k/65HzUc" +
367        "PYn6voEeh6vm02U/sjEnzRevQ2+2wXoAdp0EwtQ/DlMe+NvcwPGWKuMgX4A4L93DZGb04N2VmAU3" +
368        "YLOtZwTO0LbuWrcCM/q99G/7LcczkxIVrO2I/rh8RXVczlf9QzcrFObFv4ATuspWJ8xG7DhsMbnk" +
369        "rT94Pq6TogYeoz8o8ZMykesAqN6mt/9+ToIemmXv+e+KU1hI5oLwWMnUG6dXM6hIvrULY6o+QCPH" +
370        "172YQJMa+68HAeS+itBTAF4Clm/bLn6reHCGGU6vNdwU0lYldpiOj9cB3t+u2UuLo6tiFWjLf5Zs" +
371        "EQJETd4g/EK9nHxJn0GAKrWnTw7pEHQJ08elzUuy04C/jEEG+4QXU1InzS4o/kR0Sqz2WTGDoSoq" +
372        "ewuPRU5bzQs/b9daq3mXrnPtRBL6HfSDAdpTK76iHqLCGdqx3avHjVSBm4zFvEuYBCev+3iKOBmg" +
373        "yh7eQRTjz4UOWfy85omMBr7lK8PtfVBDzOXpasxS0uBgdUyBDX4tO6k9jZ8a1kmQRQAAAAEABVgu" +
374        "NTA5AAACSDCCAkQwggGtAgRIR8SKMA0GCSqGSIb3DQEBBAUAMGkxCzAJBgNVBAYTAlVTMRMwEQYD" +
375        "VQQIEwpDYWxpZm9ybmlhMQwwCgYDVQQHEwNNVFYxDzANBgNVBAoTBkdvb2dsZTEQMA4GA1UECxMH" +
376        "QW5kcm9pZDEUMBIGA1UEAxMLVGVzdCBTZXJ2ZXIwHhcNMDgwNjA1MTA0ODQyWhcNMDgwOTAzMTA0" +
377        "ODQyWjBpMQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZvcm5pYTEMMAoGA1UEBxMDTVRWMQ8w" +
378        "DQYDVQQKEwZHb29nbGUxEDAOBgNVBAsTB0FuZHJvaWQxFDASBgNVBAMTC1Rlc3QgU2VydmVyMIGf" +
379        "MA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCwoC6chqCI84rj1PrXuJgbiit4EV909zR6N0jNlYfg" +
380        "itwB39bP39wH03rFm8T59b3mbSptnGmCIpLZn25KPPFsYD3JJ+wFlmiUdEP9H05flfwtFQJnw9uT" +
381        "3rRIdYVMPcQ3RoZzwAMliGr882I2thIDbA6xjGU/1nRIdvk0LtxH3QIDAQABMA0GCSqGSIb3DQEB" +
382        "BAUAA4GBAJn+6YgUlY18Ie+0+Vt8oEi81DNi/bfPrAUAh63fhhBikx/3R9dl3wh09Z6p7cIdNxjW" +
383        "n2ll+cRW9eqF7z75F0Omm0C7/KAEPjukVbszmzeU5VqzkpSt0j84YWi+TfcHRrfvhLbrlmGITVpY" +
384        "ol5pHLDyqGmDs53pgwipWqsn/nEXEBgj3EoqPeqHbDf7YaP8h/5BSt0=";
385
386    private String PASSWORD = "android";
387
388    /**
389     * Loads a keystore from a base64-encoded String. Returns the KeyManager[]
390     * for the result.
391     */
392    private KeyManager[] getKeyManagers() throws Exception {
393        String keys = (useBKS ? SERVER_KEYS_BKS : SERVER_KEYS_JKS);
394        byte[] bytes = Base64.decode(keys.getBytes());
395        InputStream inputStream = new ByteArrayInputStream(bytes);
396
397        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
398        keyStore.load(inputStream, PASSWORD.toCharArray());
399        inputStream.close();
400
401        String algorithm = KeyManagerFactory.getDefaultAlgorithm();
402        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(algorithm);
403        keyManagerFactory.init(keyStore, PASSWORD.toCharArray());
404
405        return keyManagerFactory.getKeyManagers();
406    }
407
408    private SSLServerSocket getSSLServerSocket() throws Exception {
409        SSLContext context = SSLContext.getInstance("TLS");
410        context.init(getKeyManagers(), null, null);
411        SSLServerSocket sss = (SSLServerSocket) context.getServerSocketFactory()
412                .createServerSocket();
413        return sss;
414    }
415
416    public void test_creationStressTest() throws Exception {
417        KeyManager[] keyManagers = getKeyManagers();
418        // Test the default codepath, which uses /dev/urandom.
419        SSLContext sslContext = SSLContext.getInstance("TLS");
420        sslContext.init(keyManagers, null, null);
421        for (int i = 0; i < 2048; ++i) {
422            sslContext.getServerSocketFactory().createServerSocket().close();
423        }
424
425        // Test the other codepath, which copies a seed from a byte[].
426        sslContext.init(keyManagers, null, new SecureRandom());
427        for (int i = 0; i < 2048; ++i) {
428            sslContext.getServerSocketFactory().createServerSocket().close();
429        }
430    }
431}
432