/*

 * Copyright (c) 2015, 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.util.Collections;

import java.util.List;

import java.util.LinkedList;

import java.util.HashMap;

import javax.net.ssl.SSLProtocolException;

import static sun.security.ssl.CipherSuite.KeyExchange;

import static sun.security.ssl.CipherSuite.KeyExchange.*;

import static sun.security.ssl.HandshakeStateManager.HandshakeState.*;

import static sun.security.ssl.HandshakeMessage.*;

/*

 * Handshake state manager.

 *

 * Messages flow for a full handshake:

 *

 *      -                                                         -

 *      |          HelloRequest       (No.0, RFC 5246) [*]        |

 *      |     <--------------------------------------------       |

 *      |                                                         |

 *      |          ClientHello        (No.1, RFC 5246)            |

 *      |     -------------------------------------------->       |

 *      |                                                         |

 *      |   -      HelloVerifyRequest (No.3, RFC 6347)      -     |

 *      | D | <-------------------------------------------- | D   |

 *      | T |                                               | T   |

 *      | L |      ClientHello        (No.1, RFC 5246)      | L   |

 *      | S | --------------------------------------------> | S   |

 *      |   -                                               -     |

 *      |                                                         |

 *   C  |          ServerHello        (No.2, RFC 5246)            |  S

 *   L  |          SupplementalData   (No.23, RFC4680) [*]        |  E

 *   I  |          Certificate        (No.11, RFC 5246) [*]       |  R

 *   E  |          CertificateStatus  (No.22, RFC 6066) [*]       |  V

 *   N  |          ServerKeyExchange  (No.12, RFC 5246) [*]       |  E

 *   T  |          CertificateRequest (No.13, RFC 5246) [*]       |  R

 *      |          ServerHelloDone    (No.14, RFC 5246)           |

 *      |     <--------------------------------------------       |

 *      |                                                         |

 *      |          SupplementalData   (No.23, RFC4680) [*]        |

 *      |          Certificate        (No.11, RFC 5246) [*] Or    |

 *      |              CertificateURL (No.21, RFC6066) [*]        |

 *      |          ClientKeyExchange  (No.16, RFC 5246)           |

 *      |          CertificateVerify  (No.15, RFC 5246) [*]       |

 *      |          [ChangeCipherSpec] (RFC 5246)                  |

 *      |          Finished           (No.20, RFC 5246)           |

 *      |     -------------------------------------------->       |

 *      |                                                         |

 *      |          NewSessionTicket   (No.4, RFC4507) [*]         |

 *      |          [ChangeCipherSpec] (RFC 5246)                  |

 *      |          Finished           (No.20, RFC 5246)           |

 *      |     <--------------------------------------------       |

 *      -                                                         -

 * [*] Indicates optional or situation-dependent messages that are not

 * always sent.

 *

 * Message flow for an abbreviated handshake:

 *      -                                                         -

 *      |          ClientHello        (No.1, RFC 5246)            |

 *      |     -------------------------------------------->       |

 *      |                                                         |

 *   C  |          ServerHello        (No.2, RFC 5246)            |  S

 *   L  |          NewSessionTicket   (No.4, RFC4507) [*]         |  E

 *   I  |          [ChangeCipherSpec] (RFC 5246)                  |  R

 *   E  |          Finished           (No.20, RFC 5246)           |  V

 *   N  |     <--------------------------------------------       |  E

 *   T  |                                                         |  R

 *      |          [ChangeCipherSpec] (RFC 5246)                  |

 *      |          Finished           (No.20, RFC 5246)           |

 *      |     -------------------------------------------->       |

 *      -                                                         -

 *

 *

 * State machine of handshake states:

 *

 *                   +--------------+

 *      START -----> | HelloRequest |

 *        |          +--------------+

 *        |               |

 *        v               v

 *     +---------------------+   -->  +---------------------+

 *     |    ClientHello      |        | HelloVerifyRequest  |

 *     +---------------------+   <--  +---------------------+

 *               |

 *               |

 * =========================================================================

 *               |

 *               v

 *     +---------------------+

 *     |    ServerHello      |  ----------------------------------+------+

 *     +---------------------+  -->  +-------------------------+  |      |

 *                    |              | Server SupplementalData |  |      |

 *                    |              +-------------------------+  |      |

 *                    |                |                          |      |

 *                    v                v                          |      |

 *                +---------------------+                         |      |

 *         +----  | Server Certificate  |                         |      |

 *         |      +---------------------+                         |      |

 *         |          |                                           |      |

 *         |          |   +--------------------+                  |      |

 *         |          +-> | CertificateStatus  |                  |      |

 *         |          |   +--------------------+                  v      |

 *         |          |      |          |     +--------------------+     |

 *         |          v      v          +-->  | ServerKeyExchange  |     |

 *         |  +---------------------+   |     +--------------------+     |

 *         |  | CertificateRequest  |   |         |                      |

 *         |  +---------------------+ <-+---------+                      |

 *         |            |               |         |                      |

 *         v            v               |         |                      |

 *     +---------------------+  <-------+         |                      |

 *     |  ServerHelloDone    |  <-----------------+                      |

 *     +---------------------+                                           |

 *       |         |                                                     |

 *       |         |                                                     |

 *       |         |                                                     |

 * =========================================================================

 *       |         |                                                     |

 *       |         v                                                     |

 *       |   +-------------------------+                                 |

 *       |   | Client SupplementalData | --------------+                 |

 *       |   +-------------------------+               |                 |

 *       |             |                               |                 |

 *       |             v                               |                 |

 *       |   +--------------------+                    |                 |

 *       +-> | Client Certificate | ALT.               |                 |

 *       |   +--------------------+----------------+   |                 |

 *       |                        | CertificateURL |   |                 |

 *       |                        +----------------+   |                 |

 *       v                                             |                 |

 *     +-------------------+  <------------------------+                 |

 *     | ClientKeyExchange |                                             |

 *     +-------------------+                                             |

 *          |           |                                                |

 *          |           v                                                |

 *          |      +-------------------+                                 |

 *          |      | CertificateVerify |                                 |

 *          |      +-------------------+                                 |

 *          |          |                                                 |

 *          v          v                                                 |

 *     +-------------------------+                                       |

 *     | Client ChangeCipherSpec |  <---------------+                    |

 *     +-------------------------+                  |                    |

 *               |                                  |                    |

 *               v                                  |                    |

 *     +-----------------+  (abbreviated)           |                    |

 *     | Client Finished |  -------------> END      |                    |

 *     +-----------------+  (Abbreviated handshake) |                    |

 *                      |                           |                    |

 *                      | (full)                    |                    |

 *                      |                           |                    |

 * ================================                 |                    |

 *                      |                           |                    |

 *                      |                   ================================

 *                      |                           |                    |

 *                      v                           |                    |

 *                 +------------------+             |    (abbreviated)   |

 *                 | NewSessionTicket | <--------------------------------+

 *                 +------------------+             |                    |

 *                      |                           |                    |

 *                      v                           |                    |

 *     +-------------------------+                  |    (abbreviated)   |

 *     | Server ChangeCipherSpec | <-------------------------------------+

 *     +-------------------------+                  |

 *               |                                  |

 *               v                                  |

 *     +-----------------+    (abbreviated)         |

 *     | Server Finished | -------------------------+

 *     +-----------------+

 *            | (full)

 *            v

 *        END (Full handshake)

 *

 *

 * The scenarios of the use of this class:

 * 1. Create an instance of HandshakeStateManager during the initializtion

 *    handshake.

 * 2. If receiving a handshake message, call HandshakeStateManager.check()

 *    to make sure that the message is of the expected handshake type.  And

 *    then call HandshakeStateManager.update() in case handshake states may

 *    be impacted by this new incoming handshake message.

 * 3. On delivering a handshake message, call HandshakeStateManager.update()

 *    in case handshake states may by thie new outgoing handshake message.

 * 4. On receiving and delivering ChangeCipherSpec message, call

 *    HandshakeStateManager.changeCipherSpec() to check the present sequence

 *    of this message, and update the states if necessary.

 */

