/*

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

import java.nio.ByteBuffer;

import java.security.AccessController;

import java.security.AlgorithmConstraints;

import java.security.AlgorithmParameters;

import java.security.CryptoPrimitive;

import java.security.GeneralSecurityException;

import java.security.NoSuchAlgorithmException;

import java.security.SecureRandom;

import java.security.spec.AlgorithmParameterSpec;

import java.security.spec.ECGenParameterSpec;

import java.security.spec.ECParameterSpec;

import java.security.spec.InvalidParameterSpecException;

import java.security.spec.NamedParameterSpec;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.EnumSet;

import java.util.concurrent.ConcurrentHashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Optional;

import javax.crypto.spec.DHParameterSpec;

import javax.net.ssl.SSLProtocolException;

import sun.security.action.GetPropertyAction;

import static sun.security.ssl.SSLExtension.CH_SUPPORTED_GROUPS;

import static sun.security.ssl.SSLExtension.EE_SUPPORTED_GROUPS;

import sun.security.ssl.SSLExtension.ExtensionConsumer;

import sun.security.ssl.SSLExtension.SSLExtensionSpec;

import sun.security.ssl.SSLHandshake.HandshakeMessage;

/**

 * Pack of the "supported_groups" extensions [RFC 4492/7919].

 */

final class SupportedGroupsExtension {

    static final HandshakeProducer chNetworkProducer =

            new CHSupportedGroupsProducer();

    static final ExtensionConsumer chOnLoadConsumer =

            new CHSupportedGroupsConsumer();

    static final SSLStringizer sgsStringizer =

            new SupportedGroupsStringizer();

    static final HandshakeProducer eeNetworkProducer =

            new EESupportedGroupsProducer();

    static final ExtensionConsumer eeOnLoadConsumer =

            new EESupportedGroupsConsumer();

    /**

     * The "supported_groups" extension.

     */

    static final class SupportedGroupsSpec implements SSLExtensionSpec {

        final int[] namedGroupsIds;

        private SupportedGroupsSpec(int[] namedGroupsIds) {

            this.namedGroupsIds = namedGroupsIds;

        }

        private SupportedGroupsSpec(List<NamedGroup> namedGroups) {

            this.namedGroupsIds = new int[namedGroups.size()];

            int i = 0;

            for (NamedGroup ng : namedGroups) {

                namedGroupsIds[i++] = ng.id;

            }

        }

        private SupportedGroupsSpec(ByteBuffer m) throws IOException  {

            if (m.remaining() < 2) {      // 2: the length of the list

                throw new SSLProtocolException(

                    "Invalid supported_groups extension: insufficient data");

            }

            byte[] ngs = Record.getBytes16(m);

            if (m.hasRemaining()) {

                throw new SSLProtocolException(

                    "Invalid supported_groups extension: unknown extra data");

            }

            if ((ngs == null) || (ngs.length == 0) || (ngs.length % 2 != 0)) {

                throw new SSLProtocolException(

                    "Invalid supported_groups extension: incomplete data");

            }

            int[] ids = new int[ngs.length / 2];

            for (int i = 0, j = 0; i < ngs.length;) {

                ids[j++] = ((ngs[i++] & 0xFF) << 8) | (ngs[i++] & 0xFF);

            }

            this.namedGroupsIds = ids;

        }

        @Override

        public String toString() {

            MessageFormat messageFormat = new MessageFormat(

                "\"versions\": '['{0}']'", Locale.ENGLISH);

            if (namedGroupsIds == null || namedGroupsIds.length == 0) {

                Object[] messageFields = {

                        "<no supported named group specified>"

                    };

                return messageFormat.format(messageFields);

            } else {

                StringBuilder builder = new StringBuilder(512);

                boolean isFirst = true;

                for (int ngid : namedGroupsIds) {

                    if (isFirst) {

                        isFirst = false;

                    } else {

                        builder.append(", ");

                    }

                    builder.append(NamedGroup.nameOf(ngid));

                }

                Object[] messageFields = {

                        builder.toString()

                    };

                return messageFormat.format(messageFields);

            }

        }

    }

