SSLServerSocketImplTest.java revision 561ee011997c6c2f1befbfaa9d5f0a99771c1d63 
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 org.apache.harmony.xnet.provider.jsse;
19
20import java.io.IOException;
21import java.net.Socket;
22import java.net.InetSocketAddress;
23import javax.net.ssl.SSLServerSocket;
24
25import junit.framework.Test;
26import junit.framework.TestCase;
27import junit.framework.TestSuite;
28
29/**
30 * SSLServerSocketImplTest test
31 */
32public class SSLServerSocketImplTest extends TestCase {
33
34    private static boolean doLog = false;
35
36    /**
37     * Sets up the test case.
38     */
39    @Override
40    public void setUp() {
41        if (doLog) {
42            System.out.println("");
43            System.out.println("========================");
44            System.out.println("====== Running the test: " + getName());
45        }
46    }
47
48    private SSLServerSocket createSSLServerSocket() throws Exception {
49        return new SSLServerSocketImpl(JSSETestData.getSSLParameters());
50    }
51
52    /**
53     * SSLServerSocketImpl(SSLParameters sslParameters) method testing.
54     */
55    public void testSSLServerSocketImpl1() throws Exception {
56        Client client = null;
57        SSLServerSocket ssocket = null;
58        try {
59            ssocket = new SSLServerSocketImpl(JSSETestData.getSSLParameters());
60            ssocket.bind(null);
61            ssocket.setUseClientMode(true);
62
63            final SSLServerSocket s = ssocket;
64            Thread thread = new Thread() {
65                @Override
66                public void run() {
67                    try {
68                        s.accept().close();
69                    } catch (Exception e) { }
70                }
71            };
72
73            thread.start();
74
75            client = new Client(ssocket.getLocalPort());
76            client.start();
77
78            int timeout = 10; // wait no more than 5 seconds for handshake
79            while (!client.handshakeStarted()) {
80                // wait for handshake start
81                try {
82                    Thread.sleep(500);
83                } catch (Exception e) { }
84                timeout--;
85                if (timeout < 0) {
86                    try {
87                        client.close();
88                    } catch (IOException ex) { }
89                    try {
90                        ssocket.close();
91                    } catch (IOException ex) { }
92                    fail("Handshake was not started");
93                }
94            }
95        } finally {
96            if (client != null) {
97                try {
98                    client.close();
99                } catch (IOException ex) { }
100            }
101            if (ssocket != null) {
102                try {
103                    ssocket.close();
104                } catch (IOException ex) { }
105            }
106        }
107    }
108
109    /**
110     * SSLServerSocketImpl(int port, SSLParameters sslParameters) method
111     * testing.
112     */
113    public void testSSLServerSocketImpl2() throws Exception {
114        Client client = null;
115        SSLServerSocket ssocket = null;
116        try {
117            ssocket = new SSLServerSocketImpl(0,
118                    JSSETestData.getSSLParameters());
119            ssocket.setUseClientMode(true);
120
121            final SSLServerSocket s = ssocket;
122            Thread thread = new Thread() {
123                @Override
124                public void run() {
125                    try {
126                        s.accept().close();
127                    } catch (Exception e) { }
128                }
129            };
130
131            thread.start();
132
133            client = new Client(ssocket.getLocalPort());
134            client.start();
135
136            int timeout = 10; // wait no more than 5 seconds for handshake
137            while (!client.handshakeStarted()) {
138                // wait for handshake start
139                try {
140                    Thread.sleep(500);
141                } catch (Exception e) { }
142                timeout--;
143                if (timeout < 0) {
144                    try {
145                        client.close();
146                    } catch (IOException ex) { }
147                    try {
148                        ssocket.close();
149                    } catch (IOException ex) { }
150                    fail("Handshake was not started");
151                }
152            }
153        } finally {
154            if (client != null) {
155                try {
156                    client.close();
157                } catch (IOException ex) { }
158            }
159            if (ssocket != null) {
160                try {
161                    ssocket.close();
162                } catch (IOException ex) { }
163            }
164        }
165    }
166
167    /**
168     * SSLServerSocketImpl(int port, int backlog,
169     * SSLParameters sslParameters) method testing.
170     */
171    public void testSSLServerSocketImpl3() throws Exception {
172        Client client = null;
173        SSLServerSocket ssocket = null;
174        try {
175            ssocket = new SSLServerSocketImpl(0, 1,
176                    JSSETestData.getSSLParameters());
177            ssocket.setUseClientMode(true);
178
179            final SSLServerSocket s = ssocket;
180            Thread thread = new Thread() {
181                @Override
182                public void run() {
183                    try {
184                        s.accept().close();
185                    } catch (Exception e) { }
186                }
187            };
188
189            thread.start();
190
191            client = new Client(ssocket.getLocalPort());
192            client.start();
193
194            int timeout = 10; // wait no more than 5 seconds for handshake
195            while (!client.handshakeStarted()) {
196                // wait for handshake start
197                try {
198                    Thread.sleep(500);
199                } catch (Exception e) { }
200                timeout--;
201                if (timeout < 0) {
202                    try {
203                        client.close();
204                    } catch (IOException ex) { }
205                    try {
206                        ssocket.close();
207                    } catch (IOException ex) { }
208                    fail("Handshake was not started");
209                }
210            }
211        } finally {
212            if (client != null) {
213                try {
214                    client.close();
215                } catch (IOException ex) { }
216            }
217            if (ssocket != null) {
218                try {
219                    ssocket.close();
220                } catch (IOException ex) { }
221            }
222        }
223    }
224
225    /**
226     * SSLServerSocketImpl(int port, int backlog, InetAddress iAddress,
227     * SSLParameters sslParameters) method testing.
228     */
229    public void testSSLServerSocketImpl4() throws Exception {
230        Client client = null;
231        SSLServerSocket ssocket = null;
232        try {
233            ssocket = new SSLServerSocketImpl(0, 1, null,
234                    JSSETestData.getSSLParameters());
235            ssocket.setUseClientMode(true);
236
237            final SSLServerSocket s = ssocket;
238            Thread thread = new Thread() {
239                @Override
240                public void run() {
241                    try {
242                        s.accept().close();
243                    } catch (Exception e) { }
244                }
245            };
246
247            thread.start();
248
249            client = new Client(ssocket.getLocalPort());
250            client.start();
251
252            int timeout = 10; // wait no more than 5 seconds for handshake
253            while (!client.handshakeStarted()) {
254                // wait for handshake start
255                try {
256                    Thread.sleep(500);
257                } catch (Exception e) { }
258                timeout--;
259                if (timeout < 0) {
260                    try {
261                        client.close();
262                    } catch (IOException ex) { }
263                    try {
264                        ssocket.close();
265                    } catch (IOException ex) { }
266                    fail("Handshake was not started");
267                }
268            }
269        } finally {
270            if (client != null) {
271                try {
272                    client.close();
273                } catch (IOException ex) { }
274            }
275            if (ssocket != null) {
276                try {
277                    ssocket.close();
278                } catch (IOException ex) { }
279            }
280        }
281    }
282
283    /**
284     * getSupportedCipherSuites() method testing.
285     */
286    public void testGetSupportedCipherSuites() throws Exception {
287        SSLServerSocket ssocket = createSSLServerSocket();
288        String[] supported = ssocket.getSupportedCipherSuites();
289        assertNotNull(supported);
290        supported[0] = "NOT_SUPPORTED_CIPHER_SUITE";
291        supported = ssocket.getEnabledCipherSuites();
292        for (int i=0; i<supported.length; i++) {
293            if ("NOT_SUPPORTED_CIPHER_SUITE".equals(supported[i])) {
294                fail("Modification of the returned result "
295                        + "causes the modification of the internal state");
296            }
297        }
298    }
299
300    /**
301     * getEnabledCipherSuites() method testing.
302     */
303    public void testGetEnabledCipherSuites() throws Exception {
304        SSLServerSocket ssocket = createSSLServerSocket();
305        String[] enabled = ssocket.getEnabledCipherSuites();
306        assertNotNull(enabled);
307        String[] supported = ssocket.getSupportedCipherSuites();
308        for (int i=0; i<enabled.length; i++) {
309            //System.out.println("Checking of "+enabled[i]);
310            found: {
311                for (int j=0; j<supported.length; j++) {
312                    if (enabled[i].equals(supported[j])) {
313                        break found;
314                    }
315                }
316                fail("Enabled suite does not belong to the set "
317                        + "of supported cipher suites: " + enabled[i]);
318            }
319        }
320        ssocket.setEnabledCipherSuites(supported);
321        for (int i=0; i<supported.length; i++) {
322            enabled = new String[supported.length - i];
323            System.arraycopy(supported, 0,
324                    enabled, 0, supported.length-i);
325            ssocket.setEnabledCipherSuites(enabled);
326            String[] result = ssocket.getEnabledCipherSuites();
327            if (result.length != enabled.length) {
328                fail("Returned result does not correspond to expected.");
329            }
330            for (int k=0; k<result.length; k++) {
331                found: {
332                    for (int n=0; n<enabled.length; n++) {
333                        if (result[k].equals(enabled[n])) {
334                            break found;
335                        }
336                    }
337                    if (result.length != enabled.length) {
338                        fail("Returned result does not correspond "
339                                + "to expected.");
340                    }
341                }
342            }
343        }
344    }
345
346    /**
347     * setEnabledCipherSuites(String[] suites) method testing.
348     */
349    public void testSetEnabledCipherSuites() throws Exception {
350        SSLServerSocket ssocket = createSSLServerSocket();
351        String[] enabled = ssocket.getEnabledCipherSuites();
352        assertNotNull(enabled);
353        String[] supported = ssocket.getSupportedCipherSuites();
354        for (int i=0; i<enabled.length; i++) {
355            //System.out.println("Checking of "+enabled[i]);
356            found: {
357                for (int j=0; j<supported.length; j++) {
358                    if (enabled[i].equals(supported[j])) {
359                        break found;
360                    }
361                }
362                fail("Enabled suite does not belong to the set "
363                        + "of supported cipher suites: " + enabled[i]);
364            }
365        }
366        ssocket.setEnabledCipherSuites(supported);
367        ssocket.setEnabledCipherSuites(enabled);
368        ssocket.setEnabledCipherSuites(supported);
369        String[] more_than_supported = new String[supported.length+1];
370        for (int i=0; i<supported.length+1; i++) {
371            more_than_supported[i]
372                = "NOT_SUPPORTED_CIPHER_SUITE";
373            System.arraycopy(supported, 0,
374                    more_than_supported, 0, i);
375            System.arraycopy(supported, i,
376                    more_than_supported, i+1, supported.length-i);
377            try {
378                ssocket.setEnabledCipherSuites(more_than_supported);
379                fail("Expected IllegalArgumentException was not thrown");
380            } catch (IllegalArgumentException e) { }
381        }
382        enabled = ssocket.getEnabledCipherSuites();
383        enabled[0] = "NOT_SUPPORTED_CIPHER_SUITE";
384        enabled = ssocket.getEnabledCipherSuites();
385        for (int i=0; i<enabled.length; i++) {
386            if ("NOT_SUPPORTED_CIPHER_SUITE".equals(enabled[i])) {
387                fail("Modification of the returned result "
388                        + "causes the modification of the internal state");
389            }
390        }
391    }
392
393    /**
394     * getSupportedProtocols() method testing.
395     */
396    public void testGetSupportedProtocols() throws Exception {
397        SSLServerSocket ssocket = createSSLServerSocket();
398        String[] supported = ssocket.getSupportedProtocols();
399        assertNotNull(supported);
400        assertFalse(supported.length == 0);
401        supported[0] = "NOT_SUPPORTED_PROTOCOL";
402        supported = ssocket.getSupportedProtocols();
403        for (int i=0; i<supported.length; i++) {
404            if ("NOT_SUPPORTED_PROTOCOL".equals(supported[i])) {
405                fail("Modification of the returned result "
406                        + "causes the modification of the internal state");
407            }
408        }
409    }
410
411    /**
412     * getEnabledProtocols() method testing.
413     */
414    public void testGetEnabledProtocols() throws Exception {
415        SSLServerSocket ssocket = createSSLServerSocket();
416        String[] enabled = ssocket.getEnabledProtocols();
417        assertNotNull(enabled);
418        String[] supported = ssocket.getSupportedProtocols();
419        for (int i=0; i<enabled.length; i++) {
420            //System.out.println("Checking of "+enabled[i]);
421            found: {
422                for (int j=0; j<supported.length; j++) {
423                    if (enabled[i].equals(supported[j])) {
424                        break found;
425                    }
426                }
427                fail("Enabled protocol does not belong to the set "
428                        + "of supported protocols: " + enabled[i]);
429            }
430        }
431        ssocket.setEnabledProtocols(supported);
432        for (int i=0; i<supported.length; i++) {
433            enabled = new String[supported.length - i];
434            System.arraycopy(supported, i,
435                    enabled, 0, supported.length-i);
436            //System.out.println("");
437            //for (int k=0; k<supported.length - i; k++) {
438            //    System.out.println("---- "+enabled[k]);
439            //}
440            ssocket.setEnabledProtocols(enabled);
441            String[] result = ssocket.getEnabledProtocols();
442            if (result.length != enabled.length) {
443                fail("Returned result does not correspond to expected.");
444            }
445            for (int k=0; k<result.length; k++) {
446                found: {
447                    for (int n=0; n<enabled.length; n++) {
448                        if (result[k].equals(enabled[n])) {
449                            break found;
450                        }
451                    }
452                    if (result.length != enabled.length) {
453                        fail("Returned result does not correspond "
454                                + "to expected.");
455                    }
456                }
457            }
458        }
459    }
460
461    /**
462     * setEnabledProtocols(String[] protocols) method testing.
463     */
464    public void testSetEnabledProtocols() throws Exception {
465        SSLServerSocket ssocket = createSSLServerSocket();
466        String[] enabled = ssocket.getEnabledProtocols();
467        assertNotNull(enabled);
468        String[] supported = ssocket.getSupportedProtocols();
469        for (int i=0; i<enabled.length; i++) {
470            //System.out.println("Checking of "+enabled[i]);
471            found: {
472                for (int j=0; j<supported.length; j++) {
473                    if (enabled[i].equals(supported[j])) {
474                        break found;
475                    }
476                }
477                fail("Enabled suite does not belong to the set "
478                        + "of supported cipher suites: " + enabled[i]);
479            }
480        }
481        ssocket.setEnabledProtocols(supported);
482        ssocket.setEnabledProtocols(enabled);
483        ssocket.setEnabledProtocols(supported);
484        String[] more_than_supported = new String[supported.length+1];
485        for (int i=0; i<supported.length+1; i++) {
486            more_than_supported[i]
487                = "NOT_SUPPORTED_PROTOCOL";
488            System.arraycopy(supported, 0,
489                    more_than_supported, 0, i);
490            System.arraycopy(supported, i,
491                    more_than_supported, i+1, supported.length-i);
492            try {
493                ssocket.setEnabledProtocols(more_than_supported);
494                fail("Expected IllegalArgumentException was not thrown");
495            } catch (IllegalArgumentException e) { }
496        }
497        enabled = ssocket.getEnabledProtocols();
498        enabled[0] = "NOT_SUPPORTED_PROTOCOL";
499        enabled = ssocket.getEnabledProtocols();
500        for (int i=0; i<enabled.length; i++) {
501            if ("NOT_SUPPORTED_PROTOCOL".equals(enabled[i])) {
502                fail("Modification of the returned result "
503                        + "causes the modification of the internal state");
504            }
505        }
506    }
507
508    /**
509     * setUseClientMode(boolean mode) method testing.
510     * getUseClientMode() method testing.
511     */
512    public void testSetGetUseClientMode() throws Exception {
513        SSLServerSocket ssocket = createSSLServerSocket();
514
515        ssocket.setUseClientMode(false);
516        assertFalse("Result does not correspond to expected",
517                ssocket.getUseClientMode());
518        ssocket.setUseClientMode(true);
519        assertTrue("Result does not correspond to expected",
520                ssocket.getUseClientMode());
521    }
522
523    /**
524     * setNeedClientAuth(boolean need) method testing.
525     * getNeedClientAuth() method testing.
526     */
527    public void testSetGetNeedClientAuth() throws Exception {
528        SSLServerSocket ssocket = createSSLServerSocket();
529
530        ssocket.setWantClientAuth(true);
531        ssocket.setNeedClientAuth(false);
532        assertFalse("Result does not correspond to expected",
533                ssocket.getNeedClientAuth());
534        assertFalse("Socket did not reset its want client auth state",
535                ssocket.getWantClientAuth());
536        ssocket.setWantClientAuth(true);
537        ssocket.setNeedClientAuth(true);
538        assertTrue("Result does not correspond to expected",
539                ssocket.getNeedClientAuth());
540        assertFalse("Socket did not reset its want client auth state",
541                ssocket.getWantClientAuth());
542    }
543
544    /**
545     * setWantClientAuth(boolean want) method testing.
546     * getWantClientAuth() method testing.
547     */
548    public void testSetGetWantClientAuth() throws Exception {
549        SSLServerSocket ssocket = createSSLServerSocket();
550
551        ssocket.setNeedClientAuth(true);
552        ssocket.setWantClientAuth(false);
553        assertFalse("Result does not correspond to expected",
554                ssocket.getWantClientAuth());
555        assertFalse("Socket did not reset its want client auth state",
556                ssocket.getNeedClientAuth());
557        ssocket.setNeedClientAuth(true);
558        ssocket.setWantClientAuth(true);
559        assertTrue("Result does not correspond to expected",
560                ssocket.getWantClientAuth());
561        assertFalse("Socket did not reset its want client auth state",
562                ssocket.getNeedClientAuth());
563    }
564
565    /**
566     * setEnableSessionCreation(boolean flag) method testing.
567     * getEnableSessionCreation() method testing.
568     */
569    public void testSetGetEnableSessionCreation() throws Exception {
570        SSLServerSocket ssocket = createSSLServerSocket();
571
572        ssocket.setEnableSessionCreation(false);
573        assertFalse("Result does not correspond to expected",
574                ssocket.getEnableSessionCreation());
575        ssocket.setEnableSessionCreation(true);
576        assertTrue("Result does not correspond to expected",
577                ssocket.getEnableSessionCreation());
578    }
579
580    /**
581     * toString() method testing.
582     */
583    public void testToString() throws Exception {
584        SSLServerSocket ssocket = createSSLServerSocket();
585        assertNotNull("String representation is null", ssocket.toString());
586    }
587
588    private static class Client extends Thread {
589
590        private boolean closed;
591        private boolean handshake_started = false;
592        private Socket client = null;
593        private int port;
594
595        public Client(int port) throws IOException {
596            super();
597            this.port = port;
598            client = new Socket();
599            client.setSoTimeout(10000);
600        }
601
602        public int getPort() {
603            return client.getLocalPort();
604        }
605
606        @Override
607        public void run() {
608            while (!closed) {
609                try {
610                    if (doLog) {
611                        System.out.print(".");
612                    }
613                    if (!handshake_started) {
614                        client.connect(
615                                new InetSocketAddress("localhost", port));
616                        client.getInputStream().read();
617                        handshake_started = true;
618                    }
619                    Thread.sleep(1000);
620                } catch (Exception e) {
621                    e.printStackTrace();
622                }
623            }
624            if (client != null) {
625                try {
626                    client.close();
627                } catch (IOException e) { }
628            }
629            //System.out.println("===== client has been stopped");
630        }
631
632        public boolean handshakeStarted() {
633            return handshake_started;
634        }
635
636        public void close() throws IOException {
637            closed = true;
638            client.close();
639        }
640
641    };
642
643    public static Test suite() {
644        return new TestSuite(SSLServerSocketImplTest.class);
645    }
646
647    public static void main(String[] args) {
648        junit.textui.TestRunner.run(suite());
649    }
650}
651
652