FM / setuptools

/usr/lib/python2.7/site-packages/setuptools/

/usr/lib/python2.7/site-packages/setuptools

Name	Size	Mode	Actions
command/	-	0755	rm
extern/	-	0755	rm
_vendor/	-	0755	rm
archive_util.py	6592	0644	edit dl rm
archive_util.pyc	6142	0644	edit dl rm
archive_util.pyo	6142	0644	edit dl rm
build_meta.py	5671	0644	edit dl rm
build_meta.pyc	6639	0644	edit dl rm
build_meta.pyo	6522	0644	edit dl rm
config.py	16381	0644	edit dl rm
config.pyc	16888	0644	edit dl rm
config.pyo	16888	0644	edit dl rm
depends.py	5837	0644	edit dl rm
depends.pyc	6483	0644	edit dl rm
depends.pyo	6483	0644	edit dl rm
dep_util.py	935	0644	edit dl rm
dep_util.pyc	965	0644	edit dl rm
dep_util.pyo	965	0644	edit dl rm
dist.py	42514	0644	edit dl rm
dist.pyc	41502	0644	edit dl rm
dist.pyo	41444	0644	edit dl rm
extension.py	1729	0644	edit dl rm
extension.pyc	2418	0644	edit dl rm
extension.pyo	2418	0644	edit dl rm
glibc.py	3146	0644	edit dl rm
glibc.pyc	1960	0644	edit dl rm
glibc.pyo	1960	0644	edit dl rm
glob.py	5207	0644	edit dl rm
glob.pyc	4818	0644	edit dl rm
glob.pyo	4756	0644	edit dl rm
launch.py	787	0644	edit dl rm
launch.pyc	1000	0644	edit dl rm
launch.pyo	1000	0644	edit dl rm
lib2to3_ex.py	2013	0644	edit dl rm
lib2to3_ex.pyc	3004	0644	edit dl rm
lib2to3_ex.pyo	3004	0644	edit dl rm
monkey.py	5789	0644	edit dl rm
monkey.pyc	6343	0644	edit dl rm
monkey.pyo	6343	0644	edit dl rm
msvc.py	40877	0644	edit dl rm
msvc.pyc	40352	0644	edit dl rm
msvc.pyo	40352	0644	edit dl rm
namespaces.py	3199	0644	edit dl rm
namespaces.pyc	5033	0644	edit dl rm
namespaces.pyo	5033	0644	edit dl rm
package_index.py	40153	0644	edit dl rm
package_index.pyc	39743	0644	edit dl rm
package_index.pyo	39743	0644	edit dl rm
pep425tags.py	10882	0644	edit dl rm
pep425tags.pyc	9334	0644	edit dl rm
pep425tags.pyo	9334	0644	edit dl rm
py27compat.py	536	0644	edit dl rm
py27compat.pyc	1045	0644	edit dl rm
py27compat.pyo	1045	0644	edit dl rm
py31compat.py	1192	0644	edit dl rm
py31compat.pyc	1898	0644	edit dl rm
py31compat.pyo	1898	0644	edit dl rm
py33compat.py	1182	0644	edit dl rm
py33compat.pyc	1720	0644	edit dl rm
py33compat.pyo	1720	0644	edit dl rm
py36compat.py	2891	0644	edit dl rm
py36compat.pyc	2862	0644	edit dl rm
py36compat.pyo	2862	0644	edit dl rm
sandbox.py	14276	0644	edit dl rm
sandbox.pyc	18900	0644	edit dl rm
sandbox.pyo	18900	0644	edit dl rm
script (dev).tmpl	201	0644	edit dl rm
script.tmpl	138	0644	edit dl rm
site-patch.py	2307	0644	edit dl rm
site-patch.pyc	1739	0644	edit dl rm
site-patch.pyo	1739	0644	edit dl rm
ssl_support.py	8492	0644	edit dl rm
ssl_support.pyc	8516	0644	edit dl rm
ssl_support.pyo	8516	0644	edit dl rm
unicode_utils.py	996	0644	edit dl rm
unicode_utils.pyc	1472	0644	edit dl rm
unicode_utils.pyo	1472	0644	edit dl rm
version.py	144	0644	edit dl rm
version.pyc	322	0644	edit dl rm
version.pyo	322	0644	edit dl rm
wheel.py	7230	0644	edit dl rm
wheel.pyc	7343	0644	edit dl rm
wheel.pyo	7309	0644	edit dl rm
windows_support.py	714	0644	edit dl rm
windows_support.pyc	1274	0644	edit dl rm
windows_support.pyo	1274	0644	edit dl rm
__init__.py	5700	0644	edit dl rm
__init__.pyc	7625	0644	edit dl rm
__init__.pyo	7625	0644	edit dl rm

