| /* 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; | |
| } | |
| } |