    private static final

            class SupportedGroupsStringizer implements SSLStringizer {

        @Override

        public String toString(ByteBuffer buffer) {

            try {

                return (new SupportedGroupsSpec(buffer)).toString();

            } catch (IOException ioe) {

                // For debug logging only, so please swallow exceptions.

                return ioe.getMessage();

            }

        }

    }

    enum NamedGroupType {

        NAMED_GROUP_ECDHE,          // Elliptic Curve Groups (ECDHE)

        NAMED_GROUP_FFDHE,          // Finite Field Groups (DHE)

        NAMED_GROUP_XDH,            // Finite Field Groups (XDH)

        NAMED_GROUP_ARBITRARY,      // arbitrary prime and curves (ECDHE)

        NAMED_GROUP_NONE;           // Not predefined named group

        boolean isSupported(List<CipherSuite> cipherSuites) {

            for (CipherSuite cs : cipherSuites) {

                if (cs.keyExchange == null || cs.keyExchange.groupType == this) {

                    return true;

                }

            }

            return false;

        }

    }

    public static abstract class NamedGroupFunctions {

        // cache to speed up the parameters construction

        protected static final Map<NamedGroup, AlgorithmParameters>

            namedGroupParams = new ConcurrentHashMap<>();

        private final NamedGroup ng;

        protected NamedGroupFunctions(NamedGroup ng) {

            this.ng = ng;

        }

        public AlgorithmParameters getParameters() {

            AlgorithmParameters result = namedGroupParams.get(ng);

            if (result == null) {

                Optional<AlgorithmParameters> paramsOpt = getParametersImpl();

                if (paramsOpt.isPresent()) {

                    result = paramsOpt.get();

                    namedGroupParams.put(ng, result);

                }

            }

            return result;

        }

        public NamedGroup getNamedGroup() {

            return ng;

        }

        public abstract SSLKeyAgreementCredentials decodeCredentials(byte[] encoded)

            throws IOException, GeneralSecurityException;

        public abstract  SSLPossession createPossession(SecureRandom random);

        public abstract  SSLKeyDerivation createKeyDerivation(HandshakeContext hc)

            throws IOException;

        protected abstract Optional<AlgorithmParameters> getParametersImpl();

        public abstract AlgorithmParameterSpec getParameterSpec();

        public abstract boolean isAvailable();

    }

    private static class FFDHFunctions extends NamedGroupFunctions {

        FFDHFunctions(NamedGroup ng) {

            super(ng);

        }

        @Override

        public SSLKeyAgreementCredentials decodeCredentials(byte[] encoded)

                throws IOException, GeneralSecurityException {

            return DHKeyExchange.DHECredentials.valueOf(getNamedGroup(), encoded);

        }

        @Override

        public SSLPossession createPossession(SecureRandom random) {

            return new DHKeyExchange.DHEPossession(getNamedGroup(), random);

        }

        @Override

        public SSLKeyDerivation createKeyDerivation(HandshakeContext hc)

                throws IOException {

            return DHKeyExchange.kaGenerator.createKeyDerivation(hc);

        }

        @Override

        public AlgorithmParameterSpec getParameterSpec() {

            return getDHParameterSpec();

        }

        DHParameterSpec getDHParameterSpec() {

            AlgorithmParameters params = getParameters();

            try {

                return params.getParameterSpec(DHParameterSpec.class);

            } catch (InvalidParameterSpecException ipse) {

                // should be unlikely

                return getPredefinedDHParameterSpec(getNamedGroup());

            }

        }