Edit: /usr/lib/python2.7/site-packages/setuptools/ssl_support.py (8492B)

import os
import socket
import atexit
import re
import functools

from setuptools.extern.six.moves import urllib, http_client, map, filter

from pkg_resources import ResolutionError, ExtractionError

try:
    import ssl
except ImportError:
    ssl = None

__all__ = [
    'VerifyingHTTPSHandler', 'find_ca_bundle', 'is_available', 'cert_paths',
    'opener_for'
]

cert_paths = """
/etc/pki/tls/certs/ca-bundle.crt
/etc/ssl/certs/ca-certificates.crt
/usr/share/ssl/certs/ca-bundle.crt
/usr/local/share/certs/ca-root.crt
/etc/ssl/cert.pem
/System/Library/OpenSSL/certs/cert.pem
/usr/local/share/certs/ca-root-nss.crt
/etc/ssl/ca-bundle.pem
""".strip().split()

try:
    HTTPSHandler = urllib.request.HTTPSHandler
    HTTPSConnection = http_client.HTTPSConnection
except AttributeError:
    HTTPSHandler = HTTPSConnection = object

is_available = ssl is not None and object not in (HTTPSHandler, HTTPSConnection)

try:
    from ssl import CertificateError, match_hostname
except ImportError:
    try:
        from backports.ssl_match_hostname import CertificateError
        from backports.ssl_match_hostname import match_hostname
    except ImportError:
        CertificateError = None
        match_hostname = None

if not CertificateError:

class CertificateError(ValueError):
        pass

if not match_hostname:

def _dnsname_match(dn, hostname, max_wildcards=1):
        """Matching according to RFC 6125, section 6.4.3

http://tools.ietf.org/html/rfc6125#section-6.4.3
        """
        pats = []
        if not dn:
            return False

# Ported from python3-syntax:
        # leftmost, *remainder = dn.split(r'.')
        parts = dn.split(r'.')
        leftmost = parts[0]
        remainder = parts[1:]

