jdk/src/java.base/share/classes/sun/security/ssl/SSLEngineInputRecord.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 1996, 2014, 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.crypto.BadPaddingException;

 import javax.net.ssl.*;

 import sun.misc.HexDumpEncoder;


 /**
  * {@code InputRecord} implementation for {@code SSLEngine}.
  */
 final class SSLEngineInputRecord extends InputRecord implements SSLRecord {
     // used by handshake hash computation for handshake fragment
     private byte prevType = -1;
     private int hsMsgOff = 0;
     private int hsMsgLen = 0;

     private boolean formatVerified = false;     // SSLv2 ruled out?

     SSLEngineInputRecord() {
         this.readAuthenticator = MAC.TLS_NULL;
     }

     @Override
     int estimateFragmentSize(int packetSize) {
         int macLen = 0;
         if (readAuthenticator instanceof MAC) {
             macLen = ((MAC)readAuthenticator).MAClen();
         }

         if (packetSize > 0) {
             return readCipher.estimateFragmentSize(
                     packetSize, macLen, headerSize);
         } else {
             return Record.maxDataSize;
         }
     }

     @Override
     int bytesInCompletePacket(ByteBuffer packet) throws SSLException {
         /*
          * SSLv2 length field is in bytes 0/1
          * SSLv3/TLS length field is in bytes 3/4
          */
         if (packet.remaining() < 5) {
             return -1;
         }

         int pos = packet.position();
         byte byteZero = packet.get(pos);

         int len = 0;

         /*
          * If we have already verified previous packets, we can
          * ignore the verifications steps, and jump right to the
          * determination.  Otherwise, try one last hueristic to
          * see if it's SSL/TLS.
          */
         if (formatVerified ||
                 (byteZero == ct_handshake) || (byteZero == ct_alert)) {
             /*
              * Last sanity check that it's not a wild record
              */
             ProtocolVersion recordVersion = ProtocolVersion.valueOf(
                                     packet.get(pos + 1), packet.get(pos + 2));

             // check the record version
             checkRecordVersion(recordVersion, false);

             /*
              * Reasonably sure this is a V3, disable further checks.
              * We can't do the same in the v2 check below, because
              * read still needs to parse/handle the v2 clientHello.
              */
             formatVerified = true;

             /*
              * One of the SSLv3/TLS message types.
              */
             len = ((packet.get(pos + 3) & 0xFF) << 8) +
                    (packet.get(pos + 4) & 0xFF) + headerSize;

         } else {
             /*
              * Must be SSLv2 or something unknown.
              * Check if it's short (2 bytes) or
              * long (3) header.
              *
              * Internals can warn about unsupported SSLv2
              */
             boolean isShort = ((byteZero & 0x80) != 0);

             if (isShort &&
                     ((packet.get(pos + 2) == 1) || packet.get(pos + 2) == 4)) {

                 ProtocolVersion recordVersion = ProtocolVersion.valueOf(
                                     packet.get(pos + 3), packet.get(pos + 4));

                 // check the record version
                 checkRecordVersion(recordVersion, true);

                 /*
                  * Client or Server Hello
                  */
                 int mask = (isShort ? 0x7F : 0x3F);
                 len = ((byteZero & mask) << 8) +
                         (packet.get(pos + 1) & 0xFF) + (isShort ? 2 : 3);

             } else {
                 // Gobblygook!
                 throw new SSLException(
                         "Unrecognized SSL message, plaintext connection?");
             }
         }

         return len;
     }

     @Override
     void checkRecordVersion(ProtocolVersion recordVersion,
             boolean allowSSL20Hello) throws SSLException {

         if (recordVersion.maybeDTLSProtocol()) {
             throw new SSLException(
                     "Unrecognized record version " + recordVersion +
                     " , DTLS packet?");
         }

         // Check if the record version is too old.
         if ((recordVersion.v < ProtocolVersion.MIN.v)) {
             // if it's not SSLv2, we're out of here.
             if (!allowSSL20Hello ||
                     (recordVersion.v != ProtocolVersion.SSL20Hello.v)) {
                 throw new SSLException(
                     "Unsupported record version " + recordVersion);
             }
         }
     }

     @Override
     Plaintext decode(ByteBuffer packet)
             throws IOException, BadPaddingException {

         if (isClosed) {
             return null;
         }

         if (debug != null && Debug.isOn("packet")) {
              Debug.printHex(
                     "[Raw read]: length = " + packet.remaining(), packet);
         }

         // The caller should have validated the record.
         if (!formatVerified) {
             formatVerified = true;

             /*
              * The first record must either be a handshake record or an
              * alert message. If it's not, it is either invalid or an
              * SSLv2 message.
              */
             int pos = packet.position();
             byte byteZero = packet.get(pos);
             if (byteZero != ct_handshake && byteZero != ct_alert) {
                 return handleUnknownRecord(packet);
             }
         }

         return decodeInputRecord(packet);
     }

     private Plaintext decodeInputRecord(ByteBuffer packet)
             throws IOException, BadPaddingException {

         //
         // The packet should be a complete record, or more.
         //

         int srcPos = packet.position();
         int srcLim = packet.limit();

         byte contentType = packet.get();                   // pos: 0
         byte majorVersion = packet.get();                  // pos: 1
         byte minorVersion = packet.get();                  // pos: 2
         int contentLen = ((packet.get() & 0xFF) << 8) +
                           (packet.get() & 0xFF);           // pos: 3, 4

         if (debug != null && Debug.isOn("record")) {
              System.out.println(Thread.currentThread().getName() +
                     ", READ: " +
                     ProtocolVersion.valueOf(majorVersion, minorVersion) +
                     " " + Record.contentName(contentType) + ", length = " +
                     contentLen);
         }

         //
         // Check for upper bound.
         //
         // Note: May check packetSize limit in the future.
         if (contentLen < 0 || contentLen > maxLargeRecordSize - headerSize) {
             throw new SSLProtocolException(
                 "Bad input record size, TLSCiphertext.length = " + contentLen);
         }

         //
         // check for handshake fragment
         //
         if ((contentType != ct_handshake) && (hsMsgOff != hsMsgLen)) {
             throw new SSLProtocolException(
                     "Expected to get a handshake fragment");
         }

         //
         // Decrypt the fragment
         //
         int recLim = srcPos + SSLRecord.headerSize + contentLen;
         packet.limit(recLim);
         packet.position(srcPos + SSLRecord.headerSize);

         ByteBuffer plaintext;
         try {
             plaintext =
                 decrypt(readAuthenticator, readCipher, contentType, packet);
         } finally {
             // comsume a complete record
             packet.limit(srcLim);
             packet.position(recLim);
         }

         //
         // handshake hashing
         //
         if (contentType == ct_handshake) {
             int pltPos = plaintext.position();
             int pltLim = plaintext.limit();
             int frgPos = pltPos;
             for (int remains = plaintext.remaining(); remains > 0;) {
                 int howmuch;
                 byte handshakeType;
                 if (hsMsgOff < hsMsgLen) {
                     // a fragment of the handshake message
                     howmuch = Math.min((hsMsgLen - hsMsgOff), remains);
                     handshakeType = prevType;

                     hsMsgOff += howmuch;
                     if (hsMsgOff == hsMsgLen) {
                         // Now is a complete handshake message.
                         hsMsgOff = 0;
                         hsMsgLen = 0;
                     }
                 } else {    // hsMsgOff == hsMsgLen, a new handshake message
                     handshakeType = plaintext.get();
                     int handshakeLen = ((plaintext.get() & 0xFF) << 16) |
                                        ((plaintext.get() & 0xFF) << 8) |
                                         (plaintext.get() & 0xFF);
                     plaintext.position(frgPos);
                     if (remains < (handshakeLen + 4)) { // 4: handshake header
                         // This handshake message is fragmented.
                         prevType = handshakeType;
                         hsMsgOff = remains - 4;         // 4: handshake header
                         hsMsgLen = handshakeLen;
                     }

                     howmuch = Math.min(handshakeLen + 4, remains);
                 }

                 plaintext.limit(frgPos + howmuch);

                 if (handshakeType == HandshakeMessage.ht_hello_request) {
                     // omitted from handshake hash computation
                 } else if ((handshakeType != HandshakeMessage.ht_finished) &&
                     (handshakeType != HandshakeMessage.ht_certificate_verify)) {

                     if (handshakeHash == null) {
                         // used for cache only
                         handshakeHash = new HandshakeHash(false);
                     }
                     handshakeHash.update(plaintext);
                 } else {
                     // Reserve until this handshake message has been processed.
                     if (handshakeHash == null) {
                         // used for cache only
                         handshakeHash = new HandshakeHash(false);
                     }
                     handshakeHash.reserve(plaintext);
                 }

                 plaintext.position(frgPos + howmuch);
                 plaintext.limit(pltLim);

                 frgPos += howmuch;
                 remains -= howmuch;
             }

             plaintext.position(pltPos);
         }

         return new Plaintext(contentType,
                 majorVersion, minorVersion, -1, -1L, plaintext);
                 // recordEpoch, recordSeq, plaintext);
     }

     private Plaintext handleUnknownRecord(ByteBuffer packet)
             throws IOException, BadPaddingException {

         //
         // The packet should be a complete record.
         //
         int srcPos = packet.position();
         int srcLim = packet.limit();

         byte firstByte = packet.get(srcPos);
         byte thirdByte = packet.get(srcPos + 2);

         // Does it look like a Version 2 client hello (V2ClientHello)?
         if (((firstByte & 0x80) != 0) && (thirdByte == 1)) {
             /*
              * If SSLv2Hello is not enabled, throw an exception.
              */
             if (helloVersion != ProtocolVersion.SSL20Hello) {
                 throw new SSLHandshakeException("SSLv2Hello is not enabled");
             }

             byte majorVersion = packet.get(srcPos + 3);
             byte minorVersion = packet.get(srcPos + 4);

             if ((majorVersion == ProtocolVersion.SSL20Hello.major) &&
                 (minorVersion == ProtocolVersion.SSL20Hello.minor)) {

                 /*
                  * Looks like a V2 client hello, but not one saying
                  * "let's talk SSLv3".  So we need to send an SSLv2
                  * error message, one that's treated as fatal by
                  * clients (Otherwise we'll hang.)
                  */
                 if (debug != null && Debug.isOn("record")) {
                      System.out.println(Thread.currentThread().getName() +
                             "Requested to negotiate unsupported SSLv2!");
                 }

                 // hack code, the exception is caught in SSLEngineImpl
                 // so that SSLv2 error message can be delivered properly.
                 throw new UnsupportedOperationException(        // SSLv2Hello
                         "Unsupported SSL v2.0 ClientHello");
             }

             /*
              * If we can map this into a V3 ClientHello, read and
              * hash the rest of the V2 handshake, turn it into a
              * V3 ClientHello message, and pass it up.
              */
             packet.position(srcPos + 2);        // exclude the header

             if (handshakeHash == null) {
                 // used for cache only
                 handshakeHash = new HandshakeHash(false);
             }
             handshakeHash.update(packet);
             packet.position(srcPos);

             ByteBuffer converted = convertToClientHello(packet);

             if (debug != null && Debug.isOn("packet")) {
                  Debug.printHex(
                         "[Converted] ClientHello", converted);
             }

             return new Plaintext(ct_handshake,
                 majorVersion, minorVersion, -1, -1L, converted);
         } else {
             if (((firstByte & 0x80) != 0) && (thirdByte == 4)) {
                 throw new SSLException("SSL V2.0 servers are not supported.");
             }

             throw new SSLException("Unsupported or unrecognized SSL message");
         }
     }

 }
	/*
	* Copyright (c) 1996, 2014, 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.crypto.BadPaddingException;

	import javax.net.ssl.*;

	import sun.misc.HexDumpEncoder;


	/**
	* {@code InputRecord} implementation for {@code SSLEngine}.
	*/
	final class SSLEngineInputRecord extends InputRecord implements SSLRecord {
	// used by handshake hash computation for handshake fragment
	private byte prevType = -1;
	private int hsMsgOff = 0;
	private int hsMsgLen = 0;

	private boolean formatVerified = false; // SSLv2 ruled out?

	SSLEngineInputRecord() {
	this.readAuthenticator = MAC.TLS_NULL;
	}

	@Override
	int estimateFragmentSize(int packetSize) {
	int macLen = 0;
	if (readAuthenticator instanceof MAC) {
	macLen = ((MAC)readAuthenticator).MAClen();
	}

	if (packetSize > 0) {
	return readCipher.estimateFragmentSize(
	packetSize, macLen, headerSize);
	} else {
	return Record.maxDataSize;
	}
	}

	@Override
	int bytesInCompletePacket(ByteBuffer packet) throws SSLException {
	/*
	* SSLv2 length field is in bytes 0/1
	* SSLv3/TLS length field is in bytes 3/4
	*/
	if (packet.remaining() < 5) {
	return -1;
	}

	int pos = packet.position();
	byte byteZero = packet.get(pos);

	int len = 0;

	/*
	* If we have already verified previous packets, we can
	* ignore the verifications steps, and jump right to the
	* determination. Otherwise, try one last hueristic to
	* see if it's SSL/TLS.
	*/
	if (formatVerified \|\|
	(byteZero == ct_handshake) \|\| (byteZero == ct_alert)) {
	/*
	* Last sanity check that it's not a wild record
	*/
	ProtocolVersion recordVersion = ProtocolVersion.valueOf(
	packet.get(pos + 1), packet.get(pos + 2));

	// check the record version
	checkRecordVersion(recordVersion, false);

	/*
	* Reasonably sure this is a V3, disable further checks.
	* We can't do the same in the v2 check below, because
	* read still needs to parse/handle the v2 clientHello.
	*/
	formatVerified = true;

	/*
	* One of the SSLv3/TLS message types.
	*/
	len = ((packet.get(pos + 3) & 0xFF) << 8) +
	(packet.get(pos + 4) & 0xFF) + headerSize;

	} else {
	/*
	* Must be SSLv2 or something unknown.
	* Check if it's short (2 bytes) or
	* long (3) header.
	*
	* Internals can warn about unsupported SSLv2
	*/
	boolean isShort = ((byteZero & 0x80) != 0);

	if (isShort &&
	((packet.get(pos + 2) == 1) \|\| packet.get(pos + 2) == 4)) {

	ProtocolVersion recordVersion = ProtocolVersion.valueOf(
	packet.get(pos + 3), packet.get(pos + 4));

	// check the record version
	checkRecordVersion(recordVersion, true);

	/*
	* Client or Server Hello
	*/
	int mask = (isShort ? 0x7F : 0x3F);
	len = ((byteZero & mask) << 8) +
	(packet.get(pos + 1) & 0xFF) + (isShort ? 2 : 3);

	} else {
	// Gobblygook!
	throw new SSLException(
	"Unrecognized SSL message, plaintext connection?");
	}
	}

	return len;
	}

	@Override
	void checkRecordVersion(ProtocolVersion recordVersion,
	boolean allowSSL20Hello) throws SSLException {

	if (recordVersion.maybeDTLSProtocol()) {
	throw new SSLException(
	"Unrecognized record version " + recordVersion +
	" , DTLS packet?");
	}

	// Check if the record version is too old.
	if ((recordVersion.v < ProtocolVersion.MIN.v)) {
	// if it's not SSLv2, we're out of here.
	if (!allowSSL20Hello \|\|
	(recordVersion.v != ProtocolVersion.SSL20Hello.v)) {
	throw new SSLException(
	"Unsupported record version " + recordVersion);
	}
	}
	}

	@Override
	Plaintext decode(ByteBuffer packet)
	throws IOException, BadPaddingException {

	if (isClosed) {
	return null;
	}

	if (debug != null && Debug.isOn("packet")) {
	Debug.printHex(
	"[Raw read]: length = " + packet.remaining(), packet);
	}

	// The caller should have validated the record.
	if (!formatVerified) {
	formatVerified = true;

	/*
	* The first record must either be a handshake record or an
	* alert message. If it's not, it is either invalid or an
	* SSLv2 message.
	*/
	int pos = packet.position();
	byte byteZero = packet.get(pos);
	if (byteZero != ct_handshake && byteZero != ct_alert) {
	return handleUnknownRecord(packet);
	}
	}

	return decodeInputRecord(packet);
	}

	private Plaintext decodeInputRecord(ByteBuffer packet)
	throws IOException, BadPaddingException {

	//
	// The packet should be a complete record, or more.
	//

	int srcPos = packet.position();
	int srcLim = packet.limit();

	byte contentType = packet.get(); // pos: 0
	byte majorVersion = packet.get(); // pos: 1
	byte minorVersion = packet.get(); // pos: 2
	int contentLen = ((packet.get() & 0xFF) << 8) +
	(packet.get() & 0xFF); // pos: 3, 4

	if (debug != null && Debug.isOn("record")) {
	System.out.println(Thread.currentThread().getName() +
	", READ: " +
	ProtocolVersion.valueOf(majorVersion, minorVersion) +
	" " + Record.contentName(contentType) + ", length = " +
	contentLen);
	}

	//
	// Check for upper bound.
	//
	// Note: May check packetSize limit in the future.
	if (contentLen < 0 \|\| contentLen > maxLargeRecordSize - headerSize) {
	throw new SSLProtocolException(
	"Bad input record size, TLSCiphertext.length = " + contentLen);
	}

	//
	// check for handshake fragment
	//
	if ((contentType != ct_handshake) && (hsMsgOff != hsMsgLen)) {
	throw new SSLProtocolException(
	"Expected to get a handshake fragment");
	}

	//
	// Decrypt the fragment
	//
	int recLim = srcPos + SSLRecord.headerSize + contentLen;
	packet.limit(recLim);
	packet.position(srcPos + SSLRecord.headerSize);

	ByteBuffer plaintext;
	try {
	plaintext =
	decrypt(readAuthenticator, readCipher, contentType, packet);
	} finally {
	// comsume a complete record
	packet.limit(srcLim);
	packet.position(recLim);
	}

	//
	// handshake hashing
	//
	if (contentType == ct_handshake) {
	int pltPos = plaintext.position();
	int pltLim = plaintext.limit();
	int frgPos = pltPos;
	for (int remains = plaintext.remaining(); remains > 0;) {
	int howmuch;
	byte handshakeType;
	if (hsMsgOff < hsMsgLen) {
	// a fragment of the handshake message
	howmuch = Math.min((hsMsgLen - hsMsgOff), remains);
	handshakeType = prevType;

	hsMsgOff += howmuch;
	if (hsMsgOff == hsMsgLen) {
	// Now is a complete handshake message.
	hsMsgOff = 0;
	hsMsgLen = 0;
	}
	} else { // hsMsgOff == hsMsgLen, a new handshake message
	handshakeType = plaintext.get();
	int handshakeLen = ((plaintext.get() & 0xFF) << 16) \|
	((plaintext.get() & 0xFF) << 8) \|
	(plaintext.get() & 0xFF);
	plaintext.position(frgPos);
	if (remains < (handshakeLen + 4)) { // 4: handshake header
	// This handshake message is fragmented.
	prevType = handshakeType;
	hsMsgOff = remains - 4; // 4: handshake header
	hsMsgLen = handshakeLen;
	}

	howmuch = Math.min(handshakeLen + 4, remains);
	}

	plaintext.limit(frgPos + howmuch);

	if (handshakeType == HandshakeMessage.ht_hello_request) {
	// omitted from handshake hash computation
	} else if ((handshakeType != HandshakeMessage.ht_finished) &&
	(handshakeType != HandshakeMessage.ht_certificate_verify)) {

	if (handshakeHash == null) {
	// used for cache only
	handshakeHash = new HandshakeHash(false);
	}
	handshakeHash.update(plaintext);
	} else {
	// Reserve until this handshake message has been processed.
	if (handshakeHash == null) {
	// used for cache only
	handshakeHash = new HandshakeHash(false);
	}
	handshakeHash.reserve(plaintext);
	}

	plaintext.position(frgPos + howmuch);
	plaintext.limit(pltLim);

	frgPos += howmuch;
	remains -= howmuch;
	}

	plaintext.position(pltPos);
	}

	return new Plaintext(contentType,
	majorVersion, minorVersion, -1, -1L, plaintext);
	// recordEpoch, recordSeq, plaintext);
	}

	private Plaintext handleUnknownRecord(ByteBuffer packet)
	throws IOException, BadPaddingException {

	//
	// The packet should be a complete record.
	//
	int srcPos = packet.position();
	int srcLim = packet.limit();

	byte firstByte = packet.get(srcPos);
	byte thirdByte = packet.get(srcPos + 2);

	// Does it look like a Version 2 client hello (V2ClientHello)?
	if (((firstByte & 0x80) != 0) && (thirdByte == 1)) {
	/*
	* If SSLv2Hello is not enabled, throw an exception.
	*/
	if (helloVersion != ProtocolVersion.SSL20Hello) {
	throw new SSLHandshakeException("SSLv2Hello is not enabled");
	}

	byte majorVersion = packet.get(srcPos + 3);
	byte minorVersion = packet.get(srcPos + 4);

	if ((majorVersion == ProtocolVersion.SSL20Hello.major) &&
	(minorVersion == ProtocolVersion.SSL20Hello.minor)) {

	/*
	* Looks like a V2 client hello, but not one saying
	* "let's talk SSLv3". So we need to send an SSLv2
	* error message, one that's treated as fatal by
	* clients (Otherwise we'll hang.)
	*/
	if (debug != null && Debug.isOn("record")) {
	System.out.println(Thread.currentThread().getName() +
	"Requested to negotiate unsupported SSLv2!");
	}

	// hack code, the exception is caught in SSLEngineImpl
	// so that SSLv2 error message can be delivered properly.
	throw new UnsupportedOperationException( // SSLv2Hello
	"Unsupported SSL v2.0 ClientHello");
	}

	/*
	* If we can map this into a V3 ClientHello, read and
	* hash the rest of the V2 handshake, turn it into a
	* V3 ClientHello message, and pass it up.
	*/
	packet.position(srcPos + 2); // exclude the header

	if (handshakeHash == null) {
	// used for cache only
	handshakeHash = new HandshakeHash(false);
	}
	handshakeHash.update(packet);
	packet.position(srcPos);

	ByteBuffer converted = convertToClientHello(packet);

	if (debug != null && Debug.isOn("packet")) {
	Debug.printHex(
	"[Converted] ClientHello", converted);
	}

	return new Plaintext(ct_handshake,
	majorVersion, minorVersion, -1, -1L, converted);
	} else {
	if (((firstByte & 0x80) != 0) && (thirdByte == 4)) {
	throw new SSLException("SSL V2.0 servers are not supported.");
	}

	throw new SSLException("Unsupported or unrecognized SSL message");
	}
	}

	}