/*
 * 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.krb5.internal.ssl;

import sun.security.ssl.ClientKeyExchange;
import sun.security.ssl.Debug;
import sun.security.ssl.ClientKeyExchangeService;
import sun.security.ssl.HandshakeOutStream;

import sun.security.jgss.GSSCaller;
import sun.security.jgss.krb5.Krb5Util;
import sun.security.jgss.krb5.ServiceCreds;
import sun.security.krb5.EncryptedData;
import sun.security.krb5.EncryptionKey;
import sun.security.krb5.KrbException;
import sun.security.krb5.PrincipalName;
import sun.security.krb5.internal.EncTicketPart;
import sun.security.krb5.internal.Ticket;
import sun.security.krb5.internal.crypto.KeyUsage;
import sun.security.ssl.ProtocolVersion;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import javax.security.auth.Subject;
import javax.security.auth.kerberos.KerberosKey;
import javax.security.auth.kerberos.KerberosPrincipal;
import javax.security.auth.kerberos.KerberosTicket;
import javax.security.auth.kerberos.KeyTab;
import javax.security.auth.kerberos.ServicePermission;
import java.io.IOException;
import java.io.PrintStream;
import java.net.InetAddress;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.Principal;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.security.SecureRandom;
import java.util.Set;

/**
 * The provider for TLS_KRB_ cipher suites.
 *
 * @since 1.9
 */
public class Krb5KeyExchangeService implements ClientKeyExchangeService {

    public static final Debug debug = Debug.getInstance("ssl");

    @Override
    public String[] supported() {
        return new String[] { "KRB5", "KRB5_EXPORT" };
    }

    @Override
    public Object getServiceCreds(AccessControlContext acc) {
        try {
            ServiceCreds serviceCreds = AccessController.doPrivileged(
                    (PrivilegedExceptionAction<ServiceCreds>)
                            () -> Krb5Util.getServiceCreds(
                                    GSSCaller.CALLER_SSL_SERVER, null, acc));
            if (debug != null && Debug.isOn("handshake")) {
                System.out.println("Using Kerberos creds");
            }
            String serverPrincipal = serviceCreds.getName();
            if (serverPrincipal != null) {
                // When service is bound, we check ASAP. Otherwise,
                // will check after client request is received
                // in in Kerberos ClientKeyExchange
                SecurityManager sm = System.getSecurityManager();
                try {
                    if (sm != null) {
                        // Eliminate dependency on ServicePermission
                        sm.checkPermission(new ServicePermission(
                                serverPrincipal, "accept"), acc);
                    }
                } catch (SecurityException se) {
                    if (debug != null && Debug.isOn("handshake")) {
                        System.out.println("Permission to access Kerberos"
                                + " secret key denied");
                    }
                    return null;
                }
            }
            return serviceCreds;
        } catch (PrivilegedActionException e) {
            // Likely exception here is LoginException
            if (debug != null && Debug.isOn("handshake")) {
                System.out.println("Attempt to obtain Kerberos key failed: "
                        + e.toString());
            }
            return null;
        }
    }

    @Override
    public String getServiceHostName(Principal principal) {
        if (principal == null) {
            return null;
        }
        String hostName = null;
        try {
            PrincipalName princName =
                    new PrincipalName(principal.getName(),
                            PrincipalName.KRB_NT_SRV_HST);
            String[] nameParts = princName.getNameStrings();
            if (nameParts.length >= 2) {
                hostName = nameParts[1];
            }
        } catch (Exception e) {
            // ignore
        }
        return hostName;
    }


    @Override
    public boolean isRelated(boolean isClient,
            AccessControlContext acc, Principal p) {

        if (p == null) return false;
        try {
            Subject subject = AccessController.doPrivileged(
                    (PrivilegedExceptionAction<Subject>)
                            () -> Krb5Util.getSubject(
                                    isClient ? GSSCaller.CALLER_SSL_CLIENT
                                            : GSSCaller.CALLER_SSL_SERVER,
                                    acc));
            if (subject == null) {
                if (debug != null && Debug.isOn("session")) {
                    System.out.println("Kerberos credentials are" +
                            " not present in the current Subject;" +
                            " check if " +
                            " javax.security.auth.useSubjectAsCreds" +
                            " system property has been set to false");
                }
                return false;
            }
            Set<Principal> principals =
                    subject.getPrincipals(Principal.class);
            if (principals.contains(p)) {
                // bound to this principal
                return true;
            } else {
                if (isClient) {
                    return false;
                } else {
                    for (KeyTab pc : subject.getPrivateCredentials(KeyTab.class)) {
                        if (!pc.isBound()) {
                            return true;
                        }
                    }
                    return false;
                }
            }
        } catch (PrivilegedActionException pae) {
            if (debug != null && Debug.isOn("session")) {
                System.out.println("Attempt to obtain" +
                        " subject failed! " + pae);
            }
            return false;
        }

    }

    public ClientKeyExchange createClientExchange(
            String serverName, AccessControlContext acc,
            ProtocolVersion protocolVerson, SecureRandom rand) throws IOException {
        return new ExchangerImpl(serverName, acc, protocolVerson, rand);
    }

    public ClientKeyExchange createServerExchange(
            ProtocolVersion protocolVersion, ProtocolVersion clientVersion,
            SecureRandom rand, byte[] encodedTicket, byte[] encrypted,
            AccessControlContext acc, Object serviceCreds) throws IOException {
        return new ExchangerImpl(protocolVersion, clientVersion, rand,
                encodedTicket, encrypted, acc, serviceCreds);
    }

    static class ExchangerImpl extends ClientKeyExchange {

        final private KerberosPreMasterSecret preMaster;
        final private byte[] encodedTicket;
        final private KerberosPrincipal peerPrincipal;
        final private KerberosPrincipal localPrincipal;

        @Override
        public int messageLength() {
            return encodedTicket.length + preMaster.getEncrypted().length + 6;
        }

        @Override
        public void send(HandshakeOutStream s) throws IOException {
            s.putBytes16(encodedTicket);
            s.putBytes16(null);
            s.putBytes16(preMaster.getEncrypted());
        }

        @Override
        public void print(PrintStream s) throws IOException {
            s.println("*** ClientKeyExchange, Kerberos");

            if (debug != null && Debug.isOn("verbose")) {
                Debug.println(s, "Kerberos service ticket", encodedTicket);
                Debug.println(s, "Random Secret", preMaster.getUnencrypted());
                Debug.println(s, "Encrypted random Secret", preMaster.getEncrypted());
            }
        }

        ExchangerImpl(String serverName, AccessControlContext acc,
                ProtocolVersion protocolVersion, SecureRandom rand) throws IOException {

            // Get service ticket
            KerberosTicket ticket = getServiceTicket(serverName, acc);
            encodedTicket = ticket.getEncoded();

            // Record the Kerberos principals
            peerPrincipal = ticket.getServer();
            localPrincipal = ticket.getClient();

            // Optional authenticator, encrypted using session key,
            // currently ignored

            // Generate premaster secret and encrypt it using session key
            EncryptionKey sessionKey = new EncryptionKey(
                    ticket.getSessionKeyType(),
                    ticket.getSessionKey().getEncoded());

            preMaster = new KerberosPreMasterSecret(protocolVersion,
                    rand, sessionKey);
        }