final class HandshakeStateManager {

    // upcoming handshake states.

    private LinkedList<HandshakeState> upcomingStates;

    private LinkedList<HandshakeState> alternatives;

    private boolean isDTLS;

    static {

        debugIsOn = (Handshaker.debug != null) &&

                Debug.isOn("handshake") && Debug.isOn("verbose");

        handshakeTypes = new HashMap<>(15);

        handshakeTypes.put(ht_hello_request,            "hello_request");

        handshakeTypes.put(ht_client_hello,             "client_hello");

        handshakeTypes.put(ht_server_hello,             "server_hello");

        handshakeTypes.put(ht_hello_verify_request,     "hello_verify_request");

        handshakeTypes.put(ht_new_session_ticket,       "session_ticket");

        handshakeTypes.put(ht_certificate,              "certificate");

        handshakeTypes.put(ht_server_key_exchange,      "server_key_exchange");

        handshakeTypes.put(ht_certificate_request,      "certificate_request");

        handshakeTypes.put(ht_server_hello_done,        "server_hello_done");

        handshakeTypes.put(ht_certificate_verify,       "certificate_verify");

        handshakeTypes.put(ht_client_key_exchange,      "client_key_exchange");

        handshakeTypes.put(ht_finished,                 "finished");

        handshakeTypes.put(ht_certificate_url,          "certificate_url");

        handshakeTypes.put(ht_certificate_status,       "certificate_status");

        handshakeTypes.put(ht_supplemental_data,        "supplemental_data");

    }

