# 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

import sys

from .i18n import _

from . import (

    error,

    util,

)

# 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 = set([

    'tls1.0',

    'tls1.1',

    'tls1.2',

])

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

try:

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

    # SSL/TLS features are available.

    SSLContext = ssl.SSLContext

    modernssl = True

    _canloaddefaultcerts = util.safehasattr(SSLContext, 'load_default_certs')

except AttributeError:

    modernssl = False

    _canloaddefaultcerts = False

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

    class SSLContext(object):

        # ssl.wrap_socket gained the "ciphers" named argument in 2.7.

        _supportsciphers = sys.version_info >= (2, 7)

        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:

                raise error.Abort(_('capath not supported'))

            if cadata:

                raise error.Abort(_('cadata not supported'))

            self._cacerts = cafile

        def set_ciphers(self, ciphers):

            if not self._supportsciphers:

                raise error.Abort(_('setting ciphers not supported'))

            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 = {

                'keyfile': self._keyfile,

                'certfile': self._certfile,

                'server_side': server_side,

                'cert_reqs': self.verify_mode,

                'ssl_version': self.protocol,

                'ca_certs': self._cacerts,

            }

            if self._supportsciphers:

                args['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.

    """

    s = {

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

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

        'allowloaddefaultcerts': True,

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

        'certfingerprints': [],

        # Path to file containing concatenated CA certs. Used by

        # SSLContext.load_verify_locations().

        'cafile': None,

        # Whether certificate verification should be disabled.

        'disablecertverification': False,

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

        'legacyfingerprint': False,

        # PROTOCOL_* constant to use for SSLContext.__init__.

        'protocol': None,

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

        'verifymode': None,

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

        'ctxoptions': None,

    }

    # 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.

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

    def validateprotocol(protocol, key):

        if protocol not in configprotocols:

            raise error.Abort(

                _('unsupported protocol from hostsecurity.%s: %s') %

                (key, protocol),

                hint=_('valid protocols: %s') %

                     ' '.join(sorted(configprotocols)))

    key = 'minimumprotocol'

    validateprotocol(protocol, key)

    key = '%s:minimumprotocol' % hostname

    protocol = ui.config('hostsecurity', key, protocol)

    validateprotocol(protocol, key)

    s['protocol'], s['ctxoptions'] = protocolsettings(protocol)

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

    # of <alg>:<fingerprint> strings.

    fingerprints = ui.configlist('hostsecurity', '%s:fingerprints' % hostname,

                                 [])

    for fingerprint in fingerprints:

        if not (fingerprint.startswith(('sha1:', 'sha256:', 'sha512:'))):

            raise error.Abort(_('invalid fingerprint for %s: %s') % (

                                hostname, fingerprint),

                              hint=_('must begin with "sha1:", "sha256:", '

                                     'or "sha512:"'))

        alg, fingerprint = fingerprint.split(':', 1)

        fingerprint = fingerprint.replace(':', '').lower()

        s['certfingerprints'].append((alg, fingerprint))

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

    for fingerprint in ui.configlist('hostfingerprints', hostname, []):

        fingerprint = fingerprint.replace(':', '').lower()

        s['certfingerprints'].append(('sha1', fingerprint))

        s['legacyfingerprint'] = True

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

    # matters. No need to validate CA certs.

    if s['certfingerprints']:

        s['verifymode'] = ssl.CERT_NONE

        s['allowloaddefaultcerts'] = False

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

    elif ui.insecureconnections:

        s['disablecertverification'] = True

        s['verifymode'] = ssl.CERT_NONE

        s['allowloaddefaultcerts'] = False

    if ui.configbool('devel', 'disableloaddefaultcerts'):

        s['allowloaddefaultcerts'] = False

    # 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.

    cafile = ui.config('hostsecurity', '%s:verifycertsfile' % hostname)

    if s['certfingerprints'] and cafile:

        ui.warn(_('(hostsecurity.%s:verifycertsfile ignored when host '

                  'fingerprints defined; using host fingerprints for '

                  'verification)\n') % hostname)

    # Try to hook up CA certificate validation unless something above

    # makes it not necessary.

    if s['verifymode'] is None:

        # Look at per-host ca file first.

        if cafile:

            cafile = util.expandpath(cafile)

            if not os.path.exists(cafile):

                raise error.Abort(_('path specified by %s does not exist: %s') %

                                  ('hostsecurity.%s:verifycertsfile' % hostname,

                                   cafile))

            s['cafile'] = cafile

        else:

            # Find global certificates file in config.

            cafile = ui.config('web', 'cacerts')

            if cafile:

                cafile = util.expandpath(cafile)

                if not os.path.exists(cafile):

                    raise error.Abort(_('could not find web.cacerts: %s') %

                                      cafile)

            elif s['allowloaddefaultcerts']:

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

                cafile = _defaultcacerts(ui)

                if cafile:

                    ui.debug('using %s for CA file\n' % cafile)

            s['cafile'] = cafile

        # Require certificate validation if CA certs are being loaded and

        # verification hasn't been disabled above.

        if cafile or (_canloaddefaultcerts and s['allowloaddefaultcerts']):

            s['verifymode'] = ssl.CERT_REQUIRED

        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).

            s['verifymode'] = ssl.CERT_NONE

    assert s['protocol'] is not None

    assert s['ctxoptions'] is not None

    assert s['verifymode'] is not None

    return s

def protocolsettings(protocol):

    """Resolve the protocol and context options for a config value."""

    if protocol not in configprotocols:

        raise ValueError('protocol value not supported: %s' % protocol)

    # Legacy ssl module only supports up to TLS 1.0. Ideally we'd use

    # PROTOCOL_SSLv23 and options to disable SSLv2 and SSLv3. However,

    # SSLContext.options doesn't work in our implementation since we use

    # a fake SSLContext on these Python versions.

    if not modernssl:

        if protocol != 'tls1.0':

            raise error.Abort(_('current Python does not support protocol '

                                'setting %s') % protocol,

                              hint=_('upgrade Python or disable setting since '

                                     'only TLS 1.0 is supported'))

        return ssl.PROTOCOL_TLSv1, 0

    # 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

    if protocol == 'tls1.0':

        # Defaults above are to use TLS 1.0+

        pass

    elif protocol == 'tls1.1':

        options |= ssl.OP_NO_TLSv1

    elif protocol == 'tls1.2':

        options |= ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1

    else:

        raise error.Abort(_('this should not happen'))

    # 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

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:

        raise error.Abort(_('serverhostname argument is required'))

    settings = _hostsettings(ui, serverhostname)

    # We can't use ssl.create_default_context() because it calls

    # load_default_certs() unless CA arguments are passed to it. We want to

    # have explicit control over CA loading because implicitly loading

    # CAs may undermine the user's intent. For example, a user may define a CA

    # bundle with a specific CA cert removed. If the system/default CA bundle

    # is loaded and contains that removed CA, you've just undone the user's

    # choice.

    sslcontext = SSLContext(settings['protocol'])

    # This is a no-op unless using modern ssl.

    sslcontext.options |= settings['ctxoptions']

    # This still works on our fake SSLContext.

    sslcontext.verify_mode = settings['verifymode']

    if certfile is not None:

        def password():

            f = keyfile or certfile

            return ui.getpass(_('passphrase for %s: ') % f, '')

        sslcontext.load_cert_chain(certfile, keyfile, password)

    if settings['cafile'] is not None:

        try:

            sslcontext.load_verify_locations(cafile=settings['cafile'])

        except ssl.SSLError as e:

            raise error.Abort(_('error loading CA file %s: %s') % (

                              settings['cafile'], e.args[1]),

                              hint=_('file is empty or malformed?'))

        caloaded = True

    elif settings['allowloaddefaultcerts']:

        # This is a no-op on old Python.

        sslcontext.load_default_certs()

        caloaded = True

    else:

        caloaded = False

    try:

        sslsocket = sslcontext.wrap_socket(sock, server_hostname=serverhostname)

    except ssl.SSLError as e:

        # If we're doing certificate verification and no CA certs are loaded,

        # that is almost certainly the reason why verification failed. Provide

        # a hint to the user.

        # Only modern ssl module exposes SSLContext.get_ca_certs() so we can

        # only show this warning if modern ssl is available.

        if (caloaded and settings['verifymode'] == ssl.CERT_REQUIRED and

            modernssl and not sslcontext.get_ca_certs()):

            ui.warn(_('(an attempt was made to load CA certificates but none '

                      'were loaded; see '

                      'https://mercurial-scm.org/wiki/SecureConnections for '

                      'how to configure Mercurial to avoid this error)\n'))

        # Try to print more helpful error messages for known failures.

        if util.safehasattr(e, 'reason'):

            if e.reason == 'UNSUPPORTED_PROTOCOL':

                ui.warn(_('(could not negotiate a common protocol; see '

                          'https://mercurial-scm.org/wiki/SecureConnections '

                          'for how to configure Mercurial to avoid this '

                          'error)\n'))

        raise

    # check if wrap_socket failed silently because socket had been

    # closed

    # - see http://bugs.python.org/issue13721

    if not sslsocket.cipher():

        raise error.Abort(_('ssl connection failed'))

    sslsocket._hgstate = {

        'caloaded': caloaded,

        'hostname': serverhostname,

        'settings': settings,

        'ui': ui,

    }

    return sslsocket

def wrapserversocket(sock, ui, certfile=None, keyfile=None, cafile=None,

                     requireclientcert=False):

    """Wrap a socket for use by servers.

    ``certfile`` and ``keyfile`` specify the files containing the certificate's

    public and private keys, respectively. Both keys can be defined in the same

    file via ``certfile`` (the private key must come first in the file).

    ``cafile`` defines the path to certificate authorities.

    ``requireclientcert`` specifies whether to require client certificates.

    Typically ``cafile`` is only defined if ``requireclientcert`` is true.

    """

    protocol, options = protocolsettings('tls1.0')

    # This config option is intended for use in tests only. It is a giant

    # footgun to kill security. Don't define it.

    exactprotocol = ui.config('devel', 'serverexactprotocol')

    if exactprotocol == 'tls1.0':

        protocol = ssl.PROTOCOL_TLSv1

    elif exactprotocol == 'tls1.1':

        protocol = ssl.PROTOCOL_TLSv1_1

    elif exactprotocol == 'tls1.2':

        protocol = ssl.PROTOCOL_TLSv1_2

    elif exactprotocol:

        raise error.Abort(_('invalid value for serverexactprotocol: %s') %

                          exactprotocol)

    if modernssl:

        # We /could/ use create_default_context() here since it doesn't load

        # CAs when configured for client auth. However, it is hard-coded to

        # use ssl.PROTOCOL_SSLv23 which may not be appropriate here.

        sslcontext = SSLContext(protocol)

        sslcontext.options |= options

        # Improve forward secrecy.

        sslcontext.options |= getattr(ssl, 'OP_SINGLE_DH_USE', 0)

        sslcontext.options |= getattr(ssl, 'OP_SINGLE_ECDH_USE', 0)

        # Use the list of more secure ciphers if found in the ssl module.

        if util.safehasattr(ssl, '_RESTRICTED_SERVER_CIPHERS'):

            sslcontext.options |= getattr(ssl, 'OP_CIPHER_SERVER_PREFERENCE', 0)

            sslcontext.set_ciphers(ssl._RESTRICTED_SERVER_CIPHERS)

    else:

        sslcontext = SSLContext(ssl.PROTOCOL_TLSv1)

    if requireclientcert:

        sslcontext.verify_mode = ssl.CERT_REQUIRED

    else:

        sslcontext.verify_mode = ssl.CERT_NONE

    if certfile or keyfile:

        sslcontext.load_cert_chain(certfile=certfile, keyfile=keyfile)

    if cafile:

        sslcontext.load_verify_locations(cafile=cafile)

    return sslcontext.wrap_socket(sock, server_side=True)

class wildcarderror(Exception):

    """Represents an error parsing wildcards in DNS name."""

def _dnsnamematch(dn, hostname, maxwildcards=1):

    """Match DNS names according RFC 6125 section 6.4.3.

    This code is effectively copied from CPython's ssl._dnsname_match.

    Returns a bool indicating whether the expected hostname matches

    the value in ``dn``.

    """

    pats = []

    if not dn:

        return False

    pieces = dn.split(r'.')

    leftmost = pieces[0]

    remainder = pieces[1:]

    wildcards = leftmost.count('*')

    if wildcards > maxwildcards:

        raise wildcarderror(

            _('too many wildcards in certificate DNS name: %s') % dn)

    # speed up common case w/o wildcards

    if not wildcards:

        return dn.lower() == hostname.lower()

    # RFC 6125, section 6.4.3, subitem 1.

    # The client SHOULD NOT attempt to match a presented identifier in which

    # the wildcard character comprises a label other than the left-most label.