        ExchangerImpl(
                ProtocolVersion protocolVersion, ProtocolVersion clientVersion, SecureRandom rand,
                byte[] encodedTicket, byte[] encrypted,
                AccessControlContext acc, Object serviceCreds) throws IOException {

            // Read ticket
            this.encodedTicket = encodedTicket;

            if (debug != null && Debug.isOn("verbose")) {
                Debug.println(System.out,
                        "encoded Kerberos service ticket", encodedTicket);
            }

            EncryptionKey sessionKey = null;
            KerberosPrincipal tmpPeer = null;
            KerberosPrincipal tmpLocal = null;

            try {
                Ticket t = new Ticket(encodedTicket);

                EncryptedData encPart = t.encPart;
                PrincipalName ticketSname = t.sname;

                final ServiceCreds creds = (ServiceCreds)serviceCreds;
                final KerberosPrincipal princ =
                        new KerberosPrincipal(ticketSname.toString());

                // For bound service, permission already checked at setup
                if (creds.getName() == null) {
                    SecurityManager sm = System.getSecurityManager();
                    try {
                        if (sm != null) {
                            // Eliminate dependency on ServicePermission
                            sm.checkPermission(new ServicePermission(
                                    ticketSname.toString(), "accept"), acc);
                        }
                    } catch (SecurityException se) {
                        serviceCreds = null;
                        // Do not destroy keys. Will affect Subject
                        if (debug != null && Debug.isOn("handshake")) {
                            System.out.println("Permission to access Kerberos"
                                    + " secret key denied");
                            se.printStackTrace(System.out);
                        }
                        throw new IOException("Kerberos service not allowedy");
                    }
                }
                KerberosKey[] serverKeys = AccessController.doPrivileged(
                        new PrivilegedAction<KerberosKey[]>() {
                            @Override
                            public KerberosKey[] run() {
                                return creds.getKKeys(princ);
                            }
                        });
                if (serverKeys.length == 0) {
                    throw new IOException("Found no key for " + princ +
                            (creds.getName() == null ? "" :
                                    (", this keytab is for " + creds.getName() + " only")));
                }

                /*
                 * permission to access and use the secret key of the Kerberized
                 * "host" service is done in ServerHandshaker.getKerberosKeys()
                 * to ensure server has the permission to use the secret key
                 * before promising the client
                 */

                // See if we have the right key to decrypt the ticket to get
                // the session key.
                int encPartKeyType = encPart.getEType();
                Integer encPartKeyVersion = encPart.getKeyVersionNumber();
                KerberosKey dkey = null;
                try {
                    dkey = findKey(encPartKeyType, encPartKeyVersion, serverKeys);
                } catch (KrbException ke) { // a kvno mismatch
                    throw new IOException(
                            "Cannot find key matching version number", ke);
                }
                if (dkey == null) {
                    // %%% Should print string repr of etype
                    throw new IOException("Cannot find key of appropriate type" +
                            " to decrypt ticket - need etype " + encPartKeyType);
                }

                EncryptionKey secretKey = new EncryptionKey(
                        encPartKeyType,
                        dkey.getEncoded());

                // Decrypt encPart using server's secret key
                byte[] bytes = encPart.decrypt(secretKey, KeyUsage.KU_TICKET);

                // Reset data stream after decryption, remove redundant bytes
                byte[] temp = encPart.reset(bytes);
                EncTicketPart encTicketPart = new EncTicketPart(temp);

                // Record the Kerberos Principals
                tmpPeer = new KerberosPrincipal(encTicketPart.cname.getName());
                tmpLocal = new KerberosPrincipal(ticketSname.getName());

                sessionKey = encTicketPart.key;

                if (debug != null && Debug.isOn("handshake")) {
                    System.out.println("server principal: " + ticketSname);
                    System.out.println("cname: " + encTicketPart.cname.toString());
                }
            } catch (IOException e) {
                throw e;
            } catch (Exception e) {
                if (debug != null && Debug.isOn("handshake")) {
                    System.out.println("KerberosWrapper error getting session key,"
                            + " generating random secret (" + e.getMessage() + ")");
                }
                sessionKey = null;
            }

            //input.getBytes16();   // XXX Read and ignore authenticator

            if (sessionKey != null) {
                preMaster = new KerberosPreMasterSecret(protocolVersion,
                        clientVersion, rand, encrypted, sessionKey);
            } else {
                // Generate bogus premaster secret
                preMaster = new KerberosPreMasterSecret(clientVersion, rand);
            }

            peerPrincipal = tmpPeer;
            localPrincipal = tmpLocal;
        }

        // Similar to sun.security.jgss.krb5.Krb5InitCredenetial/Krb5Context
        private static KerberosTicket getServiceTicket(String serverName,
                final AccessControlContext acc) throws IOException {

            if ("localhost".equals(serverName) ||
                    "localhost.localdomain".equals(serverName)) {

                if (debug != null && Debug.isOn("handshake")) {
                    System.out.println("Get the local hostname");
                }
                String localHost = java.security.AccessController.doPrivileged(
                        new java.security.PrivilegedAction<String>() {
                            public String run() {
                                try {
                                    return InetAddress.getLocalHost().getHostName();
                                } catch (java.net.UnknownHostException e) {
                                    if (debug != null && Debug.isOn("handshake")) {
                                        System.out.println("Warning,"
                                                + " cannot get the local hostname: "
                                                + e.getMessage());
                                    }
                                    return null;
                                }
                            }
                        });
                if (localHost != null) {
                    serverName = localHost;
                }
            }

            // Resolve serverName (possibly in IP addr form) to Kerberos principal
            // name for service with hostname
            String serviceName = "host/" + serverName;
            PrincipalName principal;
            try {
                principal = new PrincipalName(serviceName,
                        PrincipalName.KRB_NT_SRV_HST);
            } catch (SecurityException se) {
                throw se;
            } catch (Exception e) {
                IOException ioe = new IOException("Invalid service principal" +
                        " name: " + serviceName);
                ioe.initCause(e);
                throw ioe;
            }
            String realm = principal.getRealmAsString();

            final String serverPrincipal = principal.toString();
            final String tgsPrincipal = "krbtgt/" + realm + "@" + realm;
            final String clientPrincipal = null;  // use default


            // check permission to obtain a service ticket to initiate a
            // context with the "host" service
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                sm.checkPermission(new ServicePermission(serverPrincipal,
                        "initiate"), acc);
            }

