# sslutil.py - SSL handling for mercurial

#

# Copyright 2005, 2006, 2007, 2008 Matt Mackall <mpm@selenic.com>

# Copyright 2006, 2007 Alexis S. L. Carvalho <alexis@cecm.usp.br>

# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from __future__ import absolute_import

import hashlib

import os

import re

import ssl

from .i18n import _

from . import (

    encoding,

    error,

    node,

    pycompat,

    util,

)

from .utils import (

    procutil,

    stringutil,

)

# Python 2.7.9+ overhauled the built-in SSL/TLS features of Python. It added

# support for TLS 1.1, TLS 1.2, SNI, system CA stores, etc. These features are

# all exposed via the "ssl" module.

#

# Depending on the version of Python being used, SSL/TLS support is either

# modern/secure or legacy/insecure. Many operations in this module have

# separate code paths depending on support in Python.

configprotocols = {

}

hassni = getattr(ssl, 'HAS_SNI', False)

# TLS 1.1 and 1.2 may not be supported if the OpenSSL Python is compiled

# against doesn't support them.

try:

    # ssl.SSLContext was added in 2.7.9 and presence indicates modern

    # SSL/TLS features are available.

    SSLContext = ssl.SSLContext

    modernssl = True

except AttributeError:

    modernssl = False

    _canloaddefaultcerts = False

    # We implement SSLContext using the interface from the standard library.

    class SSLContext(object):

        def __init__(self, protocol):

            # From the public interface of SSLContext

            self.protocol = protocol

            self.check_hostname = False

            self.options = 0

            self.verify_mode = ssl.CERT_NONE

            # Used by our implementation.

            self._certfile = None

            self._keyfile = None

            self._certpassword = None

            self._cacerts = None

            self._ciphers = None

        def load_cert_chain(self, certfile, keyfile=None, password=None):

            self._certfile = certfile

            self._keyfile = keyfile

            self._certpassword = password

        def load_default_certs(self, purpose=None):

            pass

        def load_verify_locations(self, cafile=None, capath=None, cadata=None):

            if capath:

            if cadata:

            self._cacerts = cafile

        def set_ciphers(self, ciphers):

            self._ciphers = ciphers

        def wrap_socket(self, socket, server_hostname=None, server_side=False):

            # server_hostname is unique to SSLContext.wrap_socket and is used

            # for SNI in that context. So there's nothing for us to do with it

            # in this legacy code since we don't support SNI.

            args = {

                r'keyfile': self._keyfile,

                r'certfile': self._certfile,

                r'server_side': server_side,

                r'cert_reqs': self.verify_mode,

                r'ssl_version': self.protocol,

                r'ca_certs': self._cacerts,

                r'ciphers': self._ciphers,

            }

            return ssl.wrap_socket(socket, **args)

