842 lines
No EOL
28 KiB
Java
842 lines
No EOL
28 KiB
Java
/* SSLEngineImpl.java -- implementation of SSLEngine.
|
|
Copyright (C) 2006 Free Software Foundation, Inc.
|
|
|
|
This file is a part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or (at
|
|
your option) any later version.
|
|
|
|
GNU Classpath 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 for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
|
USA
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
|
|
package gnu.javax.net.ssl.provider;
|
|
|
|
import gnu.classpath.debug.Component;
|
|
import gnu.classpath.debug.SystemLogger;
|
|
|
|
import gnu.java.security.util.ByteBufferOutputStream;
|
|
import gnu.javax.net.ssl.Session;
|
|
import gnu.javax.net.ssl.SSLRecordHandler;
|
|
|
|
import java.nio.BufferOverflowException;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.ByteOrder;
|
|
|
|
import java.security.NoSuchAlgorithmException;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.zip.DataFormatException;
|
|
|
|
import javax.crypto.IllegalBlockSizeException;
|
|
import javax.crypto.ShortBufferException;
|
|
import javax.net.ssl.SSLEngine;
|
|
import javax.net.ssl.SSLEngineResult;
|
|
import javax.net.ssl.SSLException;
|
|
import javax.net.ssl.SSLSession;
|
|
import javax.net.ssl.SSLEngineResult.HandshakeStatus;
|
|
import javax.net.ssl.SSLEngineResult.Status;
|
|
|
|
public final class SSLEngineImpl extends SSLEngine
|
|
{
|
|
final SSLContextImpl contextImpl;
|
|
private SSLRecordHandler[] handlers;
|
|
private static final SystemLogger logger = SystemLogger.SYSTEM;
|
|
private SessionImpl session;
|
|
private InputSecurityParameters insec;
|
|
private OutputSecurityParameters outsec;
|
|
private boolean inClosed;
|
|
private boolean outClosed;
|
|
private boolean createSessions;
|
|
private boolean needClientAuth;
|
|
private boolean wantClientAuth;
|
|
private boolean initialHandshakeDone;
|
|
private AbstractHandshake handshake;
|
|
private Alert lastAlert;
|
|
private SSLEngineResult.HandshakeStatus handshakeStatus;
|
|
private boolean changeCipherSpec;
|
|
|
|
private String[] enabledSuites;
|
|
private String[] enabledProtocols;
|
|
|
|
/**
|
|
* We can receive any message chunked across multiple records,
|
|
* including alerts, even though all alert messages are only two
|
|
* bytes long. Handshake messages are de-chunked in the handshake
|
|
* handler, change-cipher-spec messages are always empty, and we
|
|
* don't care about chunking of application messages.
|
|
*
|
|
* This buffer will hold the incomplete alert that we receive, if
|
|
* any.
|
|
*/
|
|
private final ByteBuffer alertBuffer;
|
|
|
|
private Mode mode;
|
|
|
|
private enum Mode { SERVER, CLIENT };
|
|
|
|
SSLEngineImpl (SSLContextImpl contextImpl, String host, int port)
|
|
{
|
|
super(host, port);
|
|
this.contextImpl = contextImpl;
|
|
handlers = new SSLRecordHandler[256];
|
|
session = new SessionImpl();
|
|
session.suite = CipherSuite.TLS_NULL_WITH_NULL_NULL;
|
|
session.version = ProtocolVersion.TLS_1_1;
|
|
byte[] sid = new byte[32];
|
|
contextImpl.random.nextBytes(sid);
|
|
session.setId(new Session.ID(sid));
|
|
session.setRandom(contextImpl.random);
|
|
|
|
if (Debug.DEBUG)
|
|
logger.logv(Component.SSL_RECORD_LAYER, "generated session ID {0} with random {1}",
|
|
session.id(), contextImpl.random);
|
|
|
|
// Begin with no encryption.
|
|
insec = new InputSecurityParameters (null, null, null, session,
|
|
CipherSuite.TLS_NULL_WITH_NULL_NULL);
|
|
outsec = new OutputSecurityParameters (null, null, null, session,
|
|
CipherSuite.TLS_NULL_WITH_NULL_NULL);
|
|
inClosed = false;
|
|
outClosed = false;
|
|
needClientAuth = false;
|
|
wantClientAuth = false;
|
|
createSessions = true;
|
|
initialHandshakeDone = false;
|
|
alertBuffer = ByteBuffer.wrap (new byte[2]);
|
|
mode = null;
|
|
lastAlert = null;
|
|
handshakeStatus = SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING;
|
|
changeCipherSpec = false;
|
|
|
|
// Set up default protocols and suites.
|
|
enabledProtocols = new String[] {
|
|
ProtocolVersion.TLS_1_1.toString(),
|
|
ProtocolVersion.TLS_1.toString(),
|
|
ProtocolVersion.SSL_3.toString()
|
|
};
|
|
enabledSuites = defaultSuites();
|
|
}
|
|
|
|
static String[] defaultSuites()
|
|
{
|
|
return new String[] {
|
|
CipherSuite.TLS_DHE_DSS_WITH_AES_256_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DHE_RSA_WITH_AES_256_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DH_DSS_WITH_AES_256_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DH_RSA_WITH_AES_256_CBC_SHA.toString(),
|
|
CipherSuite.TLS_RSA_WITH_AES_256_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DHE_DSS_WITH_AES_128_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DHE_RSA_WITH_AES_128_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DH_DSS_WITH_AES_128_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DH_RSA_WITH_AES_128_CBC_SHA.toString(),
|
|
CipherSuite.TLS_RSA_WITH_AES_128_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA.toString(),
|
|
CipherSuite.TLS_RSA_WITH_3DES_EDE_CBC_SHA.toString(),
|
|
CipherSuite.TLS_RSA_WITH_RC4_128_MD5.toString(),
|
|
CipherSuite.TLS_RSA_WITH_RC4_128_SHA.toString(),
|
|
CipherSuite.TLS_DHE_DSS_WITH_DES_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DHE_RSA_WITH_DES_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DH_DSS_WITH_DES_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DH_RSA_WITH_DES_CBC_SHA.toString(),
|
|
CipherSuite.TLS_RSA_WITH_DES_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA.toString(),
|
|
CipherSuite.TLS_RSA_EXPORT_WITH_DES40_CBC_SHA.toString(),
|
|
CipherSuite.TLS_RSA_EXPORT_WITH_RC4_40_MD5.toString(),
|
|
CipherSuite.TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA.toString(),
|
|
CipherSuite.TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA.toString(),
|
|
CipherSuite.TLS_RSA_WITH_NULL_MD5.toString(),
|
|
CipherSuite.TLS_RSA_WITH_NULL_SHA.toString()
|
|
};
|
|
}
|
|
|
|
// XXX implement?
|
|
/*public void registerHandler (final int contentType,
|
|
SSLRecordHandler handler)
|
|
throws SSLException
|
|
{
|
|
if (type.equals (ContentType.CHANGE_CIPHER_SPEC)
|
|
|| type.equals (ContentType.ALERT)
|
|
|| type.equals (ContentType.HANDSHAKE)
|
|
|| type.equals (ContentType.APPLICATION_DATA))
|
|
throw new SSLException ("can't override handler for content type " + type);
|
|
int i = type.getValue ();
|
|
if (i < 0 || i > 255)
|
|
throw new SSLException ("illegal content type: " + type);
|
|
handlers[i] = handler;
|
|
}*/
|
|
|
|
@Override
|
|
public void beginHandshake () throws SSLException
|
|
{
|
|
if (Debug.DEBUG)
|
|
logger.log(Component.SSL_HANDSHAKE, "{0} handshake begins", mode);
|
|
|
|
if (mode == null)
|
|
throw new IllegalStateException("setUseClientMode was never used");
|
|
|
|
switch (mode)
|
|
{
|
|
case SERVER:
|
|
if (getHandshakeStatus() != SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING)
|
|
throw new SSLException("handshake already in progress");
|
|
try
|
|
{
|
|
handshake = new ServerHandshake(initialHandshakeDone, this);
|
|
}
|
|
catch (NoSuchAlgorithmException nsae)
|
|
{
|
|
throw new SSLException(nsae);
|
|
}
|
|
break;
|
|
|
|
case CLIENT:
|
|
try
|
|
{
|
|
handshake = new ClientHandshake(this);
|
|
}
|
|
catch (NoSuchAlgorithmException nsae)
|
|
{
|
|
throw new SSLException(nsae);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void closeInbound()
|
|
{
|
|
inClosed = true;
|
|
}
|
|
|
|
@Override
|
|
public void closeOutbound()
|
|
{
|
|
lastAlert = new Alert(Alert.Level.WARNING, Alert.Description.CLOSE_NOTIFY);
|
|
}
|
|
|
|
@Override
|
|
public Runnable getDelegatedTask()
|
|
{
|
|
if (handshake == null)
|
|
return null;
|
|
return handshake.getTask();
|
|
}
|
|
|
|
@Override
|
|
public String[] getEnabledCipherSuites()
|
|
{
|
|
return (String[]) enabledSuites.clone();
|
|
}
|
|
|
|
@Override
|
|
public String[] getEnabledProtocols()
|
|
{
|
|
return (String[]) enabledProtocols.clone();
|
|
}
|
|
|
|
@Override
|
|
public boolean getEnableSessionCreation()
|
|
{
|
|
return createSessions;
|
|
}
|
|
|
|
@Override
|
|
public HandshakeStatus getHandshakeStatus()
|
|
{
|
|
if (handshake == null)
|
|
return HandshakeStatus.NOT_HANDSHAKING;
|
|
return handshake.status();
|
|
}
|
|
|
|
@Override
|
|
public boolean getNeedClientAuth()
|
|
{
|
|
return needClientAuth;
|
|
}
|
|
|
|
@Override
|
|
public SSLSession getSession()
|
|
{
|
|
return session;
|
|
}
|
|
|
|
@Override
|
|
public boolean getUseClientMode ()
|
|
{
|
|
return (mode == Mode.CLIENT);
|
|
}
|
|
|
|
@Override
|
|
public boolean getWantClientAuth()
|
|
{
|
|
return wantClientAuth;
|
|
}
|
|
|
|
@Override
|
|
public boolean isInboundDone()
|
|
{
|
|
return inClosed;
|
|
}
|
|
|
|
@Override
|
|
public boolean isOutboundDone()
|
|
{
|
|
return outClosed;
|
|
}
|
|
|
|
@Override
|
|
public void setEnableSessionCreation(final boolean createSessions)
|
|
{
|
|
this.createSessions = createSessions;
|
|
}
|
|
|
|
@Override
|
|
public void setEnabledCipherSuites(final String[] suites)
|
|
{
|
|
if (suites.length == 0)
|
|
throw new IllegalArgumentException("need at least one suite");
|
|
enabledSuites = (String[]) suites.clone();
|
|
}
|
|
|
|
@Override
|
|
public void setEnabledProtocols(final String[] protocols)
|
|
{
|
|
if (protocols.length == 0)
|
|
throw new IllegalArgumentException("need at least one protocol");
|
|
enabledProtocols = (String[]) protocols.clone();
|
|
}
|
|
|
|
@Override
|
|
public String[] getSupportedCipherSuites()
|
|
{
|
|
// XXX if we ever want to support "pluggable" cipher suites, we'll need
|
|
// to figure this out.
|
|
|
|
return CipherSuite.availableSuiteNames().toArray(new String[0]);
|
|
}
|
|
|
|
@Override
|
|
public String[] getSupportedProtocols()
|
|
{
|
|
return new String[] { ProtocolVersion.SSL_3.toString(),
|
|
ProtocolVersion.TLS_1.toString(),
|
|
ProtocolVersion.TLS_1_1.toString() };
|
|
}
|
|
|
|
@Override
|
|
public void setNeedClientAuth(final boolean needClientAuth)
|
|
{
|
|
this.needClientAuth = needClientAuth;
|
|
}
|
|
|
|
@Override
|
|
public void setUseClientMode (final boolean clientMode)
|
|
{
|
|
if (clientMode)
|
|
mode = Mode.CLIENT;
|
|
else
|
|
mode = Mode.SERVER;
|
|
}
|
|
|
|
public @Override void setWantClientAuth(final boolean wantClientAuth)
|
|
{
|
|
this.wantClientAuth = wantClientAuth;
|
|
}
|
|
|
|
public @Override SSLEngineResult unwrap (final ByteBuffer source,
|
|
final ByteBuffer[] sinks,
|
|
final int offset, final int length)
|
|
throws SSLException
|
|
{
|
|
if (mode == null)
|
|
throw new IllegalStateException ("setUseClientMode was never called");
|
|
|
|
if (inClosed)
|
|
return new SSLEngineResult(SSLEngineResult.Status.CLOSED,
|
|
handshakeStatus, 0, 0);
|
|
|
|
if (source.remaining() < 5)
|
|
{
|
|
return new SSLEngineResult(SSLEngineResult.Status.BUFFER_UNDERFLOW,
|
|
handshakeStatus, 0, 0);
|
|
}
|
|
|
|
Record record = null;
|
|
boolean helloV2 = false;
|
|
|
|
// XXX: messages may be chunked across multiple records; does this
|
|
// include the SSLv2 message? I don't think it does, but we should
|
|
// make sure.
|
|
if (!getUseClientMode() && (source.get(source.position()) & 0x80) == 0x80)
|
|
{
|
|
if (handshake == null)
|
|
beginHandshake();
|
|
int hellolen = source.getShort(source.position()) & 0x7FFF;
|
|
this.handshake.handleV2Hello(source.slice());
|
|
if (!insec.cipherSuite().equals (CipherSuite.TLS_NULL_WITH_NULL_NULL))
|
|
throw new SSLException ("received SSLv2 client hello in encrypted "
|
|
+ "session; this is invalid.");
|
|
if (Debug.DEBUG)
|
|
logger.log (Component.SSL_RECORD_LAYER,
|
|
"converting SSLv2 client hello to version 3 hello");
|
|
|
|
source.getShort(); // skip length
|
|
ClientHelloV2 v2 = new ClientHelloV2(source.slice());
|
|
|
|
if (Debug.DEBUG)
|
|
logger.log(Component.SSL_RECORD_LAYER, "v2 hello: {0}", v2);
|
|
|
|
List<CipherSuite> suites = v2.cipherSpecs();
|
|
|
|
ClientHelloBuilder hello = new ClientHelloBuilder();
|
|
hello.setVersion(v2.version ());
|
|
|
|
Random random = hello.random();
|
|
byte[] challenge = v2.challenge();
|
|
if (challenge.length < 32)
|
|
{
|
|
byte[] b = new byte[32];
|
|
System.arraycopy(challenge, 0, b, b.length - challenge.length,
|
|
challenge.length);
|
|
challenge = b;
|
|
}
|
|
random.setGmtUnixTime((challenge[0] & 0xFF) << 24
|
|
| (challenge[1] & 0xFF) << 16
|
|
| (challenge[2] & 0xFF) << 8
|
|
| (challenge[3] & 0xFF));
|
|
random.setRandomBytes(challenge, 4);
|
|
|
|
byte[] sessionId = v2.sessionId();
|
|
hello.setSessionId(sessionId, 0, sessionId.length);
|
|
hello.setCipherSuites(suites);
|
|
ArrayList<CompressionMethod> comps = new ArrayList<CompressionMethod>(1);
|
|
comps.add(CompressionMethod.NULL);
|
|
hello.setCompressionMethods(comps);
|
|
|
|
record = new Record(ByteBuffer.allocate(hello.length() + 9));
|
|
record.setContentType(ContentType.HANDSHAKE);
|
|
record.setVersion(v2.version());
|
|
record.setLength(hello.length() + 4);
|
|
|
|
Handshake handshake = new Handshake(record.fragment());
|
|
handshake.setLength(hello.length());
|
|
handshake.setType(Handshake.Type.CLIENT_HELLO);
|
|
|
|
handshake.bodyBuffer().put(hello.buffer());
|
|
source.position(source.position() + hellolen);
|
|
helloV2 = true;
|
|
}
|
|
else
|
|
record = new Record(source);
|
|
|
|
ContentType type = record.contentType ();
|
|
|
|
if (Debug.DEBUG)
|
|
logger.log(Component.SSL_RECORD_LAYER, "input record:\n{0}", record);
|
|
|
|
if (record.length() > session.getPacketBufferSize() - 5)
|
|
{
|
|
lastAlert = new Alert(Alert.Level.FATAL,
|
|
Alert.Description.RECORD_OVERFLOW);
|
|
throw new AlertException(lastAlert);
|
|
}
|
|
|
|
ByteBufferOutputStream sysMsg = null;
|
|
ByteBuffer msg = null;
|
|
|
|
int produced = 0;
|
|
try
|
|
{
|
|
// Application data will get decrypted directly into the user's
|
|
// output buffers.
|
|
if (record.contentType() == ContentType.APPLICATION_DATA)
|
|
produced = insec.decrypt(record, sinks, offset, length);
|
|
else
|
|
{
|
|
if (insec.cipherSuite() == CipherSuite.TLS_NULL_WITH_NULL_NULL)
|
|
msg = record.fragment();
|
|
else
|
|
{
|
|
sysMsg = new ByteBufferOutputStream();
|
|
insec.decrypt(record, sysMsg);
|
|
}
|
|
}
|
|
|
|
// Advance the input buffer past the record we just read.
|
|
if (!helloV2)
|
|
source.position(source.position() + record.length() + 5);
|
|
}
|
|
catch (BufferOverflowException boe)
|
|
{
|
|
// We throw this if the output buffers are not large enough; signal
|
|
// the caller about this.
|
|
logger.log(Component.SSL_RECORD_LAYER, "buffer overflow when decrypting", boe);
|
|
return new SSLEngineResult(SSLEngineResult.Status.BUFFER_OVERFLOW,
|
|
handshakeStatus, 0, 0);
|
|
}
|
|
catch (IllegalBlockSizeException ibse)
|
|
{
|
|
lastAlert = new Alert(Alert.Level.FATAL,
|
|
Alert.Description.BAD_RECORD_MAC);
|
|
throw new AlertException(lastAlert, ibse);
|
|
}
|
|
catch (DataFormatException dfe)
|
|
{
|
|
lastAlert = new Alert(Alert.Level.FATAL,
|
|
Alert.Description.DECOMPRESSION_FAILURE);
|
|
throw new AlertException(lastAlert, dfe);
|
|
}
|
|
catch (MacException me)
|
|
{
|
|
lastAlert = new Alert(Alert.Level.FATAL,
|
|
Alert.Description.BAD_RECORD_MAC);
|
|
throw new AlertException(lastAlert, me);
|
|
}
|
|
catch (ShortBufferException sbe)
|
|
{
|
|
// We've messed up if this happens.
|
|
lastAlert = new Alert(Alert.Level.FATAL,
|
|
Alert.Description.INTERNAL_ERROR);
|
|
throw new AlertException(lastAlert, sbe);
|
|
}
|
|
|
|
SSLEngineResult result = null;
|
|
|
|
// If we need to handle the output here, do it. Otherwise, the output
|
|
// has been stored in the supplied output buffers.
|
|
if (sysMsg != null)
|
|
{
|
|
if (Debug.DEBUG)
|
|
logger.logv(Component.SSL_RECORD_LAYER, "sysmessage {0}", sysMsg);
|
|
msg = sysMsg.buffer();
|
|
}
|
|
|
|
if (type == ContentType.CHANGE_CIPHER_SPEC)
|
|
{
|
|
// We *may* get a partial message, even though the message is only
|
|
// one byte long.
|
|
if (msg.remaining() == 0)
|
|
{
|
|
result = new SSLEngineResult (SSLEngineResult.Status.OK,
|
|
handshakeStatus,
|
|
record.length() + 5, 0);
|
|
}
|
|
else
|
|
{
|
|
byte b = msg.get();
|
|
if (b != 1)
|
|
throw new SSLException ("unknown ChangeCipherSpec value: " + (b & 0xFF));
|
|
InputSecurityParameters params = handshake.getInputParams();
|
|
logger.log (Component.SSL_RECORD_LAYER,
|
|
"switching to input security parameters {0}",
|
|
params.cipherSuite());
|
|
insec = params;
|
|
result = new SSLEngineResult (SSLEngineResult.Status.OK,
|
|
handshakeStatus,
|
|
record.length() + 5, 0);
|
|
}
|
|
}
|
|
else if (type == ContentType.ALERT)
|
|
{
|
|
int len = 0;
|
|
if (alertBuffer.position() > 0)
|
|
{
|
|
alertBuffer.put(msg.get());
|
|
len = 1;
|
|
}
|
|
if (Debug.DEBUG)
|
|
logger.logv(Component.SSL_RECORD_LAYER, "processing alerts {0}",
|
|
Util.wrapBuffer(msg));
|
|
len += msg.remaining() / 2;
|
|
Alert[] alerts = new Alert[len];
|
|
int i = 0;
|
|
if (alertBuffer.position() > 0)
|
|
{
|
|
alertBuffer.flip();
|
|
alerts[0] = new Alert(alertBuffer);
|
|
i++;
|
|
}
|
|
while (i < alerts.length)
|
|
{
|
|
alerts[i++] = new Alert(msg.duplicate());
|
|
msg.position(msg.position() + 2);
|
|
}
|
|
if (Debug.DEBUG)
|
|
logger.logv(Component.SSL_RECORD_LAYER, "alerts: {0}", alerts.length);
|
|
|
|
for (i = 0; i < alerts.length; i++)
|
|
{
|
|
if (alerts[i].level() == Alert.Level.FATAL)
|
|
throw new AlertException(alerts[i], false);
|
|
if (alerts[i].description() != Alert.Description.CLOSE_NOTIFY)
|
|
logger.log(java.util.logging.Level.WARNING,
|
|
"received alert: {0}", alerts[i]);
|
|
if (alerts[i].description() == Alert.Description.CLOSE_NOTIFY)
|
|
inClosed = true;
|
|
}
|
|
|
|
if (msg.hasRemaining())
|
|
alertBuffer.position(0).limit(2);
|
|
|
|
result = new SSLEngineResult (SSLEngineResult.Status.OK,
|
|
handshakeStatus,
|
|
record.length() + 5, 0);
|
|
}
|
|
else if (type == ContentType.HANDSHAKE)
|
|
{
|
|
if (handshake == null)
|
|
beginHandshake();
|
|
try
|
|
{
|
|
handshakeStatus = handshake.handleInput(msg);
|
|
}
|
|
catch (AlertException ae)
|
|
{
|
|
lastAlert = ae.alert();
|
|
return new SSLEngineResult(SSLEngineResult.Status.OK,
|
|
SSLEngineResult.HandshakeStatus.NEED_WRAP,
|
|
0, 0);
|
|
}
|
|
if (Debug.DEBUG)
|
|
logger.logv(Component.SSL_HANDSHAKE, "handshake status {0}", handshakeStatus);
|
|
result = new SSLEngineResult(SSLEngineResult.Status.OK,
|
|
handshakeStatus,
|
|
record.length() + 5,
|
|
0);
|
|
if (handshakeStatus == HandshakeStatus.FINISHED)
|
|
{
|
|
handshake = null;
|
|
handshakeStatus = HandshakeStatus.NOT_HANDSHAKING;
|
|
}
|
|
}
|
|
else if (type == ContentType.APPLICATION_DATA)
|
|
{
|
|
// Do nothing more; the application data has been put into
|
|
// the output buffers.
|
|
result = new SSLEngineResult(SSLEngineResult.Status.OK,
|
|
handshakeStatus,
|
|
record.length() + 5,
|
|
produced);
|
|
}
|
|
else
|
|
{
|
|
SSLRecordHandler handler = handlers[type.getValue()];
|
|
if (handler != null)
|
|
{
|
|
result = new SSLEngineResult(SSLEngineResult.Status.OK,
|
|
handshakeStatus,
|
|
record.length() + 5,
|
|
0);
|
|
}
|
|
else
|
|
throw new SSLException ("unknown content type: " + type);
|
|
}
|
|
|
|
if (Debug.DEBUG)
|
|
logger.logv(Component.SSL_RECORD_LAYER, "return result: {0}", result);
|
|
|
|
return result;
|
|
}
|
|
|
|
public @Override SSLEngineResult wrap (ByteBuffer[] sources, int offset, int length,
|
|
ByteBuffer sink)
|
|
throws SSLException
|
|
{
|
|
if (mode == null)
|
|
throw new IllegalStateException ("setUseClientMode was never called");
|
|
|
|
if (outClosed)
|
|
return new SSLEngineResult(SSLEngineResult.Status.CLOSED,
|
|
handshakeStatus, 0, 0);
|
|
|
|
ContentType type = null;
|
|
ByteBuffer sysMessage = null;
|
|
if (Debug.DEBUG)
|
|
logger.logv(Component.SSL_RECORD_LAYER, "wrap {0} {1} {2} {3} / {4}",
|
|
sources, offset, length, sink, getHandshakeStatus());
|
|
if (lastAlert != null)
|
|
{
|
|
type = ContentType.ALERT;
|
|
sysMessage = ByteBuffer.allocate(2);
|
|
Alert alert = new Alert(sysMessage);
|
|
alert.setDescription(lastAlert.description());
|
|
alert.setLevel(lastAlert.level());
|
|
if (lastAlert.description() == Alert.Description.CLOSE_NOTIFY)
|
|
outClosed = true;
|
|
}
|
|
else if (changeCipherSpec)
|
|
{
|
|
type = ContentType.CHANGE_CIPHER_SPEC;
|
|
sysMessage = ByteBuffer.allocate(1);
|
|
sysMessage.put(0, (byte) 1);
|
|
}
|
|
else if (getHandshakeStatus() == SSLEngineResult.HandshakeStatus.NEED_WRAP)
|
|
{
|
|
// If we are not encrypting, optimize the handshake to fill
|
|
// the buffer directly.
|
|
if (outsec.suite() == CipherSuite.TLS_NULL_WITH_NULL_NULL)
|
|
{
|
|
int orig = sink.position();
|
|
sink.order(ByteOrder.BIG_ENDIAN);
|
|
sink.put((byte) ContentType.HANDSHAKE.getValue());
|
|
sink.putShort((short) session.version.rawValue());
|
|
sink.putShort((short) 0);
|
|
handshakeStatus = handshake.handleOutput(sink);
|
|
int produced = sink.position() - orig;
|
|
sink.putShort(orig + 3, (short) (produced - 5));
|
|
if (Debug.DEBUG)
|
|
logger.logv(Component.SSL_RECORD_LAYER, "emitting record:\n{0}",
|
|
new Record((ByteBuffer) sink.duplicate().position(orig)));
|
|
SSLEngineResult result = new SSLEngineResult(SSLEngineResult.Status.OK,
|
|
handshakeStatus, 0, produced);
|
|
|
|
// Note, this will only happen if we transition from
|
|
// TLS_NULL_WITH_NULL_NULL *to* TLS_NULL_WITH_NULL_NULL, which
|
|
// doesn't make a lot of sense, but we support it anyway.
|
|
if (handshakeStatus == HandshakeStatus.FINISHED)
|
|
{
|
|
handshake = null; // finished with it.
|
|
handshakeStatus = HandshakeStatus.NOT_HANDSHAKING;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Rough guideline; XXX.
|
|
sysMessage = ByteBuffer.allocate(sink.remaining() - 2048);
|
|
type = ContentType.HANDSHAKE;
|
|
try
|
|
{
|
|
handshakeStatus = handshake.handleOutput(sysMessage);
|
|
}
|
|
catch (AlertException ae)
|
|
{
|
|
lastAlert = ae.alert();
|
|
return new SSLEngineResult(Status.OK,
|
|
HandshakeStatus.NEED_WRAP, 0, 0);
|
|
}
|
|
sysMessage.flip();
|
|
if (Debug.DEBUG)
|
|
logger.logv(Component.SSL_HANDSHAKE, "handshake status {0}",
|
|
handshakeStatus);
|
|
}
|
|
|
|
int produced = 0;
|
|
int consumed = 0;
|
|
|
|
try
|
|
{
|
|
int orig = sink.position();
|
|
int[] inout = null;
|
|
if (sysMessage != null)
|
|
{
|
|
if (Debug.DEBUG)
|
|
logger.logv(Component.SSL_RECORD_LAYER, "encrypt system message {0} to {1}", sysMessage, sink);
|
|
inout = outsec.encrypt(new ByteBuffer[] { sysMessage }, 0, 1,
|
|
type, sink);
|
|
produced = inout[1];
|
|
}
|
|
else
|
|
{
|
|
inout = outsec.encrypt(sources, offset, length,
|
|
ContentType.APPLICATION_DATA, sink);
|
|
consumed = inout[0];
|
|
produced = inout[1];
|
|
}
|
|
|
|
if (Debug.DEBUG)
|
|
logger.logv(Component.SSL_RECORD_LAYER, "emitting record:\n{0}",
|
|
new Record((ByteBuffer) sink.duplicate().position(orig).limit(produced)));
|
|
}
|
|
catch (ShortBufferException sbe)
|
|
{
|
|
// We don't expect this to happen, except for bugs; signal an
|
|
// internal error.
|
|
lastAlert = new Alert(Alert.Level.FATAL, Alert.Description.INTERNAL_ERROR);
|
|
return new SSLEngineResult(SSLEngineResult.Status.OK, handshakeStatus, 0, 0);
|
|
}
|
|
catch (IllegalBlockSizeException ibse)
|
|
{
|
|
// We don't expect this to happen, except for bugs; signal an
|
|
// internal error.
|
|
lastAlert = new Alert(Alert.Level.FATAL, Alert.Description.INTERNAL_ERROR);
|
|
return new SSLEngineResult(SSLEngineResult.Status.OK, handshakeStatus, 0, 0);
|
|
}
|
|
catch (DataFormatException dfe)
|
|
{
|
|
// We don't expect this to happen; signal an internal error.
|
|
lastAlert = new Alert(Alert.Level.FATAL, Alert.Description.INTERNAL_ERROR);
|
|
return new SSLEngineResult(SSLEngineResult.Status.OK, handshakeStatus, 0, 0);
|
|
}
|
|
|
|
if (lastAlert != null && lastAlert.level() == Alert.Level.FATAL)
|
|
{
|
|
AlertException ae = new AlertException(lastAlert);
|
|
lastAlert = null;
|
|
throw ae;
|
|
}
|
|
|
|
if (changeCipherSpec)
|
|
{
|
|
outsec = handshake.getOutputParams();
|
|
changeCipherSpec = false;
|
|
}
|
|
SSLEngineResult result
|
|
= new SSLEngineResult(outClosed ? SSLEngineResult.Status.CLOSED
|
|
: SSLEngineResult.Status.OK,
|
|
handshakeStatus, consumed, produced);
|
|
if (handshakeStatus == HandshakeStatus.FINISHED)
|
|
{
|
|
handshake = null; // done with it.
|
|
handshakeStatus = HandshakeStatus.NOT_HANDSHAKING;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Package-private methods.
|
|
|
|
SessionImpl session ()
|
|
{
|
|
return session;
|
|
}
|
|
|
|
void setSession(SessionImpl session)
|
|
{
|
|
this.session = session;
|
|
}
|
|
|
|
void changeCipherSpec()
|
|
{
|
|
changeCipherSpec = true;
|
|
}
|
|
} |