    HandshakeStateManager(boolean isDTLS) {

        this.upcomingStates = new LinkedList<>();

        this.alternatives = new LinkedList<>();

        this.isDTLS = isDTLS;

    }

    //

    // enumation of handshake type

    //

    static enum HandshakeState {

        HS_HELLO_REQUEST(

                "hello_request",

                HandshakeMessage.ht_hello_request),

        HS_CLIENT_HELLO(

                "client_hello",

                HandshakeMessage.ht_client_hello),

        HS_HELLO_VERIFY_REQUEST(

                "hello_verify_request",

                HandshakeMessage.ht_hello_verify_request),

        HS_SERVER_HELLO(

                "server_hello",

                HandshakeMessage.ht_server_hello),

        HS_SERVER_SUPPLEMENTAL_DATA(

                "server supplemental_data",

                HandshakeMessage.ht_supplemental_data, true),

        HS_SERVER_CERTIFICATE(

                "server certificate",

                HandshakeMessage.ht_certificate),

        HS_CERTIFICATE_STATUS(

                "certificate_status",

                HandshakeMessage.ht_certificate_status, true),

        HS_SERVER_KEY_EXCHANGE(

                "server_key_exchange",

                HandshakeMessage.ht_server_key_exchange, true),

        HS_CERTIFICATE_REQUEST(

                "certificate_request",

                HandshakeMessage.ht_certificate_request, true),

        HS_SERVER_HELLO_DONE(

                "server_hello_done",

                HandshakeMessage.ht_server_hello_done),

        HS_CLIENT_SUPPLEMENTAL_DATA(

                "client supplemental_data",

                HandshakeMessage.ht_supplemental_data, true),

        HS_CLIENT_CERTIFICATE(

                "client certificate",

                HandshakeMessage.ht_certificate, true),

        HS_CERTIFICATE_URL(

                "certificate_url",

                HandshakeMessage.ht_certificate_url, true),

        HS_CLIENT_KEY_EXCHANGE(

                "client_key_exchange",

                HandshakeMessage.ht_client_key_exchange),

        HS_CERTIFICATE_VERIFY(

                "certificate_verify",

                HandshakeMessage.ht_certificate_verify, true),

        HS_CLIENT_CHANGE_CIPHER_SPEC(

                "client change_cipher_spec",

                HandshakeMessage.ht_not_applicable),

        HS_CLEINT_FINISHED(

                "client finished",

                HandshakeMessage.ht_finished),

        HS_NEW_SESSION_TICKET(

                "session_ticket",

                HandshakeMessage.ht_new_session_ticket),

        HS_SERVER_CHANGE_CIPHER_SPEC(

                "server change_cipher_spec",

                HandshakeMessage.ht_not_applicable),

        HS_SERVER_FINISHED(

                "server finished",

                HandshakeMessage.ht_finished);

        final String description;

        final byte handshakeType;

        final boolean isOptional;

        HandshakeState(String description, byte handshakeType) {

            this.description = description;

            this.handshakeType = handshakeType;

            this.isOptional = false;

        }

        HandshakeState(String description,

                byte handshakeType, boolean isOptional) {

            this.description = description;

            this.handshakeType = handshakeType;

            this.isOptional = isOptional;

        }

        public String toString() {

            return description + "[" + handshakeType + "]" +

                    (isOptional ? "(optional)" : "");

        }

    }

    boolean isEmpty() {

        return upcomingStates.isEmpty();

    }

    List<Byte> check(byte handshakeType) throws SSLProtocolException {

        List<Byte> ignoredOptional = new LinkedList<>();

        String exceptionMsg =

                 "Handshake message sequence violation, " + handshakeType;

        if (debugIsOn) {

            System.out.println(

                    "check handshake state: " + toString(handshakeType));

        }

        if (upcomingStates.isEmpty()) {

            // Is it a kickstart message?

            if ((handshakeType != HandshakeMessage.ht_hello_request) &&

                (handshakeType != HandshakeMessage.ht_client_hello)) {

                throw new SSLProtocolException(

                    "Handshake message sequence violation, " + handshakeType);

            }

            // It is a kickstart message.

            return Collections.emptyList();

        }

        // Ignore the checking for HelloRequest messages as they

        // may be sent by the server at any time.

        if (handshakeType == HandshakeMessage.ht_hello_request) {

            return Collections.emptyList();

        }

        for (HandshakeState handshakeState : upcomingStates) {

            if (handshakeState.handshakeType == handshakeType) {

                // It's the expected next handshake type.

                return ignoredOptional;

            }

            if (handshakeState.isOptional) {

                ignoredOptional.add(handshakeState.handshakeType);

                continue;

            } else {

                for (HandshakeState alternative : alternatives) {

                    if (alternative.handshakeType == handshakeType) {

                        return ignoredOptional;

                    }

                    if (alternative.isOptional) {

                        continue;

                    } else {

                        throw new SSLProtocolException(exceptionMsg);

                    }

                }

            }

            throw new SSLProtocolException(exceptionMsg);

        }

        // Not an expected Handshake message.

        throw new SSLProtocolException(

                "Handshake message sequence violation, " + handshakeType);

    }

