Class AbstractHandshake

protected static final byte[] CLIENT_FINISHED

"client finished" -- TLS 1.0 and later

protected static final byte[] PAD1

SSL 3.0; the value 0x36 40 (for SHA-1 hashes) or 48 (for MD5 hashes) times.

protected static final byte[] PAD2

SSL 3.0; the value 0x5c 40 (for SHA-1 hashes) or 48 (for MD5 hashes) times.

protected static final byte[] SERVER_FINISHED

"server finished" -- TLS 1.0 and later

protected Random clientRandom

protected CompressionMethod compression

protected final SSLEngineImpl engine

protected ByteBuffer handshakeBuffer

The currently-read handshake messages. There may be zero, or multiple, handshake messages in this buffer.

protected int handshakeOffset

The offset into `handshakeBuffer' where the first unread handshake message resides.

protected InputSecurityParameters inParams

protected KeyAgreement keyAgreement

protected static final SystemLogger logger

protected MessageDigest md5

protected OutputSecurityParameters outParams

protected byte[] preMasterSecret

protected Random serverRandom

protected MessageDigest sha

protected LinkedList tasks

protected AbstractHandshake(SSLEngineImpl engine)
            throws NoSuchAlgorithmException

protected boolean doHash()

protected byte[] genV3CertificateVerify(MessageDigest md5,
                                        MessageDigest sha,
                                        SessionImpl session)

Generate a certificate verify message for SSLv3. In SSLv3, a different algorithm was used to generate this value was subtly different than that used in TLSv1.0 and later. In TLSv1.0 and later, this value is just the digest over the handshake messages.

SSLv3 uses the algorithm:

CertificateVerify.signature.md5_hash
MD5(master_secret + pad_2 +
MD5(handshake_messages + master_secret + pad_1));
Certificate.signature.sha_hash
SHA(master_secret + pad_2 +
SHA(handshake_messages + master_secret + pad_1));

Parameters:

md5 - The running MD5 hash of the handshake.

sha - The running SHA-1 hash of the handshake.

session - The current session being negotiated.

Returns:

The computed to-be-signed value.

protected ByteBuffer generateFinished(MessageDigest md5,
                                      MessageDigest sha,
                                      boolean isClient,
                                      SessionImpl session)

Generate a "finished" message. The hashes passed in are modified by this function, so they should be clone copies of the digest if the hash function needs to be used more.

Parameters:

md5 - The MD5 computation.

sha - The SHA-1 computation.

isClient - Whether or not the client-side finished message is being computed.

session - The current session.

Returns:

A byte buffer containing the computed finished message.

protected byte[][] generateKeys(Random clientRandom,
                                Random serverRandom,
                                SessionImpl session)

Generate the session keys from the computed master secret.

Parameters:

clientRandom - The client's nonce.

serverRandom - The server's nonce.

session - The session being established.

Returns:

The derived keys.

protected void generateMasterSecret(Random clientRandom,
                                    Random serverRandom,
                                    SessionImpl session)
            throws SSLException

protected void generatePSKSecret(String identity,
                                 byte[] otherkey,
                                 boolean isClient)
            throws SSLException

public final SSLEngineResult.HandshakeStatus handleInput(ByteBuffer fragment)
            throws SSLException

Handles the next input message in the handshake. This is called in response to a call to javax.net.ssl.SSLEngine.unwrap for a message with content-type HANDSHAKE.

Parameters:

Returns:

An SSLEngineResult describing the result.

public final SSLEngineResult.HandshakeStatus handleOutput(ByteBuffer fragment)
            throws SSLException

Produce more handshake output. This is called in response to a call to javax.net.ssl.SSLEngine.wrap, when the handshake is still in progress.

Parameters:

Returns:

An SSLEngineResult describing the result.

protected boolean hasMessage()

Tell if the handshake buffer currently has a full handshake message.

protected abstract SSLEngineResult.HandshakeStatus implHandleInput()
            throws SSLException

Called to process more handshake data. This method will be called repeatedly while there is remaining handshake data, and while the status is

Returns:

Throws:

SSLException -

protected abstract SSLEngineResult.HandshakeStatus implHandleOutput(ByteBuffer fragment)
            throws SSLException

Called to implement the underlying output handling. The callee should attempt to fill the given buffer as much as it can; this can include multiple, and even partial, handshake messages.

Parameters:

fragment - The buffer the callee should write handshake messages to.

Returns:

The new status of the handshake.

Throws:

SSLException - If an error occurs processing the output message.

protected void initDiffieHellman(DHPrivateKey dhKey,
                                 SecureRandom random)
            throws SSLException

protected boolean pollHandshake(ByteBuffer fragment)

Attempt to read the next handshake message from the given record. If only a partial handshake message is available, then this method saves the incoming bytes and returns false. If a complete handshake is read, or if there was one buffered in the handshake buffer, this method returns true, and `handshakeBuffer' can be used to read the handshake.

Parameters:

Returns:

True if a complete handshake is present in the buffer; false if only a partial one.

protected void setupSecurityParameters(byte[][] keys,
                                       boolean isClient,
                                       SSLEngineImpl engine,
                                       CompressionMethod compression)
            throws SSLException