def _hostsettings(ui, hostname):

    """Obtain security settings for a hostname.

    Returns a dict of settings relevant to that hostname.

    """

    bhostname = pycompat.bytesurl(hostname)

    s = {

        # Whether we should attempt to load default/available CA certs

        # if an explicit ``cafile`` is not defined.

        # List of 2-tuple of (hash algorithm, hash).

        # Path to file containing concatenated CA certs. Used by

        # SSLContext.load_verify_locations().

        # Whether certificate verification should be disabled.

        # Whether the legacy [hostfingerprints] section has data for this host.

        # PROTOCOL_* constant to use for SSLContext.__init__.

        # String representation of minimum protocol to be used for UI

        # presentation.

        # ssl.CERT_* constant used by SSLContext.verify_mode.

        # Defines extra ssl.OP* bitwise options to set.

        # OpenSSL Cipher List to use (instead of default).

    }

    # Allow minimum TLS protocol to be specified in the config.

    def validateprotocol(protocol, key):

        if protocol not in configprotocols:

            raise error.Abort(

                % (key, protocol),

            )

    # We default to TLS 1.1+ where we can because TLS 1.0 has known

    # vulnerabilities (like BEAST and POODLE). We allow users to downgrade to

    # TLS 1.0+ via config options in case a legacy server is encountered.

    else:

        # Let people know they are borderline secure.

        # We don't document this config option because we want people to see

        # the bold warnings on the web site.

        # internal config: hostsecurity.disabletls10warning

            ui.warn(

                _(

                )

                % bhostname

            )

    validateprotocol(protocol, key)

    validateprotocol(protocol, key)

    # If --insecure is used, we allow the use of TLS 1.0 despite config options.

    # We always print a "connection security to %s is disabled..." message when

    # --insecure is used. So no need to print anything more here.

    if ui.insecureconnections:

    # Look for fingerprints in [hostsecurity] section. Value is a list

    # of <alg>:<fingerprint> strings.

    for fingerprint in fingerprints:

            raise error.Abort(

            )

    # Fingerprints from [hostfingerprints] are always SHA-1.

    # If a host cert fingerprint is defined, it is the only thing that

    # matters. No need to validate CA certs.

    # If --insecure is used, don't take CAs into consideration.

    elif ui.insecureconnections:

    # If both fingerprints and a per-host ca file are specified, issue a warning

    # because users should not be surprised about what security is or isn't

    # being performed.

        ui.warn(

            _(

            )

            % bhostname

        )

    # Try to hook up CA certificate validation unless something above

    # makes it not necessary.

        # Look at per-host ca file first.

        if cafile:

            cafile = util.expandpath(cafile)

            if not os.path.exists(cafile):

                raise error.Abort(

                )

        else:

            # Find global certificates file in config.

            if cafile:

                cafile = util.expandpath(cafile)

                if not os.path.exists(cafile):

                    raise error.Abort(

                    )

                # CAs not defined in config. Try to find system bundles.

                cafile = _defaultcacerts(ui)

                if cafile:

        # Require certificate validation if CA certs are being loaded and

        # verification hasn't been disabled above.

        else:

            # At this point we don't have a fingerprint, aren't being

            # explicitly insecure, and can't load CA certs. Connecting

            # is insecure. We allow the connection and abort during

            # validation (once we have the fingerprint to print to the

            # user).

    return s

def protocolsettings(protocol):

    """Resolve the protocol for a config value.

    Returns a 3-tuple of (protocol, options, ui value) where the first

    2 items are values used by SSLContext and the last is a string value

    of the ``minimumprotocol`` config option equivalent.

    """

    if protocol not in configprotocols:

    # Despite its name, PROTOCOL_SSLv23 selects the highest protocol

    # that both ends support, including TLS protocols. On legacy stacks,

    # the highest it likely goes is TLS 1.0. On modern stacks, it can

    # support TLS 1.2.

    #

    # The PROTOCOL_TLSv* constants select a specific TLS version

    # only (as opposed to multiple versions). So the method for

    # supporting multiple TLS versions is to use PROTOCOL_SSLv23 and

    # disable protocols via SSLContext.options and OP_NO_* constants.

    # However, SSLContext.options doesn't work unless we have the

    # full/real SSLContext available to us.

            raise error.Abort(

                % protocol,

                hint=_(

                ),

            )

    # WARNING: returned options don't work unless the modern ssl module

    # is available. Be careful when adding options here.

    # SSLv2 and SSLv3 are broken. We ban them outright.

    options = ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3

        # Defaults above are to use TLS 1.0+

        pass

        options |= ssl.OP_NO_TLSv1

        options |= ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1

    else:

    # Prevent CRIME.

    # There is no guarantee this attribute is defined on the module.

    options |= getattr(ssl, 'OP_NO_COMPRESSION', 0)

    return ssl.PROTOCOL_SSLv23, options, protocol

def wrapsocket(sock, keyfile, certfile, ui, serverhostname=None):

    """Add SSL/TLS to a socket.

    This is a glorified wrapper for ``ssl.wrap_socket()``. It makes sane

    choices based on what security options are available.

    In addition to the arguments supported by ``ssl.wrap_socket``, we allow

    the following additional arguments:

    * serverhostname - The expected hostname of the remote server. If the

      server (and client) support SNI, this tells the server which certificate

      to use.

    """

    if not serverhostname:

    if b'SSLKEYLOGFILE' in encoding.environ:

        try:

            import sslkeylog

            sslkeylog.set_keylog(

                pycompat.fsdecode(encoding.environ[b'SSLKEYLOGFILE'])

            )

            ui.warn(

                b'sslkeylog enabled by SSLKEYLOGFILE environment variable\n'

            )

        except ImportError:

            ui.warn(

                b'sslkeylog module missing, '

                b'but SSLKEYLOGFILE set in environment\n'

            )