        private static DHParameterSpec getFFDHEDHParameterSpec(

            NamedGroup namedGroup) {

            DHParameterSpec spec = null;

            switch (namedGroup) {

                case FFDHE_2048:

                    spec = PredefinedDHParameterSpecs.ffdheParams.get(2048);

                    break;

                case FFDHE_3072:

                    spec = PredefinedDHParameterSpecs.ffdheParams.get(3072);

                    break;

                case FFDHE_4096:

                    spec = PredefinedDHParameterSpecs.ffdheParams.get(4096);

                    break;

                case FFDHE_6144:

                    spec = PredefinedDHParameterSpecs.ffdheParams.get(6144);

                    break;

                case FFDHE_8192:

                    spec = PredefinedDHParameterSpecs.ffdheParams.get(8192);

            }

            return spec;

        }

        private static DHParameterSpec getPredefinedDHParameterSpec(

            NamedGroup namedGroup) {

            DHParameterSpec spec = null;

            switch (namedGroup) {

                case FFDHE_2048:

                    spec = PredefinedDHParameterSpecs.definedParams.get(2048);

                    break;

                case FFDHE_3072:

                    spec = PredefinedDHParameterSpecs.definedParams.get(3072);

                    break;

                case FFDHE_4096:

                    spec = PredefinedDHParameterSpecs.definedParams.get(4096);

                    break;

                case FFDHE_6144:

                    spec = PredefinedDHParameterSpecs.definedParams.get(6144);

                    break;

                case FFDHE_8192:

                    spec = PredefinedDHParameterSpecs.definedParams.get(8192);

            }

            return spec;

        }

        @Override

        public boolean isAvailable() {

            AlgorithmParameters params = getParameters();

            return params != null;

        }

        @Override

        protected Optional<AlgorithmParameters> getParametersImpl() {

            try {

                AlgorithmParameters params = JsseJce.getAlgorithmParameters("DiffieHellman");

                AlgorithmParameterSpec spec = getFFDHEDHParameterSpec(getNamedGroup());

                params.init(spec);

                return Optional.of(params);

            } catch(InvalidParameterSpecException | NoSuchAlgorithmException ex) {

                return Optional.empty();

            }

        }

    }

    private static class ECDHFunctions extends NamedGroupFunctions {

        ECDHFunctions(NamedGroup ng) {

            super(ng);

        }

        @Override

        public SSLKeyAgreementCredentials decodeCredentials(byte[] encoded)

        throws IOException, GeneralSecurityException {

            return ECDHKeyExchange.ECDHECredentials.valueOf(getNamedGroup(), encoded);

        }

        @Override

        public SSLPossession createPossession(SecureRandom random) {

            return new ECDHKeyExchange.ECDHEPossession(getNamedGroup(), random);

        }

        @Override

        public SSLKeyDerivation createKeyDerivation(HandshakeContext hc)

                throws IOException {

            return ECDHKeyExchange.ecdheKAGenerator.createKeyDerivation(hc);

        }

        @Override

        public AlgorithmParameterSpec getParameterSpec() {

            return SupportedGroups.getECGenParamSpec(getNamedGroup());

        }

        @Override

        public boolean isAvailable() {

            AlgorithmParameters params = getParameters();

            return params != null;

        }

        @Override

        protected Optional<AlgorithmParameters> getParametersImpl() {

            try {

                AlgorithmParameters params = JsseJce.getAlgorithmParameters("EC");

                AlgorithmParameterSpec spec = new ECGenParameterSpec(getNamedGroup().oid);

                params.init(spec);

                return Optional.of(params);

            } catch(InvalidParameterSpecException | NoSuchAlgorithmException ex) {

                return Optional.empty();

            }

        }

    }

    private static class XDHFunctions extends NamedGroupFunctions {

        XDHFunctions(NamedGroup ng) {

            super(ng);

        }

        @Override

        public SSLKeyAgreementCredentials decodeCredentials(byte[] encoded)

                throws IOException, GeneralSecurityException {

            return XDHKeyExchange.XDHECredentials.valueOf(getNamedGroup(), encoded);

        }

        @Override

        public SSLPossession createPossession(SecureRandom random) {

            return new XDHKeyExchange.XDHEPossession(getNamedGroup(), random);

        }

        @Override

        public SSLKeyDerivation createKeyDerivation(HandshakeContext hc)