            try {
                KerberosTicket ticket = AccessController.doPrivileged(
                        new PrivilegedExceptionAction<KerberosTicket>() {
                            public KerberosTicket run() throws Exception {
                                return Krb5Util.getTicketFromSubjectAndTgs(
                                        GSSCaller.CALLER_SSL_CLIENT,
                                        clientPrincipal, serverPrincipal,
                                        tgsPrincipal, acc);
                            }});

                if (ticket == null) {
                    throw new IOException("Failed to find any kerberos service" +
                            " ticket for " + serverPrincipal);
                }
                return ticket;
            } catch (PrivilegedActionException e) {
                IOException ioe = new IOException(
                        "Attempt to obtain kerberos service ticket for " +
                                serverPrincipal + " failed!");
                ioe.initCause(e);
                throw ioe;
            }
        }

        @Override
        public SecretKey clientKeyExchange() {
            byte[] secretBytes = preMaster.getUnencrypted();
            return new SecretKeySpec(secretBytes, "TlsPremasterSecret");
        }

        @Override
        public Principal getPeerPrincipal() {
            return peerPrincipal;
        }

        @Override
        public Principal getLocalPrincipal() {
            return localPrincipal;
        }

        /**
         * Determines if a kvno matches another kvno. Used in the method
         * findKey(etype, version, keys). Always returns true if either input
         * is null or zero, in case any side does not have kvno info available.
         *
         * Note: zero is included because N/A is not a legal value for kvno
         * in javax.security.auth.kerberos.KerberosKey. Therefore, the info
         * that the kvno is N/A might be lost when converting between
         * EncryptionKey and KerberosKey.
         */
        private static boolean versionMatches(Integer v1, int v2) {
            if (v1 == null || v1 == 0 || v2 == 0) {
                return true;
            }
            return v1.equals(v2);
        }

        private static KerberosKey findKey(int etype, Integer version,
                KerberosKey[] keys) throws KrbException {
            int ktype;
            boolean etypeFound = false;

            // When no matched kvno is found, returns tke key of the same
            // etype with the highest kvno
            int kvno_found = 0;
            KerberosKey key_found = null;

            for (int i = 0; i < keys.length; i++) {
                ktype = keys[i].getKeyType();
                if (etype == ktype) {
                    int kv = keys[i].getVersionNumber();
                    etypeFound = true;
                    if (versionMatches(version, kv)) {
                        return keys[i];
                    } else if (kv > kvno_found) {
                        key_found = keys[i];
                        kvno_found = kv;
                    }
                }
            }
            // Key not found.
            // %%% kludge to allow DES keys to be used for diff etypes
            if ((etype == EncryptedData.ETYPE_DES_CBC_CRC ||
                    etype == EncryptedData.ETYPE_DES_CBC_MD5)) {
                for (int i = 0; i < keys.length; i++) {
                    ktype = keys[i].getKeyType();
                    if (ktype == EncryptedData.ETYPE_DES_CBC_CRC ||
                            ktype == EncryptedData.ETYPE_DES_CBC_MD5) {
                        int kv = keys[i].getVersionNumber();
                        etypeFound = true;
                        if (versionMatches(version, kv)) {
                            return new KerberosKey(keys[i].getPrincipal(),
                                    keys[i].getEncoded(),
                                    etype,
                                    kv);
                        } else if (kv > kvno_found) {
                            key_found = new KerberosKey(keys[i].getPrincipal(),
                                    keys[i].getEncoded(),
                                    etype,
                                    kv);
                            kvno_found = kv;
                        }
                    }
                }
            }
            if (etypeFound) {
                return key_found;
            }
            return null;
        }
    }
}