    void update(HandshakeMessage handshakeMessage,

            boolean isAbbreviated) throws SSLProtocolException {

        byte handshakeType = (byte)handshakeMessage.messageType();

        String exceptionMsg =

                 "Handshake message sequence violation, " + handshakeType;

        if (debugIsOn) {

            System.out.println(

                    "update handshake state: " + toString(handshakeType));

        }

        boolean hasPresentState = false;

        switch (handshakeType) {

        case HandshakeMessage.ht_hello_request:

            //

            // State machine:

            //     PRESENT: START

            //        TO  : ClientHello

            //

            // No old state to update.

            // Add the upcoming states.

            if (!upcomingStates.isEmpty()) {

                // A ClientHello message should be followed.

                upcomingStates.add(HS_CLIENT_HELLO);

            }   // Otherwise, ignore this HelloRequest message.

            break;

        case HandshakeMessage.ht_client_hello:

            //

            // State machine:

            //     PRESENT: START

            //              HS_CLIENT_HELLO

            //        TO  : HS_HELLO_VERIFY_REQUEST (DTLS)

            //              HS_SERVER_HELLO

            //

            // Check and update the present state.

            if (!upcomingStates.isEmpty()) {

                // The current state should be HS_CLIENT_HELLO.

                HandshakeState handshakeState = upcomingStates.pop();

                if (handshakeState != HS_CLIENT_HELLO) {

                    throw new SSLProtocolException(exceptionMsg);

                }

            }

            // Add the upcoming states.

            ClientHello clientHello = (ClientHello)handshakeMessage;

            if (isDTLS) {

                // Is it an initial ClientHello message?

                if (clientHello.cookie == null ||

                        clientHello.cookie.length == 0) {

                    // Is it an abbreviated handshake?

                    if (clientHello.sessionId.length() != 0) {

                        // A HelloVerifyRequest message or a ServerHello

                        // message may follow the abbreviated session

                        // resuming handshake request.

                        upcomingStates.add(HS_HELLO_VERIFY_REQUEST);

                        alternatives.add(HS_SERVER_HELLO);

                    } else {

                        // A HelloVerifyRequest message should follow

                        // the initial ClientHello message.

                        upcomingStates.add(HS_HELLO_VERIFY_REQUEST);

                    }

                } else {

                    // A HelloVerifyRequest may be followed if the cookie

                    // cannot be verified.

                    upcomingStates.add(HS_SERVER_HELLO);

                    alternatives.add(HS_HELLO_VERIFY_REQUEST);

                }

            } else {

                upcomingStates.add(HS_SERVER_HELLO);

            }

            break;

        case HandshakeMessage.ht_hello_verify_request:

            //

            // State machine:

            //     PRESENT: HS_HELLO_VERIFY_REQUEST

            //        TO  : HS_CLIENT_HELLO

            //

            // Note that this state may have an alternative option.

            // Check and update the present state.

            if (!upcomingStates.isEmpty()) {

                // The current state should be HS_HELLO_VERIFY_REQUEST.

                HandshakeState handshakeState = upcomingStates.pop();

                HandshakeState alternative = null;

                if (!alternatives.isEmpty()) {

                    alternative = alternatives.pop();

                }

                if ((handshakeState != HS_HELLO_VERIFY_REQUEST) &&

                        (alternative != HS_HELLO_VERIFY_REQUEST)) {

                    throw new SSLProtocolException(exceptionMsg);

                }

            } else {

                // No present state.

                throw new SSLProtocolException(exceptionMsg);

            }

            // Add the upcoming states.

            upcomingStates.add(HS_CLIENT_HELLO);

            break;

        case HandshakeMessage.ht_server_hello:

            //

            // State machine:

            //     PRESENT: HS_SERVER_HELLO

            //        TO  :

            //          Full handshake state stacks

            //              (ServerHello Flight)

            //              HS_SERVER_SUPPLEMENTAL_DATA [optional]

            //          --> HS_SERVER_CERTIFICATE [optional]