                throws IOException {

            return XDHKeyExchange.xdheKAGenerator.createKeyDerivation(hc);

        }

        @Override

        public AlgorithmParameterSpec getParameterSpec() {

            return new NamedParameterSpec(getNamedGroup().algorithm);

        }

        @Override

        public boolean isAvailable() {

            try {

                JsseJce.getKeyAgreement(getNamedGroup().algorithm);

                return true;

            } catch (NoSuchAlgorithmException ex) {

                return false;

            }

        }

        @Override

        protected Optional<AlgorithmParameters> getParametersImpl() {

            return Optional.empty();

        }

    }

    static enum NamedGroup {

        // Elliptic Curves (RFC 4492)

        //

        // See sun.security.util.CurveDB for the OIDs

        // NIST K-163

        SECT163_K1  (0x0001, "sect163k1", "1.3.132.0.1", true,

                            ProtocolVersion.PROTOCOLS_TO_12),

        SECT163_R1  (0x0002, "sect163r1", "1.3.132.0.2", false,

                            ProtocolVersion.PROTOCOLS_TO_12),

        // NIST B-163

        SECT163_R2  (0x0003, "sect163r2", "1.3.132.0.15", true,

                            ProtocolVersion.PROTOCOLS_TO_12),

        SECT193_R1  (0x0004, "sect193r1", "1.3.132.0.24", false,

                            ProtocolVersion.PROTOCOLS_TO_12),

        SECT193_R2  (0x0005, "sect193r2", "1.3.132.0.25", false,

                            ProtocolVersion.PROTOCOLS_TO_12),

        // NIST K-233

        SECT233_K1  (0x0006, "sect233k1", "1.3.132.0.26", true,

                            ProtocolVersion.PROTOCOLS_TO_12),

        // NIST B-233

        SECT233_R1  (0x0007, "sect233r1", "1.3.132.0.27", true,

                            ProtocolVersion.PROTOCOLS_TO_12),

        SECT239_K1  (0x0008, "sect239k1", "1.3.132.0.3", false,

                            ProtocolVersion.PROTOCOLS_TO_12),

        // NIST K-283

        SECT283_K1  (0x0009, "sect283k1", "1.3.132.0.16", true,

                            ProtocolVersion.PROTOCOLS_TO_12),

        // NIST B-283

        SECT283_R1  (0x000A, "sect283r1", "1.3.132.0.17", true,

                            ProtocolVersion.PROTOCOLS_TO_12),

        // NIST K-409

        SECT409_K1  (0x000B, "sect409k1", "1.3.132.0.36", true,

                            ProtocolVersion.PROTOCOLS_TO_12),

        // NIST B-409

        SECT409_R1  (0x000C, "sect409r1", "1.3.132.0.37", true,

                            ProtocolVersion.PROTOCOLS_TO_12),

        // NIST K-571

        SECT571_K1  (0x000D, "sect571k1", "1.3.132.0.38", true,

                            ProtocolVersion.PROTOCOLS_TO_12),

        // NIST B-571

        SECT571_R1  (0x000E, "sect571r1", "1.3.132.0.39", true,

                            ProtocolVersion.PROTOCOLS_TO_12),

        SECP160_K1  (0x000F, "secp160k1", "1.3.132.0.9", false,

                            ProtocolVersion.PROTOCOLS_TO_12),

        SECP160_R1  (0x0010, "secp160r1", "1.3.132.0.8", false,

                            ProtocolVersion.PROTOCOLS_TO_12),

        SECP160_R2  (0x0011, "secp160r2", "1.3.132.0.30", false,

                            ProtocolVersion.PROTOCOLS_TO_12),

        SECP192_K1  (0x0012, "secp192k1", "1.3.132.0.31", false,

                            ProtocolVersion.PROTOCOLS_TO_12),

        // NIST P-192

        SECP192_R1  (0x0013, "secp192r1", "1.2.840.10045.3.1.1", true,

                            ProtocolVersion.PROTOCOLS_TO_12),