test/jdk/sun/security/ssl/GenSSLConfigs/Traffic.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 import java.io.*;
 import java.security.*;

 class Traffic
 {
     private InputStream         in;
     private OutputStream        out;

     //
     // By default, traffic streams are predictable and what comes
     // in is compared with what it's expected to be.
     //
     static private byte fixedSeed [] = { 1, 2, 3, 4};

     private SecureRandom        prng;
     private boolean             compareRandom = true;


     Traffic (InputStream in, OutputStream out)
     {
         this.in = in;
         this.out = out;
         try {
             prng = SecureRandom.getInstance("SHA1PRNG");
         } catch (NoSuchAlgorithmException e) {
             throw new RuntimeException(e);
         }
         prng.setSeed(fixedSeed);
     }

     // optionally provide PRNG for "truly" random data.
     public void setPRNG (SecureRandom prng)
     {
         this.prng = prng;
         compareRandom = false;
     }


     //
     // Basic half-duplex testing, as used for RPC-style systems like
     // HTTP, RMI, CORBA, ONC, etc.
     //
     // parameter 'n' is "0" for some fixed data tests, else is the
     // number of passes of random data to send.
     //

     public void initiate (int n)
     throws IOException
     {
         // System.out.println ("Initiating N = " + n);

         if (n == 0)
             initiateConst ();
         else if (n < 0)
             System.out.println ("** ERROR:  initiate forever ??");
         else
             for ( ; n > 0; n -= 1) {
                 initiateRandom ();
             }
     }


     public void respond (int n)
     throws IOException
     {
         if (n == 0)
             respondConst ();
         else if (n < 0)                 // n < 0 == respond forever
             while (true)
                 respondRandom ();
         else
             while (n-- > 0)
                 respondRandom ();
     }


     //
     // Test passing of fixed size (and content) data.
     //
     // For SSL, one test goal is to ensure that all the basic
     // block cipher padding sizes get banged on.  SSLv3 ciphers
     // are all the same block size, but there are larger sizes
     // coming along.  (Big blocks in hardware can be fast!!)
     //

     private static final int MAX_BLOCKSIZE = 8 * 2;

     private void writeConstData (int n)
     throws IOException
     {
         if (n <= 0)
             return;

         byte buf [] = new byte [n];

         for (int i = 0; i < n; i++)
             buf [i] = (byte) i;

         out.write (buf);

         /*
         System.out.println (Thread.currentThread ().getName ()
             + " wrote const data size = " + n);
         */
     }

     private void readConstData (int n)
     throws IOException
     {
         if (n <= 0)
             return;

         byte buf [] = new byte [n];

         in.read (buf);

         for (int i = 0; i < n; i++)
             if (buf [i] != (byte) i)
                 throw new IOException ("const data was incorrect, "
                     + "n = " + n + ", i = " + i);

         /*
         System.out.println (Thread.currentThread ().getName ()
             + " read const data size = " + n);
         */
     }

     private void initiateConst ()
     throws IOException
     {
         for (int i = 1; i <= MAX_BLOCKSIZE; i++) {
             writeConstData (i);
             readConstData (i);
         }

     }

     private void respondConst ()
     throws IOException
     {
         for (int i = 1; i <= MAX_BLOCKSIZE; i++) {
             readConstData (i);
             writeConstData (i);
         }
     }


     //
     // Test passing of random size (and content) data.
     //
     // For SSL, one test goal is to ensure that all the basic
     // record sizes get banged on.  Traffic will normally
     // be bimodal (small packets, and big ones) and we give
     // a half-hearted effort at emulating that -- no real
     // statistics to back up this particular distribution.
     //

     private static final int MAX_RECORDSIZE = 16384 * 2;

     private int nextRecordSize ()
     {
         double  d = prng.nextGaussian ();
         int     n;

         // assume 1/3 traffic is "big", less variance
         if ((prng.nextInt () % 3)  == 0) {
             n = (int) (d * 2048);
             n += 15 * 1024;

         // ... and the rest is smaller, much variance
         } else {
             n = (int) (d * 4096);
             n += 1024;
         }

         if (n < 0)
             return nextRecordSize ();
         else if (n > MAX_RECORDSIZE)
             return MAX_RECORDSIZE;
         else
             return n;
     }


     private void writeRandomData ()
     throws IOException
     {
         int n = nextRecordSize ();
         byte buf [] = new byte [n];

         // System.out.println ("write, size = " + n);

         prng.nextBytes (buf);

         writeInt (n);
         out.write (buf);
     }

     private void readRandomData ()
     throws IOException
     {
         int     n = readInt ();
         byte    actual [] = new byte [n];

         readFully (actual);

         if (compareRandom) {
             byte        expected [];

             if (n != nextRecordSize ())
                 throw new IOException ("wrong record size");

             expected = new byte [n];
             prng.nextBytes (expected);

             for (int i = 0; i < n; i++)
                 if (actual [i] != expected [i])
                     throw new IOException ("random data was incorrect, "
                         + "n = " + n + ", i = " + i);
         }
     }

     private void initiateRandom ()
     throws IOException
     {
         writeRandomData ();
         readRandomData ();

     }

     private void respondRandom ()
     throws IOException
     {
         readRandomData ();
         writeRandomData ();
     }


     private void readFully (byte buf [])
     throws IOException
     {
         int len = buf.length;
         int offset = 0;
         int value;

         while (len > 0) {
             value = in.read (buf, offset, len);
             if (value == -1)
                 throw new EOFException ("read buffer");
             offset += value;
             len -= value;
         }
     }


     private int readInt ()
     throws IOException
     {
         int b0, b1, b2, b3;
         int n;

         b0 = in.read ();
         b1 = in.read ();
         b2 = in.read ();
         b3 = in.read ();

         if (b0 < 0 || b1 < 0 || b2 < 0 || b3 < 0)
             throw new EOFException ();

         /*
         System.out.println ("READ:   b0 = " + b0 + ", b1 = " + b1
             + ", b2 = " + b2 + ", b3 = " + b3);
         */

         n =  (b3 & 0x0ff);
         n |= (b2 & 0x0ff) << 8;
         n |= (b1 & 0x0ff) << 16;
         n |= (b0 & 0x0ff) << 24;
         return n;
     }

     private void writeInt (int n)
     throws IOException
     {
         int b0, b1, b2, b3;

         b3 = n & 0x0ff;
         n >>= 8;
         b2 = n & 0x0ff;
         n >>= 8;
         b1 = n & 0x0ff;
         n >>= 8;
         b0 = n & 0x0ff;

         /*
         System.out.println ("WRITE:  b0 = " + b0 + ", b1 = " + b1
             + ", b2 = " + b2 + ", b3 = " + b3);
         */

         out.write (b0);
         out.write (b1);
         out.write (b2);
         out.write (b3);
     }
 }
	/*
	* Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	import java.io.*;
	import java.security.*;

	class Traffic
	{
	private InputStream in;
	private OutputStream out;

	//
	// By default, traffic streams are predictable and what comes
	// in is compared with what it's expected to be.
	//
	static private byte fixedSeed [] = { 1, 2, 3, 4};

	private SecureRandom prng;
	private boolean compareRandom = true;


	Traffic (InputStream in, OutputStream out)
	{
	this.in = in;
	this.out = out;
	try {
	prng = SecureRandom.getInstance("SHA1PRNG");
	} catch (NoSuchAlgorithmException e) {
	throw new RuntimeException(e);
	}
	prng.setSeed(fixedSeed);
	}

	// optionally provide PRNG for "truly" random data.
	public void setPRNG (SecureRandom prng)
	{
	this.prng = prng;
	compareRandom = false;
	}


	//
	// Basic half-duplex testing, as used for RPC-style systems like
	// HTTP, RMI, CORBA, ONC, etc.
	//
	// parameter 'n' is "0" for some fixed data tests, else is the
	// number of passes of random data to send.
	//

	public void initiate (int n)
	throws IOException
	{
	// System.out.println ("Initiating N = " + n);

	if (n == 0)
	initiateConst ();
	else if (n < 0)
	System.out.println ("** ERROR: initiate forever ??");
	else
	for ( ; n > 0; n -= 1) {
	initiateRandom ();
	}
	}


	public void respond (int n)
	throws IOException
	{
	if (n == 0)
	respondConst ();
	else if (n < 0) // n < 0 == respond forever
	while (true)
	respondRandom ();
	else
	while (n-- > 0)
	respondRandom ();
	}


	//
	// Test passing of fixed size (and content) data.
	//
	// For SSL, one test goal is to ensure that all the basic
	// block cipher padding sizes get banged on. SSLv3 ciphers
	// are all the same block size, but there are larger sizes
	// coming along. (Big blocks in hardware can be fast!!)
	//

	private static final int MAX_BLOCKSIZE = 8 * 2;

	private void writeConstData (int n)
	throws IOException
	{
	if (n <= 0)
	return;

	byte buf [] = new byte [n];

	for (int i = 0; i < n; i++)
	buf [i] = (byte) i;

	out.write (buf);

	/*
	System.out.println (Thread.currentThread ().getName ()
	+ " wrote const data size = " + n);
	*/
	}

	private void readConstData (int n)
	throws IOException
	{
	if (n <= 0)
	return;

	byte buf [] = new byte [n];

	in.read (buf);

	for (int i = 0; i < n; i++)
	if (buf [i] != (byte) i)
	throw new IOException ("const data was incorrect, "
	+ "n = " + n + ", i = " + i);

	/*
	System.out.println (Thread.currentThread ().getName ()
	+ " read const data size = " + n);
	*/
	}

	private void initiateConst ()
	throws IOException
	{
	for (int i = 1; i <= MAX_BLOCKSIZE; i++) {
	writeConstData (i);
	readConstData (i);
	}

	}

	private void respondConst ()
	throws IOException
	{
	for (int i = 1; i <= MAX_BLOCKSIZE; i++) {
	readConstData (i);
	writeConstData (i);
	}
	}


	//
	// Test passing of random size (and content) data.
	//
	// For SSL, one test goal is to ensure that all the basic
	// record sizes get banged on. Traffic will normally
	// be bimodal (small packets, and big ones) and we give
	// a half-hearted effort at emulating that -- no real
	// statistics to back up this particular distribution.
	//

	private static final int MAX_RECORDSIZE = 16384 * 2;

	private int nextRecordSize ()
	{
	double d = prng.nextGaussian ();
	int n;

	// assume 1/3 traffic is "big", less variance
	if ((prng.nextInt () % 3) == 0) {
	n = (int) (d * 2048);
	n += 15 * 1024;

	// ... and the rest is smaller, much variance
	} else {
	n = (int) (d * 4096);
	n += 1024;
	}

	if (n < 0)
	return nextRecordSize ();
	else if (n > MAX_RECORDSIZE)
	return MAX_RECORDSIZE;
	else
	return n;
	}


	private void writeRandomData ()
	throws IOException
	{
	int n = nextRecordSize ();
	byte buf [] = new byte [n];

	// System.out.println ("write, size = " + n);

	prng.nextBytes (buf);

	writeInt (n);
	out.write (buf);
	}

	private void readRandomData ()
	throws IOException
	{
	int n = readInt ();
	byte actual [] = new byte [n];

	readFully (actual);

	if (compareRandom) {
	byte expected [];

	if (n != nextRecordSize ())
	throw new IOException ("wrong record size");

	expected = new byte [n];
	prng.nextBytes (expected);

	for (int i = 0; i < n; i++)
	if (actual [i] != expected [i])
	throw new IOException ("random data was incorrect, "
	+ "n = " + n + ", i = " + i);
	}
	}

	private void initiateRandom ()
	throws IOException
	{
	writeRandomData ();
	readRandomData ();

	}

	private void respondRandom ()
	throws IOException
	{
	readRandomData ();
	writeRandomData ();
	}


	private void readFully (byte buf [])
	throws IOException
	{
	int len = buf.length;
	int offset = 0;
	int value;

	while (len > 0) {
	value = in.read (buf, offset, len);
	if (value == -1)
	throw new EOFException ("read buffer");
	offset += value;
	len -= value;
	}
	}


	private int readInt ()
	throws IOException
	{
	int b0, b1, b2, b3;
	int n;

	b0 = in.read ();
	b1 = in.read ();
	b2 = in.read ();
	b3 = in.read ();

	if (b0 < 0 \|\| b1 < 0 \|\| b2 < 0 \|\| b3 < 0)
	throw new EOFException ();

	/*
	System.out.println ("READ: b0 = " + b0 + ", b1 = " + b1
	+ ", b2 = " + b2 + ", b3 = " + b3);
	*/

	n = (b3 & 0x0ff);
	n \|= (b2 & 0x0ff) << 8;
	n \|= (b1 & 0x0ff) << 16;
	n \|= (b0 & 0x0ff) << 24;
	return n;
	}

	private void writeInt (int n)
	throws IOException
	{
	int b0, b1, b2, b3;

	b3 = n & 0x0ff;
	n >>= 8;
	b2 = n & 0x0ff;
	n >>= 8;
	b1 = n & 0x0ff;
	n >>= 8;
	b0 = n & 0x0ff;

	/*
	System.out.println ("WRITE: b0 = " + b0 + ", b1 = " + b1
	+ ", b2 = " + b2 + ", b3 = " + b3);
	*/

	out.write (b0);
	out.write (b1);
	out.write (b2);
	out.write (b3);
	}
	}