src/share/classes/sun/security/ssl/EngineOutputRecord.java - toolchain/jdk/jdk9_jdk - Git at Google

 /*
  * Copyright (c) 2003, 2007, 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.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * 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.
  */


 package sun.security.ssl;

 import java.io.*;
 import java.nio.*;

 import javax.net.ssl.SSLException;
 import sun.misc.HexDumpEncoder;


 /**
  * A OutputRecord class extension which uses external ByteBuffers
  * or the internal ByteArrayOutputStream for data manipulations.
  * <P>
  * Instead of rewriting this entire class
  * to use ByteBuffers, we leave things intact, so handshake, CCS,
  * and alerts will continue to use the internal buffers, but application
  * data will use external buffers.
  *
  * @author Brad Wetmore
  */
 final class EngineOutputRecord extends OutputRecord {

     private EngineWriter writer;

     private boolean finishedMsg = false;

     /*
      * All handshake hashing is done by the superclass
      */

     /*
      * Default constructor makes a record supporting the maximum
      * SSL record size.  It allocates the header bytes directly.
      *
      * @param type the content type for the record
      */
     EngineOutputRecord(byte type, SSLEngineImpl engine) {
         super(type, recordSize(type));
         writer = engine.writer;
     }

     /**
      * Get the size of the buffer we need for records of the specified
      * type.
      * <P>
      * Application data buffers will provide their own byte buffers,
      * and will not use the internal byte caching.
      */
     private static int recordSize(byte type) {
         switch (type) {

         case ct_change_cipher_spec:
         case ct_alert:
             return maxAlertRecordSize;

         case ct_handshake:
             return maxRecordSize;

         case ct_application_data:
             return 0;
         }

         throw new RuntimeException("Unknown record type: " + type);
     }

     void setFinishedMsg() {
         finishedMsg = true;
     }

     public void flush() throws IOException {
         finishedMsg = false;
     }

     boolean isFinishedMsg() {
         return finishedMsg;
     }


     /**
      * Calculate the MAC value, storing the result either in
      * the internal buffer, or at the end of the destination
      * ByteBuffer.
      * <P>
      * We assume that the higher levels have assured us enough
      * room, otherwise we'll indirectly throw a
      * BufferOverFlowException runtime exception.
      *
      * position should equal limit, and points to the next
      * free spot.
      */
     private void addMAC(MAC signer, ByteBuffer bb)
             throws IOException {

         if (signer.MAClen() != 0) {
             byte[] hash = signer.compute(contentType(), bb);

             /*
              * position was advanced to limit in compute above.
              *
              * Mark next area as writable (above layers should have
              * established that we have plenty of room), then write
              * out the hash.
              */
             bb.limit(bb.limit() + hash.length);
             bb.put(hash);
         }
     }

     /*
      * Encrypt a ByteBuffer.
      *
      * We assume that the higher levels have assured us enough
      * room for the encryption (plus padding), otherwise we'll
      * indirectly throw a BufferOverFlowException runtime exception.
      *
      * position and limit will be the same, and points to the
      * next free spot.
      */
     void encrypt(CipherBox box, ByteBuffer bb) {
         box.encrypt(bb);
     }

     /*
      * Override the actual write below.  We do things this way to be
      * consistent with InputRecord.  InputRecord may try to write out
      * data to the peer, and *then* throw an Exception.  This forces
      * data to be generated/output before the exception is ever
      * generated.
      */
     void writeBuffer(OutputStream s, byte [] buf, int off, int len)
             throws IOException {
         /*
          * Copy data out of buffer, it's ready to go.
          */
         ByteBuffer netBB = (ByteBuffer)
             ByteBuffer.allocate(len).put(buf, 0, len).flip();
         writer.putOutboundData(netBB);
     }

     /*
      * Main method for writing non-application data.
      * We MAC/encrypt, then send down for processing.
      */
     void write(MAC writeMAC, CipherBox writeCipher) throws IOException {
         /*
          * Sanity check.
          */
         switch (contentType()) {
         case ct_change_cipher_spec:
         case ct_alert:
         case ct_handshake:
             break;
         default:
             throw new RuntimeException("unexpected byte buffers");
         }

         /*
          * Don't bother to really write empty records.  We went this
          * far to drive the handshake machinery, for correctness; not
          * writing empty records improves performance by cutting CPU
          * time and network resource usage.  Also, some protocol
          * implementations are fragile and don't like to see empty
          * records, so this increases robustness.
          *
          * (Even change cipher spec messages have a byte of data!)
          */
         if (!isEmpty()) {
             // compress();              // eventually
             addMAC(writeMAC);
             encrypt(writeCipher);
             write((OutputStream)null);  // send down for processing
         }
         return;
     }

     /**
      * Main wrap/write driver.
      */
     void write(EngineArgs ea, MAC writeMAC, CipherBox writeCipher)
             throws IOException {
         /*
          * sanity check to make sure someone didn't inadvertantly
          * send us an impossible combination we don't know how
          * to process.
          */
         assert(contentType() == ct_application_data);

         /*
          * Have we set the MAC's yet?  If not, we're not ready
          * to process application data yet.
          */
         if (writeMAC == MAC.NULL) {
             return;
         }

         /*
          * Don't bother to really write empty records.  We went this
          * far to drive the handshake machinery, for correctness; not
          * writing empty records improves performance by cutting CPU
          * time and network resource usage.  Also, some protocol
          * implementations are fragile and don't like to see empty
          * records, so this increases robustness.
          */
         int length = Math.min(ea.getAppRemaining(), maxDataSize);
         if (length == 0) {
             return;
         }

         /*
          * Copy out existing buffer values.
          */
         ByteBuffer dstBB = ea.netData;
         int dstPos = dstBB.position();
         int dstLim = dstBB.limit();

         /*
          * Where to put the data.  Jump over the header.
          *
          * Don't need to worry about SSLv2 rewrites, if we're here,
          * that's long since done.
          */
         int dstData = dstPos + headerSize;
         dstBB.position(dstData);

         ea.gather(length);

         /*
          * "flip" but skip over header again, add MAC & encrypt
          * addMAC will expand the limit to reflect the new
          * data.
          */
         dstBB.limit(dstBB.position());
         dstBB.position(dstData);
         addMAC(writeMAC, dstBB);

         /*
          * Encrypt may pad, so again the limit may have changed.
          */
         dstBB.limit(dstBB.position());
         dstBB.position(dstData);
         encrypt(writeCipher, dstBB);

         if (debug != null
                 && (Debug.isOn("record") || Debug.isOn("handshake"))) {
             if ((debug != null && Debug.isOn("record"))
                     || contentType() == ct_change_cipher_spec)
                 System.out.println(Thread.currentThread().getName()
                     // v3.0/v3.1 ...
                     + ", WRITE: " + protocolVersion
                     + " " + InputRecord.contentName(contentType())
                     + ", length = " + length);
         }

         int packetLength = dstBB.limit() - dstData;

         /*
          * Finish out the record header.
          */
         dstBB.put(dstPos, contentType());
         dstBB.put(dstPos + 1, protocolVersion.major);
         dstBB.put(dstPos + 2, protocolVersion.minor);
         dstBB.put(dstPos + 3, (byte)(packetLength >> 8));
         dstBB.put(dstPos + 4, (byte)packetLength);

         /*
          * Position was already set by encrypt() above.
          */
         dstBB.limit(dstLim);

         return;
     }
 }
	/*
	* Copyright (c) 2003, 2007, 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. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* 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.
	*/


	package sun.security.ssl;

	import java.io.*;
	import java.nio.*;

	import javax.net.ssl.SSLException;
	import sun.misc.HexDumpEncoder;


	/**
	* A OutputRecord class extension which uses external ByteBuffers
	* or the internal ByteArrayOutputStream for data manipulations.
	* <P>
	* Instead of rewriting this entire class
	* to use ByteBuffers, we leave things intact, so handshake, CCS,
	* and alerts will continue to use the internal buffers, but application
	* data will use external buffers.
	*
	* @author Brad Wetmore
	*/
	final class EngineOutputRecord extends OutputRecord {

	private EngineWriter writer;

	private boolean finishedMsg = false;

	/*
	* All handshake hashing is done by the superclass
	*/

	/*
	* Default constructor makes a record supporting the maximum
	* SSL record size. It allocates the header bytes directly.
	*
	* @param type the content type for the record
	*/
	EngineOutputRecord(byte type, SSLEngineImpl engine) {
	super(type, recordSize(type));
	writer = engine.writer;
	}

	/**
	* Get the size of the buffer we need for records of the specified
	* type.
	* <P>
	* Application data buffers will provide their own byte buffers,
	* and will not use the internal byte caching.
	*/
	private static int recordSize(byte type) {
	switch (type) {

	case ct_change_cipher_spec:
	case ct_alert:
	return maxAlertRecordSize;

	case ct_handshake:
	return maxRecordSize;

	case ct_application_data:
	return 0;
	}

	throw new RuntimeException("Unknown record type: " + type);
	}

	void setFinishedMsg() {
	finishedMsg = true;
	}

	public void flush() throws IOException {
	finishedMsg = false;
	}

	boolean isFinishedMsg() {
	return finishedMsg;
	}


	/**
	* Calculate the MAC value, storing the result either in
	* the internal buffer, or at the end of the destination
	* ByteBuffer.
	* <P>
	* We assume that the higher levels have assured us enough
	* room, otherwise we'll indirectly throw a
	* BufferOverFlowException runtime exception.
	*
	* position should equal limit, and points to the next
	* free spot.
	*/
	private void addMAC(MAC signer, ByteBuffer bb)
	throws IOException {

	if (signer.MAClen() != 0) {
	byte[] hash = signer.compute(contentType(), bb);

	/*
	* position was advanced to limit in compute above.
	*
	* Mark next area as writable (above layers should have
	* established that we have plenty of room), then write
	* out the hash.
	*/
	bb.limit(bb.limit() + hash.length);
	bb.put(hash);
	}
	}

	/*
	* Encrypt a ByteBuffer.
	*
	* We assume that the higher levels have assured us enough
	* room for the encryption (plus padding), otherwise we'll
	* indirectly throw a BufferOverFlowException runtime exception.
	*
	* position and limit will be the same, and points to the
	* next free spot.
	*/
	void encrypt(CipherBox box, ByteBuffer bb) {
	box.encrypt(bb);
	}

	/*
	* Override the actual write below. We do things this way to be
	* consistent with InputRecord. InputRecord may try to write out
	* data to the peer, and then throw an Exception. This forces
	* data to be generated/output before the exception is ever
	* generated.
	*/
	void writeBuffer(OutputStream s, byte [] buf, int off, int len)
	throws IOException {
	/*
	* Copy data out of buffer, it's ready to go.
	*/
	ByteBuffer netBB = (ByteBuffer)
	ByteBuffer.allocate(len).put(buf, 0, len).flip();
	writer.putOutboundData(netBB);
	}

	/*
	* Main method for writing non-application data.
	* We MAC/encrypt, then send down for processing.
	*/
	void write(MAC writeMAC, CipherBox writeCipher) throws IOException {
	/*
	* Sanity check.
	*/
	switch (contentType()) {
	case ct_change_cipher_spec:
	case ct_alert:
	case ct_handshake:
	break;
	default:
	throw new RuntimeException("unexpected byte buffers");
	}

	/*
	* Don't bother to really write empty records. We went this
	* far to drive the handshake machinery, for correctness; not
	* writing empty records improves performance by cutting CPU
	* time and network resource usage. Also, some protocol
	* implementations are fragile and don't like to see empty
	* records, so this increases robustness.
	*
	* (Even change cipher spec messages have a byte of data!)
	*/
	if (!isEmpty()) {
	// compress(); // eventually
	addMAC(writeMAC);
	encrypt(writeCipher);
	write((OutputStream)null); // send down for processing
	}
	return;
	}

	/**
	* Main wrap/write driver.
	*/
	void write(EngineArgs ea, MAC writeMAC, CipherBox writeCipher)
	throws IOException {
	/*
	* sanity check to make sure someone didn't inadvertantly
	* send us an impossible combination we don't know how
	* to process.
	*/
	assert(contentType() == ct_application_data);

	/*
	* Have we set the MAC's yet? If not, we're not ready
	* to process application data yet.
	*/
	if (writeMAC == MAC.NULL) {
	return;
	}

	/*
	* Don't bother to really write empty records. We went this
	* far to drive the handshake machinery, for correctness; not
	* writing empty records improves performance by cutting CPU
	* time and network resource usage. Also, some protocol
	* implementations are fragile and don't like to see empty
	* records, so this increases robustness.
	*/
	int length = Math.min(ea.getAppRemaining(), maxDataSize);
	if (length == 0) {
	return;
	}

	/*
	* Copy out existing buffer values.
	*/
	ByteBuffer dstBB = ea.netData;
	int dstPos = dstBB.position();
	int dstLim = dstBB.limit();

	/*
	* Where to put the data. Jump over the header.
	*
	* Don't need to worry about SSLv2 rewrites, if we're here,
	* that's long since done.
	*/
	int dstData = dstPos + headerSize;
	dstBB.position(dstData);

	ea.gather(length);

	/*
	* "flip" but skip over header again, add MAC & encrypt
	* addMAC will expand the limit to reflect the new
	* data.
	*/
	dstBB.limit(dstBB.position());
	dstBB.position(dstData);
	addMAC(writeMAC, dstBB);

	/*
	* Encrypt may pad, so again the limit may have changed.
	*/
	dstBB.limit(dstBB.position());
	dstBB.position(dstData);
	encrypt(writeCipher, dstBB);

	if (debug != null
	&& (Debug.isOn("record") \|\| Debug.isOn("handshake"))) {
	if ((debug != null && Debug.isOn("record"))
	\|\| contentType() == ct_change_cipher_spec)
	System.out.println(Thread.currentThread().getName()
	// v3.0/v3.1 ...
	+ ", WRITE: " + protocolVersion
	+ " " + InputRecord.contentName(contentType())
	+ ", length = " + length);
	}

	int packetLength = dstBB.limit() - dstData;

	/*
	* Finish out the record header.
	*/
	dstBB.put(dstPos, contentType());
	dstBB.put(dstPos + 1, protocolVersion.major);
	dstBB.put(dstPos + 2, protocolVersion.minor);
	dstBB.put(dstPos + 3, (byte)(packetLength >> 8));
	dstBB.put(dstPos + 4, (byte)packetLength);

	/*
	* Position was already set by encrypt() above.
	*/
	dstBB.limit(dstLim);

	return;
	}
	}