diff options
Diffstat (limited to 'harmony-tests/src/test/java/org/apache/harmony/tests/javax/net/ssl/SSLEngineTest.java')
| -rw-r--r-- | harmony-tests/src/test/java/org/apache/harmony/tests/javax/net/ssl/SSLEngineTest.java | 1210 |
1 files changed, 1210 insertions, 0 deletions
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/net/ssl/SSLEngineTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/net/ssl/SSLEngineTest.java new file mode 100644 index 0000000..31f5881 --- /dev/null +++ b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/net/ssl/SSLEngineTest.java @@ -0,0 +1,1210 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package tests.api.javax.net.ssl; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.ReadOnlyBufferException; +import java.nio.channels.Pipe; +import java.nio.channels.Pipe.SinkChannel; +import java.nio.channels.Pipe.SourceChannel; +import java.security.KeyManagementException; +import java.security.NoSuchAlgorithmException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; +import javax.net.ssl.SSLContext; +import javax.net.ssl.SSLEngine; +import javax.net.ssl.SSLEngineResult; +import javax.net.ssl.SSLEngineResult.Status; +import javax.net.ssl.SSLException; +import javax.net.ssl.SSLEngineResult.HandshakeStatus; +import junit.framework.TestCase; +import libcore.java.security.StandardNames; + +/** + * Tests for SSLEngine class + * + */ +public class SSLEngineTest extends TestCase { + private static final int MAX_TLS_RECORD_SIZE = 32768; + + private HandshakeHandler clientEngine; + private HandshakeHandler serverEngine; + + @Override protected void setUp() throws Exception { + super.setUp(); + } + + /** + * Test for <code>SSLEngine()</code> constructor Assertion: creates + * SSLEngine object with null host and -1 port + */ + public void test_Constructor() throws Exception { + SSLEngine e = getEngine(); + assertNull(e.getPeerHost()); + assertEquals(-1, e.getPeerPort()); + String[] suites = e.getSupportedCipherSuites(); + e.setEnabledCipherSuites(suites); + assertEquals(e.getEnabledCipherSuites().length, suites.length); + } + + /** + * Test for <code>SSLEngine(String host, int port)</code> constructor + */ + public void test_ConstructorLjava_lang_StringI01() throws Exception { + int port = 1010; + SSLEngine e = getEngine(null, port); + assertNull(e.getPeerHost()); + assertEquals(e.getPeerPort(), port); + try { + e.beginHandshake(); + fail("should throw IllegalStateException"); + } catch (IllegalStateException expected) { + } + + e = getEngine(null, port); + e.setUseClientMode(true); + e.beginHandshake(); + + e = getEngine(null, port); + e.setUseClientMode(false); + e.beginHandshake(); + } + + /** + * Test for <code>SSLEngine(String host, int port)</code> constructor + */ + public void test_ConstructorLjava_lang_StringI02() throws Exception { + String host = "new host"; + int port = 8080; + SSLEngine e = getEngine(host, port); + assertEquals(e.getPeerHost(), host); + assertEquals(e.getPeerPort(), port); + String[] suites = e.getSupportedCipherSuites(); + e.setEnabledCipherSuites(suites); + assertEquals(e.getEnabledCipherSuites().length, suites.length); + e.setUseClientMode(true); + assertTrue(e.getUseClientMode()); + } + + /** + * Test for <code>getPeerHost()</code> method + */ + public void test_getPeerHost() throws Exception { + SSLEngine e = getEngine(); + assertNull(e.getPeerHost()); + e = getEngine("www.fortify.net", 80); + assertEquals("Incorrect host name", "www.fortify.net", e.getPeerHost()); + } + + /** + * Test for <code>getPeerPort()</code> method + */ + public void test_getPeerPort() throws Exception { + SSLEngine e = getEngine(); + assertEquals("Incorrect default value of peer port", + -1 ,e.getPeerPort()); + e = getEngine("www.fortify.net", 80); + assertEquals("Incorrect peer port", 80, e.getPeerPort()); + } + + public void test_getSupportedProtocols() throws Exception { + SSLEngine sse = getEngine(); + + String[] res = sse.getSupportedProtocols(); + assertNotNull(res); + assertTrue(res.length > 0); + } + + /** + * javax.net.ssl.SSLEngine#setEnabledProtocols(String[] protocols) + * javax.net.ssl.SSLEngine#getEnabledProtocols() + */ + public void test_EnabledProtocols() throws Exception { + SSLEngine sse = getEngine(); + String[] pr = sse.getSupportedProtocols(); + + sse.setEnabledProtocols(pr); + String[] res = sse.getEnabledProtocols(); + assertNotNull("Null array was returned", res); + assertEquals("Incorrect array length", res.length, pr.length); + assertTrue("Incorrect array was returned", Arrays.equals(res, pr)); + + try { + sse.setEnabledProtocols(null); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#getSupportedCipherSuites() + */ + public void test_getSupportedCipherSuites() throws Exception { + SSLEngine sse = getEngine(); + + String[] res = sse.getSupportedCipherSuites(); + assertNotNull(res); + assertTrue(res.length > 0); + } + + /** + * javax.net.ssl.SSLEngine#setEnabledCipherSuites(String[] suites) + * javax.net.ssl.SSLEngine#getEnabledCipherSuites() + */ + public void test_EnabledCipherSuites() throws Exception { + SSLEngine sse = getEngine(); + String[] st = sse.getSupportedCipherSuites(); + + sse.setEnabledCipherSuites(st); + String[] res = sse.getEnabledCipherSuites(); + assertNotNull("Null array was returned", res); + assertEquals("Incorrect array length", res.length, st.length); + assertTrue("Incorrect array was returned", Arrays.equals(res, st)); + + try { + sse.setEnabledCipherSuites(null); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#setEnableSessionCreation(boolean flag) + * javax.net.ssl.SSLEngine#getEnableSessionCreation() + */ + public void test_EnableSessionCreation() throws Exception { + SSLEngine sse = getEngine(); + try { + assertTrue(sse.getEnableSessionCreation()); + sse.setEnableSessionCreation(false); + assertFalse(sse.getEnableSessionCreation()); + sse.setEnableSessionCreation(true); + assertTrue(sse.getEnableSessionCreation()); + } catch (Exception ex) { + fail("Unexpected exception " + ex); + } + } + + /** + * javax.net.ssl.SSLEngine#setNeedClientAuth(boolean need) + * javax.net.ssl.SSLEngine#getNeedClientAuth() + */ + public void test_NeedClientAuth() throws Exception { + SSLEngine sse = getEngine(); + try { + sse.setNeedClientAuth(false); + assertFalse(sse.getNeedClientAuth()); + sse.setNeedClientAuth(true); + assertTrue(sse.getNeedClientAuth()); + } catch (Exception ex) { + fail("Unexpected exception " + ex); + } + } + + /** + * javax.net.ssl.SSLEngine#setWantClientAuth(boolean want) + * javax.net.ssl.SSLEngine#getWantClientAuth() + */ + public void test_WantClientAuth() throws Exception { + SSLEngine sse = getEngine(); + sse.setWantClientAuth(false); + assertFalse(sse.getWantClientAuth()); + sse.setWantClientAuth(true); + assertTrue(sse.getWantClientAuth()); + } + + /** + * javax.net.ssl.SSLEngine#beginHandshake() + */ + public void test_beginHandshake() throws Exception { + SSLEngine sse = getEngine(); + try { + sse.beginHandshake(); + fail("IllegalStateException wasn't thrown"); + } catch (IllegalStateException expected) { + } + sse = getEngine("new host", 1080); + try { + sse.beginHandshake(); + fail("IllegalStateException wasn't thrown"); + } catch (IllegalStateException expected) { + } + sse = getEngine(); + sse.setUseClientMode(true); + sse.beginHandshake(); + } + + /** + * javax.net.ssl.SSLEngine#setUseClientMode(boolean mode) + * javax.net.ssl.SSLEngine#getUseClientMode() + */ + public void test_UseClientMode() throws Exception { + SSLEngine sse = getEngine(); + sse.setUseClientMode(false); + assertFalse(sse.getUseClientMode()); + sse.setUseClientMode(true); + assertTrue(sse.getUseClientMode()); + + sse = getEngine(null, 1080); + sse.setUseClientMode(true); + sse.beginHandshake(); + try { + sse.setUseClientMode(false); + fail("IllegalArgumentException was not thrown"); + } catch (IllegalArgumentException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#getSession() + */ + public void test_getSession() throws Exception { + SSLEngine sse = getEngine(); + assertNotNull(sse.getSession()); + } + + /** + * javax.net.ssl.SSLEngine#getHandshakeStatus() + */ + public void test_getHandshakeStatus() throws Exception { + SSLEngine sse = getEngine(); + assertEquals(sse.getHandshakeStatus().toString(), "NOT_HANDSHAKING"); + sse.setUseClientMode(true); + sse.beginHandshake(); + assertEquals(sse.getHandshakeStatus().toString(), "NEED_WRAP"); + } + + /** + * javax.net.ssl.SSLEngine#getDelegatedTask() + */ + public void test_getDelegatedTask() throws Exception { + SSLEngine sse = getEngine(); + assertNull(sse.getDelegatedTask()); + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts, + * int offset, int length) + * Exception case: SSLException should be thrown. + */ + public void test_unwrap_01() throws Exception { + prepareEngines(); + doHandshake(); + + ByteBuffer bbs = ByteBuffer.wrap(new byte[] {1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,31,2,3,1,2,3,1,2,3,1,2,3}); + ByteBuffer bbd = ByteBuffer.allocate(100); + try { + clientEngine.engine.unwrap(bbs, new ByteBuffer[] { bbd }, 0, 1); + fail("SSLException wasn't thrown"); + } catch (SSLException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts, + * int offset, int length) + * Exception case: IndexOutOfBoundsException should be thrown. + */ + public void test_unwrap_02() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer[] bbA = { ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; + + ByteBuffer bb = ByteBuffer.allocate(10); + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + try { + sse.unwrap(bb, bbA, -1, 3); + fail("IndexOutOfBoundsException wasn't thrown"); + } catch (IndexOutOfBoundsException expected) { + } + try { + sse.unwrap(bb, bbA, 0, -3); + fail("IndexOutOfBoundsException wasn't thrown"); + } catch (IndexOutOfBoundsException expected) { + } + try { + sse.unwrap(bb, bbA, bbA.length + 1, bbA.length); + fail("IndexOutOfBoundsException wasn't thrown"); + } catch (IndexOutOfBoundsException expected) { + } + try { + sse.unwrap(bb, bbA, 0, bbA.length + 1); + fail("IndexOutOfBoundsException wasn't thrown"); + } catch (IndexOutOfBoundsException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts, + * int offset, int length) + * Exception case: ReadOnlyBufferException should be thrown. + */ + public void test_unwrap_03() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bbR = ByteBuffer.allocate(100).asReadOnlyBuffer(); + ByteBuffer[] bbA = { bbR, ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; + + ByteBuffer bb = ByteBuffer.allocate(10); + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + try { + sse.unwrap(bb, bbA, 0, bbA.length); + fail("ReadOnlyBufferException wasn't thrown"); + } catch (ReadOnlyBufferException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts, + * int offset, int length) + * Exception case: IllegalArgumentException should be thrown. + */ + public void test_unwrap_04() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer[] bbA = {ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100)}; + ByteBuffer[] bbAN = {ByteBuffer.allocate(100), null, ByteBuffer.allocate(100)}; + ByteBuffer[] bbN = null; + ByteBuffer bb = ByteBuffer.allocate(10); + ByteBuffer bN = null; + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + try { + sse.unwrap(bN, bbA, 0, 3); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + try { + sse.unwrap(bb, bbAN, 0, 3); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + try { + sse.unwrap(bb, bbN, 0, 0); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + try { + sse.unwrap(bN, bbN, 0, 0); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts, + * int offset, int length) + * Exception case: IllegalStateException should be thrown. + */ + public void test_unwrap_05() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer[] bbA = { ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; + + ByteBuffer bb = ByteBuffer.allocate(10); + SSLEngine sse = getEngine(host, port); + + try { + SSLEngineResult result = sse.unwrap(bb, bbA, 0, bbA.length); + fail("IllegalStateException wasn't thrown"); + } catch (IllegalStateException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts, + * int offset, int length) + */ + public void test_unwrap_06() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer[] bbA = { ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; + + ByteBuffer bb = ByteBuffer.allocate(10); + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + SSLEngineResult res = sse.unwrap(bb, bbA, 0, bbA.length); + assertEquals(0, res.bytesConsumed()); + assertEquals(0, res.bytesProduced()); + } + + public void test_wrap_01() throws Exception { + prepareEngines(); + doHandshake(); + ByteBuffer bbs = ByteBuffer.allocate(100); + ByteBuffer bbd = ByteBuffer.allocate(MAX_TLS_RECORD_SIZE); + clientEngine.engine.wrap(new ByteBuffer[] { bbs }, 0, 1, bbd); + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, int offset, + * int length, ByteBuffer dst) + * Exception case: IndexOutOfBoundsException should be thrown. + */ + public void test_wrap_02() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bb = ByteBuffer.allocate(10); + ByteBuffer[] bbA = {ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5)}; + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + try { + sse.wrap(bbA, -1, 3, bb); + fail("IndexOutOfBoundsException wasn't thrown"); + } catch (IndexOutOfBoundsException expected) { + } + try { + sse.wrap(bbA, 0, -3, bb); + fail("IndexOutOfBoundsException wasn't thrown"); + } catch (IndexOutOfBoundsException expected) { + } + try { + sse.wrap(bbA, bbA.length + 1, bbA.length, bb); + fail("IndexOutOfBoundsException wasn't thrown"); + } catch (IndexOutOfBoundsException expected) { + } + try { + sse.wrap(bbA, 0, bbA.length + 1, bb); + fail("IndexOutOfBoundsException wasn't thrown"); + } catch (IndexOutOfBoundsException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, int offset, + * int length, ByteBuffer dst) + * Exception case: ReadOnlyBufferException should be thrown. + */ + public void test_wrap_03() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bb = ByteBuffer.allocate(MAX_TLS_RECORD_SIZE).asReadOnlyBuffer(); + ByteBuffer[] bbA = {ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5)}; + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + try { + sse.wrap(bbA, 0, bbA.length, bb); + fail("ReadOnlyBufferException wasn't thrown"); + } catch (ReadOnlyBufferException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, int offset, + * int length, ByteBuffer dst) + * Exception case: IllegalArgumentException should be thrown. + */ + public void test_wrap_04() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer[] bbA = {ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100)}; + ByteBuffer[] bbN = null; + ByteBuffer bN = null; + SSLEngine e = getEngine(host, port); + e.setUseClientMode(true); + + try { + e.wrap(bbA, 0, 3, bN); + fail("IllegalArgumentException must be thrown for null srcs byte buffer array"); + } catch (IllegalArgumentException ex) { + } + + try { + e.wrap(bbN, 0, 0, bN); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException ex) { + } + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, int offset, + * int length, ByteBuffer dst) + * Exception case: IllegalStateException should be thrown. + */ + public void test_wrap_05() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bb = ByteBuffer.allocate(MAX_TLS_RECORD_SIZE); + ByteBuffer[] bbA = {ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5)}; + SSLEngine sse = getEngine(host, port); + + try { + SSLEngineResult result = sse.wrap(bbA, 0, bbA.length, bb); + fail("Should fail since mode not set yet"); + } catch (IllegalStateException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, int offset, + * int length, ByteBuffer dst) + */ + public void test_wrap_06() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bb = ByteBuffer.allocate(MAX_TLS_RECORD_SIZE); + ByteBuffer[] bbA = {ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5)}; + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + SSLEngineResult result = sse.wrap(bbA, 0, bbA.length, bb); + assertEquals(SSLEngineResult.Status.OK, result.getStatus()); + assertEquals(0, result.bytesConsumed()); + assertTrue(result.bytesProduced() > 0); + } + + /** + * javax.net.ssl.SSLEngine#closeOutbound() + * javax.net.ssl.SSLEngine#isOutboundDone() + */ + public void test_closeOutbound() throws Exception { + SSLEngine sse = getEngine(); + + assertFalse(sse.isOutboundDone()); + sse.closeOutbound(); + assertTrue(sse.isOutboundDone()); + } + + /** + * javax.net.ssl.SSLEngine#closeInbound() + * javax.net.ssl.SSLEngine#isInboundDone() + */ + public void test_closeInbound() throws Exception { + SSLEngine sse = getEngine(); + + assertFalse(sse.isInboundDone()); + sse.closeInbound(); + assertTrue(sse.isInboundDone()); + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer dst) + * SSLException should be thrown. + */ + public void test_unwrap_ByteBuffer_ByteBuffer_01() throws Exception { + prepareEngines(); + doHandshake(); + ByteBuffer bbs = ByteBuffer.allocate(100); + ByteBuffer bbd = ByteBuffer.allocate(100); + + try { + SSLEngineResult unwrap = clientEngine.engine.unwrap(bbs, bbd); + fail("SSLException wasn't thrown"); + } catch (SSLException ex) { + //expected + } + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer dst) + * ReadOnlyBufferException should be thrown. + */ + public void test_unwrap_ByteBuffer_ByteBuffer_02() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bbs = ByteBuffer.allocate(10); + ByteBuffer bbd = ByteBuffer.allocate(100).asReadOnlyBuffer(); + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + try { + sse.unwrap(bbs, bbd); + fail("ReadOnlyBufferException wasn't thrown"); + } catch (ReadOnlyBufferException iobe) { + //expected + } catch (Exception e) { + fail(e + " was thrown instead of ReadOnlyBufferException"); + } + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer dst) + * IllegalArgumentException should be thrown. + */ + public void test_unwrap_ByteBuffer_ByteBuffer_03() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bbsN = null; + ByteBuffer bbdN = null; + ByteBuffer bbs = ByteBuffer.allocate(10); + ByteBuffer bbd = ByteBuffer.allocate(100); + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + try { + sse.unwrap(bbsN, bbd); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + + try { + sse.unwrap(bbs, bbdN); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + + try { + sse.unwrap(bbsN, bbdN); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer dst) + * IllegalStateException should be thrown. + */ + public void test_unwrap_ByteBuffer_ByteBuffer_04() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bbs = ByteBuffer.allocate(10); + ByteBuffer bbd = ByteBuffer.allocate(100); + SSLEngine sse = getEngine(host, port); + + try { + sse.unwrap(bbs, bbd); + fail("IllegalStateException wasn't thrown"); + } catch (IllegalStateException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer dst) + */ + public void test_unwrap_ByteBuffer_ByteBuffer_05() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bbs = ByteBuffer.allocate(10); + ByteBuffer bbd = ByteBuffer.allocate(100); + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + SSLEngineResult res = sse.unwrap(bbs, bbd); + assertEquals(0, res.bytesConsumed()); + assertEquals(0, res.bytesProduced()); + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts) + * SSLException should be thrown. + */ + public void test_unwrap_ByteBuffer$ByteBuffer_01() throws Exception { + prepareEngines(); + doHandshake(); + + ByteBuffer bbs = ByteBuffer.allocate(100); + ByteBuffer bbd = ByteBuffer.allocate(100); + + try { + clientEngine.engine.unwrap(bbs, new ByteBuffer[] { bbd }); + fail("SSLException wasn't thrown"); + } catch (SSLException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts) + * ReadOnlyBufferException should be thrown. + */ + public void test_unwrap_ByteBuffer$ByteBuffer_02() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bbs = ByteBuffer.allocate(10); + ByteBuffer bbR = ByteBuffer.allocate(100).asReadOnlyBuffer(); + ByteBuffer[] bbA = { bbR, ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + try { + sse.unwrap(bbs, bbA); + fail("ReadOnlyBufferException wasn't thrown"); + } catch (ReadOnlyBufferException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts) + * IllegalArgumentException should be thrown. + */ + public void test_unwrap_ByteBuffer$ByteBuffer_03() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer[] bbA = { ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; + ByteBuffer[] bbN = { ByteBuffer.allocate(100), null, ByteBuffer.allocate(100) }; + ByteBuffer[] bbAN = null; + ByteBuffer bb = ByteBuffer.allocate(10); + ByteBuffer bN = null; + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + try { + sse.unwrap(bN, bbA); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + + try { + sse.unwrap(bb, bbAN); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + + try { + sse.unwrap(bb, bbN); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + + try { + sse.unwrap(bN, bbAN); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts) + * IllegalStateException should be thrown. + */ + public void test_unwrap_ByteBuffer$ByteBuffer_04() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bbs = ByteBuffer.allocate(10); + ByteBuffer[] bbd = {ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; + SSLEngine sse = getEngine(host, port); + + try { + sse.unwrap(bbs, bbd); + fail("IllegalStateException wasn't thrown"); + } catch (IllegalStateException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts) + */ + public void test_unwrap_ByteBuffer$ByteBuffer_05() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bbs = ByteBuffer.allocate(10); + ByteBuffer[] bbd = {ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + SSLEngineResult res = sse.unwrap(bbs, bbd); + assertEquals(0, res.bytesConsumed()); + assertEquals(0, res.bytesProduced()); + } + + public void test_wrap_ByteBuffer_ByteBuffer_01() throws Exception { + prepareEngines(); + doHandshake(); + ByteBuffer bbs = ByteBuffer.allocate(20); + ByteBuffer bbd = ByteBuffer.allocate(20000); + clientEngine.engine.wrap(bbs, bbd); + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer src, ByteBuffer dst) + * ReadOnlyBufferException should be thrown. + */ + public void test_wrap_ByteBuffer_ByteBuffer_02() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bbs = ByteBuffer.allocate(10); + ByteBuffer bbd = ByteBuffer.allocate(100).asReadOnlyBuffer(); + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + try { + sse.wrap(bbs, bbd); + fail("ReadOnlyBufferException wasn't thrown"); + } catch (ReadOnlyBufferException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer src, ByteBuffer dst) + * IllegalArgumentException should be thrown. + */ + public void test_wrap_ByteBuffer_ByteBuffer_03() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bbsN = null; + ByteBuffer bbdN = null; + ByteBuffer bbs = ByteBuffer.allocate(10); + ByteBuffer bbd = ByteBuffer.allocate(100); + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + try { + sse.wrap(bbsN, bbd); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + + try { + sse.wrap(bbs, bbdN); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + + try { + sse.wrap(bbsN, bbdN); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer src, ByteBuffer dst) + * IllegalStateException should be thrown. + */ + public void test_wrap_ByteBuffer_ByteBuffer_04() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bbs = ByteBuffer.allocate(10); + ByteBuffer bbd = ByteBuffer.allocate(10); + SSLEngine sse = getEngine(host, port); + + try { + SSLEngineResult result = sse.wrap(bbs, bbd); + } catch (IllegalStateException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer src, ByteBuffer dst) + */ + public void test_wrap_ByteBuffer_ByteBuffer_05() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bb = ByteBuffer.allocate(10); + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + SSLEngineResult res = sse.wrap(bb, ByteBuffer.allocate(10)); + assertEquals(Status.BUFFER_OVERFLOW, res.getStatus()); + assertEquals(0, res.bytesConsumed()); + assertEquals(0, res.bytesProduced()); + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, ByteBuffer dst) + * SSLException should be thrown. + */ + public void test_wrap_ByteBuffer$ByteBuffer_01() throws Exception { + prepareEngines(); + doHandshake(); + ByteBuffer bbs = ByteBuffer.allocate(100); + ByteBuffer bbd = ByteBuffer.allocate(20000); + + clientEngine.engine.wrap(new ByteBuffer[] { bbs }, bbd); + serverEngine.engine.wrap(new ByteBuffer[] { bbs }, bbd); + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, ByteBuffer dst) + * ReadOnlyBufferException should be thrown. + */ + public void test_wrap_ByteBuffer$ByteBuffer_02() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bb = ByteBuffer.allocate(10).asReadOnlyBuffer(); + ByteBuffer[] bbA = {ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5)}; + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + try { + sse.wrap(bbA, bb); + fail("ReadOnlyBufferException wasn't thrown"); + } catch (ReadOnlyBufferException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, ByteBuffer dst) + * IllegalArgumentException should be thrown. + */ + public void test_wrap_ByteBuffer$ByteBuffer_03() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer[] bbA = {ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100)}; + ByteBuffer[] bbAN = null; + ByteBuffer bb = ByteBuffer.allocate(10); + ByteBuffer bN = null; + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + try { + sse.wrap(bbA, bN); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + + try { + sse.wrap(bbAN, bb); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + + try { + sse.wrap(bbAN, bN); + fail("IllegalArgumentException wasn't thrown"); + } catch (IllegalArgumentException expected) { + } + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, ByteBuffer dst) + * IllegalStateException should be thrown. + */ + public void test_wrap_ByteBuffer$ByteBuffer_04() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bb = ByteBuffer.allocate(10); + ByteBuffer[] bbA = { ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5) }; + SSLEngine sse = getEngine(host, port); + + SSLEngineResult result = sse.wrap(bbA, bb); + assertEquals(Status.BUFFER_OVERFLOW, result.getStatus()); + } + + /** + * javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, ByteBuffer dst) + */ + public void test_wrap_ByteBuffer$ByteBuffer_05() throws Exception { + String host = "new host"; + int port = 8080; + ByteBuffer bb = ByteBuffer.allocate(2000); + ByteBuffer[] bbA = { ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5) }; + SSLEngine sse = getEngine(host, port); + sse.setUseClientMode(true); + + SSLEngineResult res = sse.wrap(bbA, bb); + assertEquals(0, res.bytesConsumed()); + assertEquals(0, res.bytesProduced()); + } + + private SSLEngine getEngine() throws Exception { + SSLContext context = SSLContext.getInstance("TLS"); + context.init(null, null, null); + return context.createSSLEngine(); + } + + private SSLEngine getEngine(String host, int port) throws Exception { + SSLContext context = SSLContext.getInstance("TLS"); + context.init(null, null, null); + return context.createSSLEngine(host, port); + } + + class HandshakeHandler implements Runnable { + + private final SSLEngine engine; + + private final SourceChannel in; + + private final SinkChannel out; + + private final ByteBuffer EMPTY = ByteBuffer.allocate(0); + + @SuppressWarnings("unused") + private final String LOGTAG; + + private SSLEngineResult.HandshakeStatus status; + + private ByteBuffer readBuffer; + + private ByteBuffer writeBuffer; + + HandshakeHandler(boolean clientMode, SourceChannel in, SinkChannel out) throws Exception { + this.in = in; + this.out = out; + engine = getEngine(); + engine.setUseClientMode(clientMode); + String[] cipherSuites = engine.getSupportedCipherSuites(); + Set<String> enabledSuites = new HashSet<String>(); + for (String cipherSuite : cipherSuites) { + if (cipherSuite.contains("anon")) { + enabledSuites.add(cipherSuite); + } + } + engine.setEnabledCipherSuites((String[]) enabledSuites.toArray( + new String[enabledSuites.size()])); + + engine.beginHandshake(); + status = engine.getHandshakeStatus(); + + if (clientMode) { + LOGTAG = "CLIENT: "; + } else { + LOGTAG = "SERVER: "; + } + + log("CipherSuites: " + Arrays.toString(engine.getEnabledCipherSuites())); + log(status); + + readBuffer = ByteBuffer.allocate(200000); + writeBuffer = ByteBuffer.allocate(20000); + } + + public SSLEngineResult.HandshakeStatus getStatus() { + return status; + } + + private void log(Object o) { + //System.out.print(LOGTAG); + //System.out.println(o); + } + + private ByteBuffer read() throws IOException { + if (readBuffer == null || readBuffer.remaining() == 0 || readBuffer.position() == 0) { + readBuffer.clear(); + int read = in.read(readBuffer); + log("read: " + read); + readBuffer.rewind(); + readBuffer.limit(read); + } + return readBuffer; + } + + public void run() { + try { + while (true) { + switch (status) { + case FINISHED: { + log(status); + return; + } + case NEED_TASK: { + log(status); + Runnable task; + while ((task = engine.getDelegatedTask()) != null) { + task.run(); + } + status = engine.getHandshakeStatus(); + break; + } + case NEED_UNWRAP: { + log(status); + ByteBuffer source = read(); + writeBuffer.clear(); + + while (status == HandshakeStatus.NEED_UNWRAP) { + SSLEngineResult result = engine.unwrap(source, writeBuffer); + status = result.getHandshakeStatus(); + log(result); + } + break; + } + case NEED_WRAP: { + log(status); + writeBuffer.clear(); + + int produced = 0; + SSLEngineResult result = null; + while (status == HandshakeStatus.NEED_WRAP) { + result = engine.wrap(EMPTY, writeBuffer); + status = result.getHandshakeStatus(); + produced += result.bytesProduced(); + log(result); + } + writeBuffer.rewind(); + writeBuffer.limit(produced); + log("write: " + produced); + out.write(writeBuffer); + break; + } + case NOT_HANDSHAKING: { + log("Not Handshaking"); + return; + } + } + } + } catch (IOException e) { + log(e); + } catch (RuntimeException e) { + // ignore; + } + } + } + + public void testHandshake() throws Exception { + + prepareEngines(); + + assertTrue("handshake failed", doHandshake()); + + System.out.println(clientEngine.engine.getSession().getCipherSuite()); + + assertEquals("Handshake not finished", + SSLEngineResult.HandshakeStatus.FINISHED, + clientEngine.getStatus()); + assertEquals("Handshake not finished", + SSLEngineResult.HandshakeStatus.FINISHED, + serverEngine.getStatus()); + } + + void prepareEngines() throws Exception { + Pipe clientSendPipe = Pipe.open(); + Pipe serverSendPipe = Pipe.open(); + + SinkChannel clientSink = clientSendPipe.sink(); + SourceChannel serverSource = clientSendPipe.source(); + SinkChannel serverSink = serverSendPipe.sink(); + SourceChannel clientSource = serverSendPipe.source(); + + clientEngine = new HandshakeHandler(true, clientSource, clientSink); + serverEngine = new HandshakeHandler(false, serverSource, serverSink); + } + + boolean doHandshake() throws InterruptedException { + Thread clientThread = new Thread(clientEngine); + clientThread.start(); + + Thread serverThread = new Thread(serverEngine); + serverThread.start(); + + int i = 0; + while (clientThread.isAlive() && serverThread.isAlive() && i < 20) { + Thread.sleep(500); + i++; + } + + if (clientThread.isAlive()) { + clientThread.interrupt(); + } + + if (serverThread.isAlive()) { + serverThread.interrupt(); + } + + return clientEngine.getStatus() == HandshakeStatus.FINISHED && serverEngine.getStatus() == HandshakeStatus.FINISHED; + } + +} |