Home | History | Annotate | Download | only in jsse
      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 
     18 package org.apache.harmony.xnet.provider.jsse;
     19 
     20 import java.io.IOException;
     21 import java.math.BigInteger;
     22 import java.util.Arrays;
     23 
     24 import junit.framework.TestCase;
     25 
     26 /**
     27  * Tests for <code>ClientKeyExchange</code> constructor and methods
     28  *
     29  */
     30 public class ClientKeyExchangeTest extends TestCase {
     31 
     32     /*
     33      * Test for void ClientKeyExchange(byte[], boolean)
     34      */
     35     public void testClientKeyExchangebyteArrayboolean() throws Exception {
     36         byte[] encrypted_pre_master_secret = new byte[] {
     37                 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
     38                 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
     39         boolean[] isTLS = new boolean[] { true, false };
     40 
     41         for (int i = 0; i < isTLS.length; i++) {
     42             ClientKeyExchange message = new ClientKeyExchange(
     43                     encrypted_pre_master_secret, isTLS[i]);
     44             assertEquals("incorrect type", Handshake.CLIENT_KEY_EXCHANGE,
     45                     message.getType());
     46 
     47             assertTrue("incorrect ClientKeyExchange", Arrays.equals(
     48                     message.exchange_keys, encrypted_pre_master_secret));
     49 
     50             HandshakeIODataStream out = new HandshakeIODataStream();
     51             message.send(out);
     52             byte[] encoded = out.getData(1000);
     53             assertEquals("incorrect out data length ", message.length(),
     54                     encoded.length);
     55 
     56             HandshakeIODataStream in = new HandshakeIODataStream();
     57             in.append(encoded);
     58             ClientKeyExchange message_2 = new ClientKeyExchange(in, message
     59                     .length(), isTLS[i], true);
     60 
     61             assertTrue("Incorrect message decoding", Arrays.equals(
     62                     message.exchange_keys, message_2.exchange_keys));
     63             assertEquals("Incorrect message decoding", message.length(),
     64                     message_2.length());
     65 
     66             in.append(encoded);
     67             try {
     68                 message_2 = new ClientKeyExchange(in, message.length() - 1,
     69                         isTLS[i], true);
     70                 if (isTLS[i]) {
     71                     fail("Small length: No expected AlertException");
     72                 }
     73             } catch (AlertException e) {
     74                 if (!isTLS[i]) {
     75                     fail(e.toString());
     76                 }
     77             }
     78 
     79             in.append(encoded);
     80             in.append(new byte[] { 1, 2, 3 });
     81             try {
     82                 message_2 = new ClientKeyExchange(in, message.length() + 3,
     83                         isTLS[i], true);
     84                 if (isTLS[i]) {
     85                     fail("Extra bytes: No expected AlertException");
     86                 }
     87             } catch (AlertException e) {
     88                 if (!isTLS[i]) {
     89                     fail(e.toString());
     90                 }
     91             }
     92         }
     93     }
     94 
     95     /*
     96      * Test for void ClientKeyExchange(BigInteger)
     97      */
     98     public void testClientKeyExchangeBigInteger() throws Exception {
     99         BigInteger dh_Yc = new BigInteger("1234567890");
    100         boolean[] isTLS = new boolean[] { true, false };
    101 
    102         for (int i = 0; i < isTLS.length; i++) {
    103             ClientKeyExchange message = new ClientKeyExchange(dh_Yc);
    104             assertEquals("incorrect type", Handshake.CLIENT_KEY_EXCHANGE,
    105                     message.getType());
    106             assertEquals("incorrect ClientKeyExchange", dh_Yc, new BigInteger(
    107                     message.exchange_keys));
    108 
    109             HandshakeIODataStream out = new HandshakeIODataStream();
    110             message.send(out);
    111             byte[] encoded = out.getData(1000);
    112             assertEquals("incorrect out data length", message.length(),
    113                     encoded.length);
    114 
    115             HandshakeIODataStream in = new HandshakeIODataStream();
    116             in.append(encoded);
    117             ClientKeyExchange message_2 = new ClientKeyExchange(in, message
    118                     .length(), isTLS[i], false);
    119 
    120             assertEquals("Incorrect message decoding", message.length(),
    121                     message_2.length());
    122             assertTrue("Incorrect message decoding", Arrays.equals(
    123                     message.exchange_keys, message_2.exchange_keys));
    124 
    125             in.append(encoded);
    126             try {
    127                 message_2 = new ClientKeyExchange(in, message.length() - 1,
    128                         isTLS[i], false);
    129                 fail("Small length: No expected AlertException");
    130             } catch (AlertException e) {
    131             }
    132 
    133             in.append(encoded);
    134             in.append(new byte[] { 1, 2, 3 });
    135             try {
    136                 message_2 = new ClientKeyExchange(in, message.length() + 3,
    137                         isTLS[i], false);
    138                 fail("Extra bytes: No expected AlertException");
    139             } catch (AlertException e) {
    140             }
    141         }
    142     }
    143 
    144     /*
    145      * Test for void ClientKeyExchange()
    146      */
    147     public void testClientKeyExchange() throws Exception {
    148 
    149         ClientKeyExchange message = new ClientKeyExchange();
    150         assertEquals("incorrect type", Handshake.CLIENT_KEY_EXCHANGE, message
    151                 .getType());
    152         assertEquals("incorrect ClientKeyExchange", 0,
    153                 message.exchange_keys.length);
    154         assertEquals("incorrect ClientKeyExchange", 0, message.length());
    155         assertTrue("incorrect ClientKeyExchange", message.isEmpty());
    156 
    157         HandshakeIODataStream out = new HandshakeIODataStream();
    158         message.send(out);
    159         byte[] encoded = out.getData(1000);
    160         assertEquals("incorrect ClientKeyExchange", 0, message.length());
    161         assertEquals("incorrect out data length", message.length(),
    162                 encoded.length);
    163 
    164         HandshakeIODataStream in = new HandshakeIODataStream();
    165         in.append(encoded);
    166         ClientKeyExchange message_2 = new ClientKeyExchange(in, message
    167                 .length(), true, false);
    168 
    169         assertEquals("Incorrect message decoding", 0,
    170                 message_2.exchange_keys.length);
    171         assertEquals("Incorrect message decoding", 0, message_2.length());
    172         assertTrue("Incorrect message decoding", message_2.isEmpty());
    173 
    174         in.append(encoded);
    175         try {
    176             message_2 = new ClientKeyExchange(in, message.length() - 1, true,
    177                     false);
    178             fail("Small length: No expected IOException");
    179         } catch (IOException e) {
    180         }
    181 
    182         in.append(encoded);
    183         in.append(new byte[] { 1, 2, 3 });
    184         try {
    185             message_2 = new ClientKeyExchange(in, message.length() + 3, true,
    186                     false);
    187             fail("Extra bytes: No expected IOException");
    188         } catch (IOException e) {
    189         }
    190     }
    191 
    192 }
    193