wildcards = leftmost.count('*')
        if wildcards > max_wildcards:
            # Issue #17980: avoid denials of service by refusing more
            # than one wildcard per fragment.  A survey of established
            # policy among SSL implementations showed it to be a
            # reasonable choice.
            raise CertificateError(
                "too many wildcards in certificate DNS name: " + repr(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.
        if leftmost == '*':
            # When '*' is a fragment by itself, it matches a non-empty dotless
            # fragment.
            pats.append('[^.]+')
        elif leftmost.startswith('xn--') or hostname.startswith('xn--'):
            # RFC 6125, section 6.4.3, subitem 3.
            # The client SHOULD NOT attempt to match a presented identifier
            # where the wildcard character is embedded within an A-label or
            # U-label of an internationalized domain name.
            pats.append(re.escape(leftmost))
        else:
            # Otherwise, '*' matches any dotless string, e.g. www*
            pats.append(re.escape(leftmost).replace(r'\*', '[^.]*'))

# add the remaining fragments, ignore any wildcards
        for frag in remainder:
            pats.append(re.escape(frag))

pat = re.compile(r'\A' + r'\.'.join(pats) + r'\Z', re.IGNORECASE)
        return pat.match(hostname)

def match_hostname(cert, hostname):
        """Verify that *cert* (in decoded format as returned by
        SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
        rules are followed, but IP addresses are not accepted for *hostname*.

CertificateError is raised on failure. On success, the function
        returns nothing.
        """
        if not cert:
            raise ValueError("empty or no certificate")
        dnsnames = []
        san = cert.get('subjectAltName', ())
        for key, value in san:
            if key == 'DNS':
                if _dnsname_match(value, hostname):
                    return
                dnsnames.append(value)
        if not dnsnames:
            # The subject is only checked when there is no dNSName entry
            # in subjectAltName
            for sub in cert.get('subject', ()):
                for key, value in sub:
                    # XXX according to RFC 2818, the most specific Common Name
                    # must be used.
                    if key == 'commonName':
                        if _dnsname_match(value, hostname):
                            return
                        dnsnames.append(value)
        if len(dnsnames) > 1:
            raise CertificateError("hostname %r "
                "doesn't match either of %s"
                % (hostname, ', '.join(map(repr, dnsnames))))
        elif len(dnsnames) == 1:
            raise CertificateError("hostname %r "
                "doesn't match %r"
                % (hostname, dnsnames[0]))
        else:
            raise CertificateError("no appropriate commonName or "
                "subjectAltName fields were found")

class VerifyingHTTPSHandler(HTTPSHandler):
    """Simple verifying handler: no auth, subclasses, timeouts, etc."""

def __init__(self, ca_bundle):
        self.ca_bundle = ca_bundle
        HTTPSHandler.__init__(self)

def https_open(self, req):
        return self.do_open(
            lambda host, **kw: VerifyingHTTPSConn(host, self.ca_bundle, **kw), req
        )

class VerifyingHTTPSConn(HTTPSConnection):
    """Simple verifying connection: no auth, subclasses, timeouts, etc."""

def __init__(self, host, ca_bundle, **kw):
        HTTPSConnection.__init__(self, host, **kw)
        self.ca_bundle = ca_bundle

def connect(self):
        sock = socket.create_connection(
            (self.host, self.port), getattr(self, 'source_address', None)
        )

# Handle the socket if a (proxy) tunnel is present
        if hasattr(self, '_tunnel') and getattr(self, '_tunnel_host', None):
            self.sock = sock
            self._tunnel()
            # http://bugs.python.org/issue7776: Python>=3.4.1 and >=2.7.7
            # change self.host to mean the proxy server host when tunneling is
            # being used. Adapt, since we are interested in the destination
            # host for the match_hostname() comparison.
            actual_host = self._tunnel_host
        else:
            actual_host = self.host

if hasattr(ssl, 'create_default_context'):
            ctx = ssl.create_default_context(cafile=self.ca_bundle)
            self.sock = ctx.wrap_socket(sock, server_hostname=actual_host)
        else:
            # This is for python < 2.7.9 and < 3.4?
            self.sock = ssl.wrap_socket(
                sock, cert_reqs=ssl.CERT_REQUIRED, ca_certs=self.ca_bundle
            )
        try:
            match_hostname(self.sock.getpeercert(), actual_host)
        except CertificateError:
            self.sock.shutdown(socket.SHUT_RDWR)
            self.sock.close()
            raise

def opener_for(ca_bundle=None):
    """Get a urlopen() replacement that uses ca_bundle for verification"""
    return urllib.request.build_opener(
        VerifyingHTTPSHandler(ca_bundle or find_ca_bundle())
    ).open

# from jaraco.functools
def once(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        if not hasattr(func, 'always_returns'):
            func.always_returns = func(*args, **kwargs)
        return func.always_returns
    return wrapper

@once
def get_win_certfile():
    try:
        import wincertstore
    except ImportError:
        return None

class CertFile(wincertstore.CertFile):
        def __init__(self):
            super(CertFile, self).__init__()
            atexit.register(self.close)

def close(self):
            try:
                super(CertFile, self).close()
            except OSError:
                pass

_wincerts = CertFile()
    _wincerts.addstore('CA')
    _wincerts.addstore('ROOT')
    return _wincerts.name

def find_ca_bundle():
    """Return an existing CA bundle path, or None"""
    extant_cert_paths = filter(os.path.isfile, cert_paths)
    return (
        get_win_certfile()
        or next(extant_cert_paths, None)
        or _certifi_where()
    )

def _certifi_where():
    try:
        return __import__('certifi').where()
    except (ImportError, ResolutionError, ExtractionError):
        pass

cmd: